Source file src/database/sql/fakedb_test.go

Documentation: database/sql

     1  // Copyright 2011 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package sql
     6  
     7  import (
     8  	"context"
     9  	"database/sql/driver"
    10  	"errors"
    11  	"fmt"
    12  	"io"
    13  	"reflect"
    14  	"sort"
    15  	"strconv"
    16  	"strings"
    17  	"sync"
    18  	"testing"
    19  	"time"
    20  )
    21  
    22  // fakeDriver is a fake database that implements Go's driver.Driver
    23  // interface, just for testing.
    24  //
    25  // It speaks a query language that's semantically similar to but
    26  // syntactically different and simpler than SQL.  The syntax is as
    27  // follows:
    28  //
    29  //   WIPE
    30  //   CREATE|<tablename>|<col>=<type>,<col>=<type>,...
    31  //     where types are: "string", [u]int{8,16,32,64}, "bool"
    32  //   INSERT|<tablename>|col=val,col2=val2,col3=?
    33  //   SELECT|<tablename>|projectcol1,projectcol2|filtercol=?,filtercol2=?
    34  //   SELECT|<tablename>|projectcol1,projectcol2|filtercol=?param1,filtercol2=?param2
    35  //
    36  // Any of these can be preceded by PANIC|<method>|, to cause the
    37  // named method on fakeStmt to panic.
    38  //
    39  // Any of these can be proceeded by WAIT|<duration>|, to cause the
    40  // named method on fakeStmt to sleep for the specified duration.
    41  //
    42  // Multiple of these can be combined when separated with a semicolon.
    43  //
    44  // When opening a fakeDriver's database, it starts empty with no
    45  // tables. All tables and data are stored in memory only.
    46  type fakeDriver struct {
    47  	mu         sync.Mutex // guards 3 following fields
    48  	openCount  int        // conn opens
    49  	closeCount int        // conn closes
    50  	waitCh     chan struct{}
    51  	waitingCh  chan struct{}
    52  	dbs        map[string]*fakeDB
    53  }
    54  
    55  type fakeConnector struct {
    56  	name string
    57  
    58  	waiter func(context.Context)
    59  	closed bool
    60  }
    61  
    62  func (c *fakeConnector) Connect(context.Context) (driver.Conn, error) {
    63  	conn, err := fdriver.Open(c.name)
    64  	conn.(*fakeConn).waiter = c.waiter
    65  	return conn, err
    66  }
    67  
    68  func (c *fakeConnector) Driver() driver.Driver {
    69  	return fdriver
    70  }
    71  
    72  func (c *fakeConnector) Close() error {
    73  	if c.closed {
    74  		return errors.New("fakedb: connector is closed")
    75  	}
    76  	c.closed = true
    77  	return nil
    78  }
    79  
    80  type fakeDriverCtx struct {
    81  	fakeDriver
    82  }
    83  
    84  var _ driver.DriverContext = &fakeDriverCtx{}
    85  
    86  func (cc *fakeDriverCtx) OpenConnector(name string) (driver.Connector, error) {
    87  	return &fakeConnector{name: name}, nil
    88  }
    89  
    90  type fakeDB struct {
    91  	name string
    92  
    93  	mu       sync.Mutex
    94  	tables   map[string]*table
    95  	badConn  bool
    96  	allowAny bool
    97  }
    98  
    99  type table struct {
   100  	mu      sync.Mutex
   101  	colname []string
   102  	coltype []string
   103  	rows    []*row
   104  }
   105  
   106  func (t *table) columnIndex(name string) int {
   107  	for n, nname := range t.colname {
   108  		if name == nname {
   109  			return n
   110  		}
   111  	}
   112  	return -1
   113  }
   114  
   115  type row struct {
   116  	cols []interface{} // must be same size as its table colname + coltype
   117  }
   118  
   119  type memToucher interface {
   120  	// touchMem reads & writes some memory, to help find data races.
   121  	touchMem()
   122  }
   123  
   124  type fakeConn struct {
   125  	db *fakeDB // where to return ourselves to
   126  
   127  	currTx *fakeTx
   128  
   129  	// Every operation writes to line to enable the race detector
   130  	// check for data races.
   131  	line int64
   132  
   133  	// Stats for tests:
   134  	mu          sync.Mutex
   135  	stmtsMade   int
   136  	stmtsClosed int
   137  	numPrepare  int
   138  
   139  	// bad connection tests; see isBad()
   140  	bad       bool
   141  	stickyBad bool
   142  
   143  	skipDirtySession bool // tests that use Conn should set this to true.
   144  
   145  	// dirtySession tests ResetSession, true if a query has executed
   146  	// until ResetSession is called.
   147  	dirtySession bool
   148  
   149  	// The waiter is called before each query. May be used in place of the "WAIT"
   150  	// directive.
   151  	waiter func(context.Context)
   152  }
   153  
   154  func (c *fakeConn) touchMem() {
   155  	c.line++
   156  }
   157  
   158  func (c *fakeConn) incrStat(v *int) {
   159  	c.mu.Lock()
   160  	*v++
   161  	c.mu.Unlock()
   162  }
   163  
   164  type fakeTx struct {
   165  	c *fakeConn
   166  }
   167  
   168  type boundCol struct {
   169  	Column      string
   170  	Placeholder string
   171  	Ordinal     int
   172  }
   173  
   174  type fakeStmt struct {
   175  	memToucher
   176  	c *fakeConn
   177  	q string // just for debugging
   178  
   179  	cmd   string
   180  	table string
   181  	panic string
   182  	wait  time.Duration
   183  
   184  	next *fakeStmt // used for returning multiple results.
   185  
   186  	closed bool
   187  
   188  	colName      []string      // used by CREATE, INSERT, SELECT (selected columns)
   189  	colType      []string      // used by CREATE
   190  	colValue     []interface{} // used by INSERT (mix of strings and "?" for bound params)
   191  	placeholders int           // used by INSERT/SELECT: number of ? params
   192  
   193  	whereCol []boundCol // used by SELECT (all placeholders)
   194  
   195  	placeholderConverter []driver.ValueConverter // used by INSERT
   196  }
   197  
   198  var fdriver driver.Driver = &fakeDriver{}
   199  
   200  func init() {
   201  	Register("test", fdriver)
   202  }
   203  
   204  func contains(list []string, y string) bool {
   205  	for _, x := range list {
   206  		if x == y {
   207  			return true
   208  		}
   209  	}
   210  	return false
   211  }
   212  
   213  type Dummy struct {
   214  	driver.Driver
   215  }
   216  
   217  func TestDrivers(t *testing.T) {
   218  	unregisterAllDrivers()
   219  	Register("test", fdriver)
   220  	Register("invalid", Dummy{})
   221  	all := Drivers()
   222  	if len(all) < 2 || !sort.StringsAreSorted(all) || !contains(all, "test") || !contains(all, "invalid") {
   223  		t.Fatalf("Drivers = %v, want sorted list with at least [invalid, test]", all)
   224  	}
   225  }
   226  
   227  // hook to simulate connection failures
   228  var hookOpenErr struct {
   229  	sync.Mutex
   230  	fn func() error
   231  }
   232  
   233  func setHookOpenErr(fn func() error) {
   234  	hookOpenErr.Lock()
   235  	defer hookOpenErr.Unlock()
   236  	hookOpenErr.fn = fn
   237  }
   238  
   239  // Supports dsn forms:
   240  //    <dbname>
   241  //    <dbname>;<opts>  (only currently supported option is `badConn`,
   242  //                      which causes driver.ErrBadConn to be returned on
   243  //                      every other conn.Begin())
   244  func (d *fakeDriver) Open(dsn string) (driver.Conn, error) {
   245  	hookOpenErr.Lock()
   246  	fn := hookOpenErr.fn
   247  	hookOpenErr.Unlock()
   248  	if fn != nil {
   249  		if err := fn(); err != nil {
   250  			return nil, err
   251  		}
   252  	}
   253  	parts := strings.Split(dsn, ";")
   254  	if len(parts) < 1 {
   255  		return nil, errors.New("fakedb: no database name")
   256  	}
   257  	name := parts[0]
   258  
   259  	db := d.getDB(name)
   260  
   261  	d.mu.Lock()
   262  	d.openCount++
   263  	d.mu.Unlock()
   264  	conn := &fakeConn{db: db}
   265  
   266  	if len(parts) >= 2 && parts[1] == "badConn" {
   267  		conn.bad = true
   268  	}
   269  	if d.waitCh != nil {
   270  		d.waitingCh <- struct{}{}
   271  		<-d.waitCh
   272  		d.waitCh = nil
   273  		d.waitingCh = nil
   274  	}
   275  	return conn, nil
   276  }
   277  
   278  func (d *fakeDriver) getDB(name string) *fakeDB {
   279  	d.mu.Lock()
   280  	defer d.mu.Unlock()
   281  	if d.dbs == nil {
   282  		d.dbs = make(map[string]*fakeDB)
   283  	}
   284  	db, ok := d.dbs[name]
   285  	if !ok {
   286  		db = &fakeDB{name: name}
   287  		d.dbs[name] = db
   288  	}
   289  	return db
   290  }
   291  
   292  func (db *fakeDB) wipe() {
   293  	db.mu.Lock()
   294  	defer db.mu.Unlock()
   295  	db.tables = nil
   296  }
   297  
   298  func (db *fakeDB) createTable(name string, columnNames, columnTypes []string) error {
   299  	db.mu.Lock()
   300  	defer db.mu.Unlock()
   301  	if db.tables == nil {
   302  		db.tables = make(map[string]*table)
   303  	}
   304  	if _, exist := db.tables[name]; exist {
   305  		return fmt.Errorf("fakedb: table %q already exists", name)
   306  	}
   307  	if len(columnNames) != len(columnTypes) {
   308  		return fmt.Errorf("fakedb: create table of %q len(names) != len(types): %d vs %d",
   309  			name, len(columnNames), len(columnTypes))
   310  	}
   311  	db.tables[name] = &table{colname: columnNames, coltype: columnTypes}
   312  	return nil
   313  }
   314  
   315  // must be called with db.mu lock held
   316  func (db *fakeDB) table(table string) (*table, bool) {
   317  	if db.tables == nil {
   318  		return nil, false
   319  	}
   320  	t, ok := db.tables[table]
   321  	return t, ok
   322  }
   323  
   324  func (db *fakeDB) columnType(table, column string) (typ string, ok bool) {
   325  	db.mu.Lock()
   326  	defer db.mu.Unlock()
   327  	t, ok := db.table(table)
   328  	if !ok {
   329  		return
   330  	}
   331  	for n, cname := range t.colname {
   332  		if cname == column {
   333  			return t.coltype[n], true
   334  		}
   335  	}
   336  	return "", false
   337  }
   338  
   339  func (c *fakeConn) isBad() bool {
   340  	if c.stickyBad {
   341  		return true
   342  	} else if c.bad {
   343  		if c.db == nil {
   344  			return false
   345  		}
   346  		// alternate between bad conn and not bad conn
   347  		c.db.badConn = !c.db.badConn
   348  		return c.db.badConn
   349  	} else {
   350  		return false
   351  	}
   352  }
   353  
   354  func (c *fakeConn) isDirtyAndMark() bool {
   355  	if c.skipDirtySession {
   356  		return false
   357  	}
   358  	if c.currTx != nil {
   359  		c.dirtySession = true
   360  		return false
   361  	}
   362  	if c.dirtySession {
   363  		return true
   364  	}
   365  	c.dirtySession = true
   366  	return false
   367  }
   368  
   369  func (c *fakeConn) Begin() (driver.Tx, error) {
   370  	if c.isBad() {
   371  		return nil, driver.ErrBadConn
   372  	}
   373  	if c.currTx != nil {
   374  		return nil, errors.New("fakedb: already in a transaction")
   375  	}
   376  	c.touchMem()
   377  	c.currTx = &fakeTx{c: c}
   378  	return c.currTx, nil
   379  }
   380  
   381  var hookPostCloseConn struct {
   382  	sync.Mutex
   383  	fn func(*fakeConn, error)
   384  }
   385  
   386  func setHookpostCloseConn(fn func(*fakeConn, error)) {
   387  	hookPostCloseConn.Lock()
   388  	defer hookPostCloseConn.Unlock()
   389  	hookPostCloseConn.fn = fn
   390  }
   391  
   392  var testStrictClose *testing.T
   393  
   394  // setStrictFakeConnClose sets the t to Errorf on when fakeConn.Close
   395  // fails to close. If nil, the check is disabled.
   396  func setStrictFakeConnClose(t *testing.T) {
   397  	testStrictClose = t
   398  }
   399  
   400  func (c *fakeConn) ResetSession(ctx context.Context) error {
   401  	c.dirtySession = false
   402  	c.currTx = nil
   403  	if c.isBad() {
   404  		return driver.ErrBadConn
   405  	}
   406  	return nil
   407  }
   408  
   409  var _ driver.Validator = (*fakeConn)(nil)
   410  
   411  func (c *fakeConn) IsValid() bool {
   412  	return !c.isBad()
   413  }
   414  
   415  func (c *fakeConn) Close() (err error) {
   416  	drv := fdriver.(*fakeDriver)
   417  	defer func() {
   418  		if err != nil && testStrictClose != nil {
   419  			testStrictClose.Errorf("failed to close a test fakeConn: %v", err)
   420  		}
   421  		hookPostCloseConn.Lock()
   422  		fn := hookPostCloseConn.fn
   423  		hookPostCloseConn.Unlock()
   424  		if fn != nil {
   425  			fn(c, err)
   426  		}
   427  		if err == nil {
   428  			drv.mu.Lock()
   429  			drv.closeCount++
   430  			drv.mu.Unlock()
   431  		}
   432  	}()
   433  	c.touchMem()
   434  	if c.currTx != nil {
   435  		return errors.New("fakedb: can't close fakeConn; in a Transaction")
   436  	}
   437  	if c.db == nil {
   438  		return errors.New("fakedb: can't close fakeConn; already closed")
   439  	}
   440  	if c.stmtsMade > c.stmtsClosed {
   441  		return errors.New("fakedb: can't close; dangling statement(s)")
   442  	}
   443  	c.db = nil
   444  	return nil
   445  }
   446  
   447  func checkSubsetTypes(allowAny bool, args []driver.NamedValue) error {
   448  	for _, arg := range args {
   449  		switch arg.Value.(type) {
   450  		case int64, float64, bool, nil, []byte, string, time.Time:
   451  		default:
   452  			if !allowAny {
   453  				return fmt.Errorf("fakedb: invalid argument ordinal %[1]d: %[2]v, type %[2]T", arg.Ordinal, arg.Value)
   454  			}
   455  		}
   456  	}
   457  	return nil
   458  }
   459  
   460  func (c *fakeConn) Exec(query string, args []driver.Value) (driver.Result, error) {
   461  	// Ensure that ExecContext is called if available.
   462  	panic("ExecContext was not called.")
   463  }
   464  
   465  func (c *fakeConn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
   466  	// This is an optional interface, but it's implemented here
   467  	// just to check that all the args are of the proper types.
   468  	// ErrSkip is returned so the caller acts as if we didn't
   469  	// implement this at all.
   470  	err := checkSubsetTypes(c.db.allowAny, args)
   471  	if err != nil {
   472  		return nil, err
   473  	}
   474  	return nil, driver.ErrSkip
   475  }
   476  
   477  func (c *fakeConn) Query(query string, args []driver.Value) (driver.Rows, error) {
   478  	// Ensure that ExecContext is called if available.
   479  	panic("QueryContext was not called.")
   480  }
   481  
   482  func (c *fakeConn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
   483  	// This is an optional interface, but it's implemented here
   484  	// just to check that all the args are of the proper types.
   485  	// ErrSkip is returned so the caller acts as if we didn't
   486  	// implement this at all.
   487  	err := checkSubsetTypes(c.db.allowAny, args)
   488  	if err != nil {
   489  		return nil, err
   490  	}
   491  	return nil, driver.ErrSkip
   492  }
   493  
   494  func errf(msg string, args ...interface{}) error {
   495  	return errors.New("fakedb: " + fmt.Sprintf(msg, args...))
   496  }
   497  
   498  // parts are table|selectCol1,selectCol2|whereCol=?,whereCol2=?
   499  // (note that where columns must always contain ? marks,
   500  //  just a limitation for fakedb)
   501  func (c *fakeConn) prepareSelect(stmt *fakeStmt, parts []string) (*fakeStmt, error) {
   502  	if len(parts) != 3 {
   503  		stmt.Close()
   504  		return nil, errf("invalid SELECT syntax with %d parts; want 3", len(parts))
   505  	}
   506  	stmt.table = parts[0]
   507  
   508  	stmt.colName = strings.Split(parts[1], ",")
   509  	for n, colspec := range strings.Split(parts[2], ",") {
   510  		if colspec == "" {
   511  			continue
   512  		}
   513  		nameVal := strings.Split(colspec, "=")
   514  		if len(nameVal) != 2 {
   515  			stmt.Close()
   516  			return nil, errf("SELECT on table %q has invalid column spec of %q (index %d)", stmt.table, colspec, n)
   517  		}
   518  		column, value := nameVal[0], nameVal[1]
   519  		_, ok := c.db.columnType(stmt.table, column)
   520  		if !ok {
   521  			stmt.Close()
   522  			return nil, errf("SELECT on table %q references non-existent column %q", stmt.table, column)
   523  		}
   524  		if !strings.HasPrefix(value, "?") {
   525  			stmt.Close()
   526  			return nil, errf("SELECT on table %q has pre-bound value for where column %q; need a question mark",
   527  				stmt.table, column)
   528  		}
   529  		stmt.placeholders++
   530  		stmt.whereCol = append(stmt.whereCol, boundCol{Column: column, Placeholder: value, Ordinal: stmt.placeholders})
   531  	}
   532  	return stmt, nil
   533  }
   534  
   535  // parts are table|col=type,col2=type2
   536  func (c *fakeConn) prepareCreate(stmt *fakeStmt, parts []string) (*fakeStmt, error) {
   537  	if len(parts) != 2 {
   538  		stmt.Close()
   539  		return nil, errf("invalid CREATE syntax with %d parts; want 2", len(parts))
   540  	}
   541  	stmt.table = parts[0]
   542  	for n, colspec := range strings.Split(parts[1], ",") {
   543  		nameType := strings.Split(colspec, "=")
   544  		if len(nameType) != 2 {
   545  			stmt.Close()
   546  			return nil, errf("CREATE table %q has invalid column spec of %q (index %d)", stmt.table, colspec, n)
   547  		}
   548  		stmt.colName = append(stmt.colName, nameType[0])
   549  		stmt.colType = append(stmt.colType, nameType[1])
   550  	}
   551  	return stmt, nil
   552  }
   553  
   554  // parts are table|col=?,col2=val
   555  func (c *fakeConn) prepareInsert(ctx context.Context, stmt *fakeStmt, parts []string) (*fakeStmt, error) {
   556  	if len(parts) != 2 {
   557  		stmt.Close()
   558  		return nil, errf("invalid INSERT syntax with %d parts; want 2", len(parts))
   559  	}
   560  	stmt.table = parts[0]
   561  	for n, colspec := range strings.Split(parts[1], ",") {
   562  		nameVal := strings.Split(colspec, "=")
   563  		if len(nameVal) != 2 {
   564  			stmt.Close()
   565  			return nil, errf("INSERT table %q has invalid column spec of %q (index %d)", stmt.table, colspec, n)
   566  		}
   567  		column, value := nameVal[0], nameVal[1]
   568  		ctype, ok := c.db.columnType(stmt.table, column)
   569  		if !ok {
   570  			stmt.Close()
   571  			return nil, errf("INSERT table %q references non-existent column %q", stmt.table, column)
   572  		}
   573  		stmt.colName = append(stmt.colName, column)
   574  
   575  		if !strings.HasPrefix(value, "?") {
   576  			var subsetVal interface{}
   577  			// Convert to driver subset type
   578  			switch ctype {
   579  			case "string":
   580  				subsetVal = []byte(value)
   581  			case "blob":
   582  				subsetVal = []byte(value)
   583  			case "int32":
   584  				i, err := strconv.Atoi(value)
   585  				if err != nil {
   586  					stmt.Close()
   587  					return nil, errf("invalid conversion to int32 from %q", value)
   588  				}
   589  				subsetVal = int64(i) // int64 is a subset type, but not int32
   590  			case "table": // For testing cursor reads.
   591  				c.skipDirtySession = true
   592  				vparts := strings.Split(value, "!")
   593  
   594  				substmt, err := c.PrepareContext(ctx, fmt.Sprintf("SELECT|%s|%s|", vparts[0], strings.Join(vparts[1:], ",")))
   595  				if err != nil {
   596  					return nil, err
   597  				}
   598  				cursor, err := (substmt.(driver.StmtQueryContext)).QueryContext(ctx, []driver.NamedValue{})
   599  				substmt.Close()
   600  				if err != nil {
   601  					return nil, err
   602  				}
   603  				subsetVal = cursor
   604  			default:
   605  				stmt.Close()
   606  				return nil, errf("unsupported conversion for pre-bound parameter %q to type %q", value, ctype)
   607  			}
   608  			stmt.colValue = append(stmt.colValue, subsetVal)
   609  		} else {
   610  			stmt.placeholders++
   611  			stmt.placeholderConverter = append(stmt.placeholderConverter, converterForType(ctype))
   612  			stmt.colValue = append(stmt.colValue, value)
   613  		}
   614  	}
   615  	return stmt, nil
   616  }
   617  
   618  // hook to simulate broken connections
   619  var hookPrepareBadConn func() bool
   620  
   621  func (c *fakeConn) Prepare(query string) (driver.Stmt, error) {
   622  	panic("use PrepareContext")
   623  }
   624  
   625  func (c *fakeConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
   626  	c.numPrepare++
   627  	if c.db == nil {
   628  		panic("nil c.db; conn = " + fmt.Sprintf("%#v", c))
   629  	}
   630  
   631  	if c.stickyBad || (hookPrepareBadConn != nil && hookPrepareBadConn()) {
   632  		return nil, driver.ErrBadConn
   633  	}
   634  
   635  	c.touchMem()
   636  	var firstStmt, prev *fakeStmt
   637  	for _, query := range strings.Split(query, ";") {
   638  		parts := strings.Split(query, "|")
   639  		if len(parts) < 1 {
   640  			return nil, errf("empty query")
   641  		}
   642  		stmt := &fakeStmt{q: query, c: c, memToucher: c}
   643  		if firstStmt == nil {
   644  			firstStmt = stmt
   645  		}
   646  		if len(parts) >= 3 {
   647  			switch parts[0] {
   648  			case "PANIC":
   649  				stmt.panic = parts[1]
   650  				parts = parts[2:]
   651  			case "WAIT":
   652  				wait, err := time.ParseDuration(parts[1])
   653  				if err != nil {
   654  					return nil, errf("expected section after WAIT to be a duration, got %q %v", parts[1], err)
   655  				}
   656  				parts = parts[2:]
   657  				stmt.wait = wait
   658  			}
   659  		}
   660  		cmd := parts[0]
   661  		stmt.cmd = cmd
   662  		parts = parts[1:]
   663  
   664  		if c.waiter != nil {
   665  			c.waiter(ctx)
   666  		}
   667  
   668  		if stmt.wait > 0 {
   669  			wait := time.NewTimer(stmt.wait)
   670  			select {
   671  			case <-wait.C:
   672  			case <-ctx.Done():
   673  				wait.Stop()
   674  				return nil, ctx.Err()
   675  			}
   676  		}
   677  
   678  		c.incrStat(&c.stmtsMade)
   679  		var err error
   680  		switch cmd {
   681  		case "WIPE":
   682  			// Nothing
   683  		case "SELECT":
   684  			stmt, err = c.prepareSelect(stmt, parts)
   685  		case "CREATE":
   686  			stmt, err = c.prepareCreate(stmt, parts)
   687  		case "INSERT":
   688  			stmt, err = c.prepareInsert(ctx, stmt, parts)
   689  		case "NOSERT":
   690  			// Do all the prep-work like for an INSERT but don't actually insert the row.
   691  			// Used for some of the concurrent tests.
   692  			stmt, err = c.prepareInsert(ctx, stmt, parts)
   693  		default:
   694  			stmt.Close()
   695  			return nil, errf("unsupported command type %q", cmd)
   696  		}
   697  		if err != nil {
   698  			return nil, err
   699  		}
   700  		if prev != nil {
   701  			prev.next = stmt
   702  		}
   703  		prev = stmt
   704  	}
   705  	return firstStmt, nil
   706  }
   707  
   708  func (s *fakeStmt) ColumnConverter(idx int) driver.ValueConverter {
   709  	if s.panic == "ColumnConverter" {
   710  		panic(s.panic)
   711  	}
   712  	if len(s.placeholderConverter) == 0 {
   713  		return driver.DefaultParameterConverter
   714  	}
   715  	return s.placeholderConverter[idx]
   716  }
   717  
   718  func (s *fakeStmt) Close() error {
   719  	if s.panic == "Close" {
   720  		panic(s.panic)
   721  	}
   722  	if s.c == nil {
   723  		panic("nil conn in fakeStmt.Close")
   724  	}
   725  	if s.c.db == nil {
   726  		panic("in fakeStmt.Close, conn's db is nil (already closed)")
   727  	}
   728  	s.touchMem()
   729  	if !s.closed {
   730  		s.c.incrStat(&s.c.stmtsClosed)
   731  		s.closed = true
   732  	}
   733  	if s.next != nil {
   734  		s.next.Close()
   735  	}
   736  	return nil
   737  }
   738  
   739  var errClosed = errors.New("fakedb: statement has been closed")
   740  
   741  // hook to simulate broken connections
   742  var hookExecBadConn func() bool
   743  
   744  func (s *fakeStmt) Exec(args []driver.Value) (driver.Result, error) {
   745  	panic("Using ExecContext")
   746  }
   747  
   748  var errFakeConnSessionDirty = errors.New("fakedb: session is dirty")
   749  
   750  func (s *fakeStmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
   751  	if s.panic == "Exec" {
   752  		panic(s.panic)
   753  	}
   754  	if s.closed {
   755  		return nil, errClosed
   756  	}
   757  
   758  	if s.c.stickyBad || (hookExecBadConn != nil && hookExecBadConn()) {
   759  		return nil, driver.ErrBadConn
   760  	}
   761  	if s.c.isDirtyAndMark() {
   762  		return nil, errFakeConnSessionDirty
   763  	}
   764  
   765  	err := checkSubsetTypes(s.c.db.allowAny, args)
   766  	if err != nil {
   767  		return nil, err
   768  	}
   769  	s.touchMem()
   770  
   771  	if s.wait > 0 {
   772  		time.Sleep(s.wait)
   773  	}
   774  
   775  	select {
   776  	default:
   777  	case <-ctx.Done():
   778  		return nil, ctx.Err()
   779  	}
   780  
   781  	db := s.c.db
   782  	switch s.cmd {
   783  	case "WIPE":
   784  		db.wipe()
   785  		return driver.ResultNoRows, nil
   786  	case "CREATE":
   787  		if err := db.createTable(s.table, s.colName, s.colType); err != nil {
   788  			return nil, err
   789  		}
   790  		return driver.ResultNoRows, nil
   791  	case "INSERT":
   792  		return s.execInsert(args, true)
   793  	case "NOSERT":
   794  		// Do all the prep-work like for an INSERT but don't actually insert the row.
   795  		// Used for some of the concurrent tests.
   796  		return s.execInsert(args, false)
   797  	}
   798  	return nil, fmt.Errorf("fakedb: unimplemented statement Exec command type of %q", s.cmd)
   799  }
   800  
   801  // When doInsert is true, add the row to the table.
   802  // When doInsert is false do prep-work and error checking, but don't
   803  // actually add the row to the table.
   804  func (s *fakeStmt) execInsert(args []driver.NamedValue, doInsert bool) (driver.Result, error) {
   805  	db := s.c.db
   806  	if len(args) != s.placeholders {
   807  		panic("error in pkg db; should only get here if size is correct")
   808  	}
   809  	db.mu.Lock()
   810  	t, ok := db.table(s.table)
   811  	db.mu.Unlock()
   812  	if !ok {
   813  		return nil, fmt.Errorf("fakedb: table %q doesn't exist", s.table)
   814  	}
   815  
   816  	t.mu.Lock()
   817  	defer t.mu.Unlock()
   818  
   819  	var cols []interface{}
   820  	if doInsert {
   821  		cols = make([]interface{}, len(t.colname))
   822  	}
   823  	argPos := 0
   824  	for n, colname := range s.colName {
   825  		colidx := t.columnIndex(colname)
   826  		if colidx == -1 {
   827  			return nil, fmt.Errorf("fakedb: column %q doesn't exist or dropped since prepared statement was created", colname)
   828  		}
   829  		var val interface{}
   830  		if strvalue, ok := s.colValue[n].(string); ok && strings.HasPrefix(strvalue, "?") {
   831  			if strvalue == "?" {
   832  				val = args[argPos].Value
   833  			} else {
   834  				// Assign value from argument placeholder name.
   835  				for _, a := range args {
   836  					if a.Name == strvalue[1:] {
   837  						val = a.Value
   838  						break
   839  					}
   840  				}
   841  			}
   842  			argPos++
   843  		} else {
   844  			val = s.colValue[n]
   845  		}
   846  		if doInsert {
   847  			cols[colidx] = val
   848  		}
   849  	}
   850  
   851  	if doInsert {
   852  		t.rows = append(t.rows, &row{cols: cols})
   853  	}
   854  	return driver.RowsAffected(1), nil
   855  }
   856  
   857  // hook to simulate broken connections
   858  var hookQueryBadConn func() bool
   859  
   860  func (s *fakeStmt) Query(args []driver.Value) (driver.Rows, error) {
   861  	panic("Use QueryContext")
   862  }
   863  
   864  func (s *fakeStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
   865  	if s.panic == "Query" {
   866  		panic(s.panic)
   867  	}
   868  	if s.closed {
   869  		return nil, errClosed
   870  	}
   871  
   872  	if s.c.stickyBad || (hookQueryBadConn != nil && hookQueryBadConn()) {
   873  		return nil, driver.ErrBadConn
   874  	}
   875  	if s.c.isDirtyAndMark() {
   876  		return nil, errFakeConnSessionDirty
   877  	}
   878  
   879  	err := checkSubsetTypes(s.c.db.allowAny, args)
   880  	if err != nil {
   881  		return nil, err
   882  	}
   883  
   884  	s.touchMem()
   885  	db := s.c.db
   886  	if len(args) != s.placeholders {
   887  		panic("error in pkg db; should only get here if size is correct")
   888  	}
   889  
   890  	setMRows := make([][]*row, 0, 1)
   891  	setColumns := make([][]string, 0, 1)
   892  	setColType := make([][]string, 0, 1)
   893  
   894  	for {
   895  		db.mu.Lock()
   896  		t, ok := db.table(s.table)
   897  		db.mu.Unlock()
   898  		if !ok {
   899  			return nil, fmt.Errorf("fakedb: table %q doesn't exist", s.table)
   900  		}
   901  
   902  		if s.table == "magicquery" {
   903  			if len(s.whereCol) == 2 && s.whereCol[0].Column == "op" && s.whereCol[1].Column == "millis" {
   904  				if args[0].Value == "sleep" {
   905  					time.Sleep(time.Duration(args[1].Value.(int64)) * time.Millisecond)
   906  				}
   907  			}
   908  		}
   909  		if s.table == "tx_status" && s.colName[0] == "tx_status" {
   910  			txStatus := "autocommit"
   911  			if s.c.currTx != nil {
   912  				txStatus = "transaction"
   913  			}
   914  			cursor := &rowsCursor{
   915  				parentMem: s.c,
   916  				posRow:    -1,
   917  				rows: [][]*row{
   918  					{
   919  						{
   920  							cols: []interface{}{
   921  								txStatus,
   922  							},
   923  						},
   924  					},
   925  				},
   926  				cols: [][]string{
   927  					{
   928  						"tx_status",
   929  					},
   930  				},
   931  				colType: [][]string{
   932  					{
   933  						"string",
   934  					},
   935  				},
   936  				errPos: -1,
   937  			}
   938  			return cursor, nil
   939  		}
   940  
   941  		t.mu.Lock()
   942  
   943  		colIdx := make(map[string]int) // select column name -> column index in table
   944  		for _, name := range s.colName {
   945  			idx := t.columnIndex(name)
   946  			if idx == -1 {
   947  				t.mu.Unlock()
   948  				return nil, fmt.Errorf("fakedb: unknown column name %q", name)
   949  			}
   950  			colIdx[name] = idx
   951  		}
   952  
   953  		mrows := []*row{}
   954  	rows:
   955  		for _, trow := range t.rows {
   956  			// Process the where clause, skipping non-match rows. This is lazy
   957  			// and just uses fmt.Sprintf("%v") to test equality. Good enough
   958  			// for test code.
   959  			for _, wcol := range s.whereCol {
   960  				idx := t.columnIndex(wcol.Column)
   961  				if idx == -1 {
   962  					t.mu.Unlock()
   963  					return nil, fmt.Errorf("fakedb: invalid where clause column %q", wcol)
   964  				}
   965  				tcol := trow.cols[idx]
   966  				if bs, ok := tcol.([]byte); ok {
   967  					// lazy hack to avoid sprintf %v on a []byte
   968  					tcol = string(bs)
   969  				}
   970  				var argValue interface{}
   971  				if wcol.Placeholder == "?" {
   972  					argValue = args[wcol.Ordinal-1].Value
   973  				} else {
   974  					// Assign arg value from placeholder name.
   975  					for _, a := range args {
   976  						if a.Name == wcol.Placeholder[1:] {
   977  							argValue = a.Value
   978  							break
   979  						}
   980  					}
   981  				}
   982  				if fmt.Sprintf("%v", tcol) != fmt.Sprintf("%v", argValue) {
   983  					continue rows
   984  				}
   985  			}
   986  			mrow := &row{cols: make([]interface{}, len(s.colName))}
   987  			for seli, name := range s.colName {
   988  				mrow.cols[seli] = trow.cols[colIdx[name]]
   989  			}
   990  			mrows = append(mrows, mrow)
   991  		}
   992  
   993  		var colType []string
   994  		for _, column := range s.colName {
   995  			colType = append(colType, t.coltype[t.columnIndex(column)])
   996  		}
   997  
   998  		t.mu.Unlock()
   999  
  1000  		setMRows = append(setMRows, mrows)
  1001  		setColumns = append(setColumns, s.colName)
  1002  		setColType = append(setColType, colType)
  1003  
  1004  		if s.next == nil {
  1005  			break
  1006  		}
  1007  		s = s.next
  1008  	}
  1009  
  1010  	cursor := &rowsCursor{
  1011  		parentMem: s.c,
  1012  		posRow:    -1,
  1013  		rows:      setMRows,
  1014  		cols:      setColumns,
  1015  		colType:   setColType,
  1016  		errPos:    -1,
  1017  	}
  1018  	return cursor, nil
  1019  }
  1020  
  1021  func (s *fakeStmt) NumInput() int {
  1022  	if s.panic == "NumInput" {
  1023  		panic(s.panic)
  1024  	}
  1025  	return s.placeholders
  1026  }
  1027  
  1028  // hook to simulate broken connections
  1029  var hookCommitBadConn func() bool
  1030  
  1031  func (tx *fakeTx) Commit() error {
  1032  	tx.c.currTx = nil
  1033  	if hookCommitBadConn != nil && hookCommitBadConn() {
  1034  		return driver.ErrBadConn
  1035  	}
  1036  	tx.c.touchMem()
  1037  	return nil
  1038  }
  1039  
  1040  // hook to simulate broken connections
  1041  var hookRollbackBadConn func() bool
  1042  
  1043  func (tx *fakeTx) Rollback() error {
  1044  	tx.c.currTx = nil
  1045  	if hookRollbackBadConn != nil && hookRollbackBadConn() {
  1046  		return driver.ErrBadConn
  1047  	}
  1048  	tx.c.touchMem()
  1049  	return nil
  1050  }
  1051  
  1052  type rowsCursor struct {
  1053  	parentMem memToucher
  1054  	cols      [][]string
  1055  	colType   [][]string
  1056  	posSet    int
  1057  	posRow    int
  1058  	rows      [][]*row
  1059  	closed    bool
  1060  
  1061  	// errPos and err are for making Next return early with error.
  1062  	errPos int
  1063  	err    error
  1064  
  1065  	// a clone of slices to give out to clients, indexed by the
  1066  	// original slice's first byte address.  we clone them
  1067  	// just so we're able to corrupt them on close.
  1068  	bytesClone map[*byte][]byte
  1069  
  1070  	// Every operation writes to line to enable the race detector
  1071  	// check for data races.
  1072  	// This is separate from the fakeConn.line to allow for drivers that
  1073  	// can start multiple queries on the same transaction at the same time.
  1074  	line int64
  1075  }
  1076  
  1077  func (rc *rowsCursor) touchMem() {
  1078  	rc.parentMem.touchMem()
  1079  	rc.line++
  1080  }
  1081  
  1082  func (rc *rowsCursor) Close() error {
  1083  	rc.touchMem()
  1084  	rc.parentMem.touchMem()
  1085  	rc.closed = true
  1086  	return nil
  1087  }
  1088  
  1089  func (rc *rowsCursor) Columns() []string {
  1090  	return rc.cols[rc.posSet]
  1091  }
  1092  
  1093  func (rc *rowsCursor) ColumnTypeScanType(index int) reflect.Type {
  1094  	return colTypeToReflectType(rc.colType[rc.posSet][index])
  1095  }
  1096  
  1097  var rowsCursorNextHook func(dest []driver.Value) error
  1098  
  1099  func (rc *rowsCursor) Next(dest []driver.Value) error {
  1100  	if rowsCursorNextHook != nil {
  1101  		return rowsCursorNextHook(dest)
  1102  	}
  1103  
  1104  	if rc.closed {
  1105  		return errors.New("fakedb: cursor is closed")
  1106  	}
  1107  	rc.touchMem()
  1108  	rc.posRow++
  1109  	if rc.posRow == rc.errPos {
  1110  		return rc.err
  1111  	}
  1112  	if rc.posRow >= len(rc.rows[rc.posSet]) {
  1113  		return io.EOF // per interface spec
  1114  	}
  1115  	for i, v := range rc.rows[rc.posSet][rc.posRow].cols {
  1116  		// TODO(bradfitz): convert to subset types? naah, I
  1117  		// think the subset types should only be input to
  1118  		// driver, but the sql package should be able to handle
  1119  		// a wider range of types coming out of drivers. all
  1120  		// for ease of drivers, and to prevent drivers from
  1121  		// messing up conversions or doing them differently.
  1122  		dest[i] = v
  1123  
  1124  		if bs, ok := v.([]byte); ok {
  1125  			if rc.bytesClone == nil {
  1126  				rc.bytesClone = make(map[*byte][]byte)
  1127  			}
  1128  			clone, ok := rc.bytesClone[&bs[0]]
  1129  			if !ok {
  1130  				clone = make([]byte, len(bs))
  1131  				copy(clone, bs)
  1132  				rc.bytesClone[&bs[0]] = clone
  1133  			}
  1134  			dest[i] = clone
  1135  		}
  1136  	}
  1137  	return nil
  1138  }
  1139  
  1140  func (rc *rowsCursor) HasNextResultSet() bool {
  1141  	rc.touchMem()
  1142  	return rc.posSet < len(rc.rows)-1
  1143  }
  1144  
  1145  func (rc *rowsCursor) NextResultSet() error {
  1146  	rc.touchMem()
  1147  	if rc.HasNextResultSet() {
  1148  		rc.posSet++
  1149  		rc.posRow = -1
  1150  		return nil
  1151  	}
  1152  	return io.EOF // Per interface spec.
  1153  }
  1154  
  1155  // fakeDriverString is like driver.String, but indirects pointers like
  1156  // DefaultValueConverter.
  1157  //
  1158  // This could be surprising behavior to retroactively apply to
  1159  // driver.String now that Go1 is out, but this is convenient for
  1160  // our TestPointerParamsAndScans.
  1161  //
  1162  type fakeDriverString struct{}
  1163  
  1164  func (fakeDriverString) ConvertValue(v interface{}) (driver.Value, error) {
  1165  	switch c := v.(type) {
  1166  	case string, []byte:
  1167  		return v, nil
  1168  	case *string:
  1169  		if c == nil {
  1170  			return nil, nil
  1171  		}
  1172  		return *c, nil
  1173  	}
  1174  	return fmt.Sprintf("%v", v), nil
  1175  }
  1176  
  1177  type anyTypeConverter struct{}
  1178  
  1179  func (anyTypeConverter) ConvertValue(v interface{}) (driver.Value, error) {
  1180  	return v, nil
  1181  }
  1182  
  1183  func converterForType(typ string) driver.ValueConverter {
  1184  	switch typ {
  1185  	case "bool":
  1186  		return driver.Bool
  1187  	case "nullbool":
  1188  		return driver.Null{Converter: driver.Bool}
  1189  	case "byte", "int16":
  1190  		return driver.NotNull{Converter: driver.DefaultParameterConverter}
  1191  	case "int32":
  1192  		return driver.Int32
  1193  	case "nullbyte", "nullint32", "nullint16":
  1194  		return driver.Null{Converter: driver.DefaultParameterConverter}
  1195  	case "string":
  1196  		return driver.NotNull{Converter: fakeDriverString{}}
  1197  	case "nullstring":
  1198  		return driver.Null{Converter: fakeDriverString{}}
  1199  	case "int64":
  1200  		// TODO(coopernurse): add type-specific converter
  1201  		return driver.NotNull{Converter: driver.DefaultParameterConverter}
  1202  	case "nullint64":
  1203  		// TODO(coopernurse): add type-specific converter
  1204  		return driver.Null{Converter: driver.DefaultParameterConverter}
  1205  	case "float64":
  1206  		// TODO(coopernurse): add type-specific converter
  1207  		return driver.NotNull{Converter: driver.DefaultParameterConverter}
  1208  	case "nullfloat64":
  1209  		// TODO(coopernurse): add type-specific converter
  1210  		return driver.Null{Converter: driver.DefaultParameterConverter}
  1211  	case "datetime":
  1212  		return driver.NotNull{Converter: driver.DefaultParameterConverter}
  1213  	case "nulldatetime":
  1214  		return driver.Null{Converter: driver.DefaultParameterConverter}
  1215  	case "any":
  1216  		return anyTypeConverter{}
  1217  	}
  1218  	panic("invalid fakedb column type of " + typ)
  1219  }
  1220  
  1221  func colTypeToReflectType(typ string) reflect.Type {
  1222  	switch typ {
  1223  	case "bool":
  1224  		return reflect.TypeOf(false)
  1225  	case "nullbool":
  1226  		return reflect.TypeOf(NullBool{})
  1227  	case "int16":
  1228  		return reflect.TypeOf(int16(0))
  1229  	case "nullint16":
  1230  		return reflect.TypeOf(NullInt16{})
  1231  	case "int32":
  1232  		return reflect.TypeOf(int32(0))
  1233  	case "nullint32":
  1234  		return reflect.TypeOf(NullInt32{})
  1235  	case "string":
  1236  		return reflect.TypeOf("")
  1237  	case "nullstring":
  1238  		return reflect.TypeOf(NullString{})
  1239  	case "int64":
  1240  		return reflect.TypeOf(int64(0))
  1241  	case "nullint64":
  1242  		return reflect.TypeOf(NullInt64{})
  1243  	case "float64":
  1244  		return reflect.TypeOf(float64(0))
  1245  	case "nullfloat64":
  1246  		return reflect.TypeOf(NullFloat64{})
  1247  	case "datetime":
  1248  		return reflect.TypeOf(time.Time{})
  1249  	case "any":
  1250  		return reflect.TypeOf(new(interface{})).Elem()
  1251  	}
  1252  	panic("invalid fakedb column type of " + typ)
  1253  }
  1254  

View as plain text