Source file src/pkg/database/sql/convert.go

     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	// Type conversions for Scan.
     6	
     7	package sql
     8	
     9	import (
    10		"database/sql/driver"
    11		"errors"
    12		"fmt"
    13		"reflect"
    14		"strconv"
    15		"time"
    16		"unicode"
    17		"unicode/utf8"
    18	)
    19	
    20	var errNilPtr = errors.New("destination pointer is nil") // embedded in descriptive error
    21	
    22	func describeNamedValue(nv *driver.NamedValue) string {
    23		if len(nv.Name) == 0 {
    24			return fmt.Sprintf("$%d", nv.Ordinal)
    25		}
    26		return fmt.Sprintf("with name %q", nv.Name)
    27	}
    28	
    29	func validateNamedValueName(name string) error {
    30		if len(name) == 0 {
    31			return nil
    32		}
    33		r, _ := utf8.DecodeRuneInString(name)
    34		if unicode.IsLetter(r) {
    35			return nil
    36		}
    37		return fmt.Errorf("name %q does not begin with a letter", name)
    38	}
    39	
    40	// ccChecker wraps the driver.ColumnConverter and allows it to be used
    41	// as if it were a NamedValueChecker. If the driver ColumnConverter
    42	// is not present then the NamedValueChecker will return driver.ErrSkip.
    43	type ccChecker struct {
    44		cci  driver.ColumnConverter
    45		want int
    46	}
    47	
    48	func (c ccChecker) CheckNamedValue(nv *driver.NamedValue) error {
    49		if c.cci == nil {
    50			return driver.ErrSkip
    51		}
    52		// The column converter shouldn't be called on any index
    53		// it isn't expecting. The final error will be thrown
    54		// in the argument converter loop.
    55		index := nv.Ordinal - 1
    56		if c.want <= index {
    57			return nil
    58		}
    59	
    60		// First, see if the value itself knows how to convert
    61		// itself to a driver type. For example, a NullString
    62		// struct changing into a string or nil.
    63		if vr, ok := nv.Value.(driver.Valuer); ok {
    64			sv, err := callValuerValue(vr)
    65			if err != nil {
    66				return err
    67			}
    68			if !driver.IsValue(sv) {
    69				return fmt.Errorf("non-subset type %T returned from Value", sv)
    70			}
    71			nv.Value = sv
    72		}
    73	
    74		// Second, ask the column to sanity check itself. For
    75		// example, drivers might use this to make sure that
    76		// an int64 values being inserted into a 16-bit
    77		// integer field is in range (before getting
    78		// truncated), or that a nil can't go into a NOT NULL
    79		// column before going across the network to get the
    80		// same error.
    81		var err error
    82		arg := nv.Value
    83		nv.Value, err = c.cci.ColumnConverter(index).ConvertValue(arg)
    84		if err != nil {
    85			return err
    86		}
    87		if !driver.IsValue(nv.Value) {
    88			return fmt.Errorf("driver ColumnConverter error converted %T to unsupported type %T", arg, nv.Value)
    89		}
    90		return nil
    91	}
    92	
    93	// defaultCheckNamedValue wraps the default ColumnConverter to have the same
    94	// function signature as the CheckNamedValue in the driver.NamedValueChecker
    95	// interface.
    96	func defaultCheckNamedValue(nv *driver.NamedValue) (err error) {
    97		nv.Value, err = driver.DefaultParameterConverter.ConvertValue(nv.Value)
    98		return err
    99	}
   100	
   101	// driverArgsConnLocked converts arguments from callers of Stmt.Exec and
   102	// Stmt.Query into driver Values.
   103	//
   104	// The statement ds may be nil, if no statement is available.
   105	//
   106	// ci must be locked.
   107	func driverArgsConnLocked(ci driver.Conn, ds *driverStmt, args []interface{}) ([]driver.NamedValue, error) {
   108		nvargs := make([]driver.NamedValue, len(args))
   109	
   110		// -1 means the driver doesn't know how to count the number of
   111		// placeholders, so we won't sanity check input here and instead let the
   112		// driver deal with errors.
   113		want := -1
   114	
   115		var si driver.Stmt
   116		var cc ccChecker
   117		if ds != nil {
   118			si = ds.si
   119			want = ds.si.NumInput()
   120			cc.want = want
   121		}
   122	
   123		// Check all types of interfaces from the start.
   124		// Drivers may opt to use the NamedValueChecker for special
   125		// argument types, then return driver.ErrSkip to pass it along
   126		// to the column converter.
   127		nvc, ok := si.(driver.NamedValueChecker)
   128		if !ok {
   129			nvc, ok = ci.(driver.NamedValueChecker)
   130		}
   131		cci, ok := si.(driver.ColumnConverter)
   132		if ok {
   133			cc.cci = cci
   134		}
   135	
   136		// Loop through all the arguments, checking each one.
   137		// If no error is returned simply increment the index
   138		// and continue. However if driver.ErrRemoveArgument
   139		// is returned the argument is not included in the query
   140		// argument list.
   141		var err error
   142		var n int
   143		for _, arg := range args {
   144			nv := &nvargs[n]
   145			if np, ok := arg.(NamedArg); ok {
   146				if err = validateNamedValueName(np.Name); err != nil {
   147					return nil, err
   148				}
   149				arg = np.Value
   150				nv.Name = np.Name
   151			}
   152			nv.Ordinal = n + 1
   153			nv.Value = arg
   154	
   155			// Checking sequence has four routes:
   156			// A: 1. Default
   157			// B: 1. NamedValueChecker 2. Column Converter 3. Default
   158			// C: 1. NamedValueChecker 3. Default
   159			// D: 1. Column Converter 2. Default
   160			//
   161			// The only time a Column Converter is called is first
   162			// or after NamedValueConverter. If first it is handled before
   163			// the nextCheck label. Thus for repeats tries only when the
   164			// NamedValueConverter is selected should the Column Converter
   165			// be used in the retry.
   166			checker := defaultCheckNamedValue
   167			nextCC := false
   168			switch {
   169			case nvc != nil:
   170				nextCC = cci != nil
   171				checker = nvc.CheckNamedValue
   172			case cci != nil:
   173				checker = cc.CheckNamedValue
   174			}
   175	
   176		nextCheck:
   177			err = checker(nv)
   178			switch err {
   179			case nil:
   180				n++
   181				continue
   182			case driver.ErrRemoveArgument:
   183				nvargs = nvargs[:len(nvargs)-1]
   184				continue
   185			case driver.ErrSkip:
   186				if nextCC {
   187					nextCC = false
   188					checker = cc.CheckNamedValue
   189				} else {
   190					checker = defaultCheckNamedValue
   191				}
   192				goto nextCheck
   193			default:
   194				return nil, fmt.Errorf("sql: converting argument %s type: %v", describeNamedValue(nv), err)
   195			}
   196		}
   197	
   198		// Check the length of arguments after conversion to allow for omitted
   199		// arguments.
   200		if want != -1 && len(nvargs) != want {
   201			return nil, fmt.Errorf("sql: expected %d arguments, got %d", want, len(nvargs))
   202		}
   203	
   204		return nvargs, nil
   205	
   206	}
   207	
   208	// convertAssign is the same as convertAssignRows, but without the optional
   209	// rows argument.
   210	func convertAssign(dest, src interface{}) error {
   211		return convertAssignRows(dest, src, nil)
   212	}
   213	
   214	// convertAssignRows copies to dest the value in src, converting it if possible.
   215	// An error is returned if the copy would result in loss of information.
   216	// dest should be a pointer type. If rows is passed in, the rows will
   217	// be used as the parent for any cursor values converted from a
   218	// driver.Rows to a *Rows.
   219	func convertAssignRows(dest, src interface{}, rows *Rows) error {
   220		// Common cases, without reflect.
   221		switch s := src.(type) {
   222		case string:
   223			switch d := dest.(type) {
   224			case *string:
   225				if d == nil {
   226					return errNilPtr
   227				}
   228				*d = s
   229				return nil
   230			case *[]byte:
   231				if d == nil {
   232					return errNilPtr
   233				}
   234				*d = []byte(s)
   235				return nil
   236			case *RawBytes:
   237				if d == nil {
   238					return errNilPtr
   239				}
   240				*d = append((*d)[:0], s...)
   241				return nil
   242			}
   243		case []byte:
   244			switch d := dest.(type) {
   245			case *string:
   246				if d == nil {
   247					return errNilPtr
   248				}
   249				*d = string(s)
   250				return nil
   251			case *interface{}:
   252				if d == nil {
   253					return errNilPtr
   254				}
   255				*d = cloneBytes(s)
   256				return nil
   257			case *[]byte:
   258				if d == nil {
   259					return errNilPtr
   260				}
   261				*d = cloneBytes(s)
   262				return nil
   263			case *RawBytes:
   264				if d == nil {
   265					return errNilPtr
   266				}
   267				*d = s
   268				return nil
   269			}
   270		case time.Time:
   271			switch d := dest.(type) {
   272			case *time.Time:
   273				*d = s
   274				return nil
   275			case *string:
   276				*d = s.Format(time.RFC3339Nano)
   277				return nil
   278			case *[]byte:
   279				if d == nil {
   280					return errNilPtr
   281				}
   282				*d = []byte(s.Format(time.RFC3339Nano))
   283				return nil
   284			case *RawBytes:
   285				if d == nil {
   286					return errNilPtr
   287				}
   288				*d = s.AppendFormat((*d)[:0], time.RFC3339Nano)
   289				return nil
   290			}
   291		case decimalDecompose:
   292			switch d := dest.(type) {
   293			case decimalCompose:
   294				return d.Compose(s.Decompose(nil))
   295			}
   296		case nil:
   297			switch d := dest.(type) {
   298			case *interface{}:
   299				if d == nil {
   300					return errNilPtr
   301				}
   302				*d = nil
   303				return nil
   304			case *[]byte:
   305				if d == nil {
   306					return errNilPtr
   307				}
   308				*d = nil
   309				return nil
   310			case *RawBytes:
   311				if d == nil {
   312					return errNilPtr
   313				}
   314				*d = nil
   315				return nil
   316			}
   317		// The driver is returning a cursor the client may iterate over.
   318		case driver.Rows:
   319			switch d := dest.(type) {
   320			case *Rows:
   321				if d == nil {
   322					return errNilPtr
   323				}
   324				if rows == nil {
   325					return errors.New("invalid context to convert cursor rows, missing parent *Rows")
   326				}
   327				rows.closemu.Lock()
   328				*d = Rows{
   329					dc:          rows.dc,
   330					releaseConn: func(error) {},
   331					rowsi:       s,
   332				}
   333				// Chain the cancel function.
   334				parentCancel := rows.cancel
   335				rows.cancel = func() {
   336					// When Rows.cancel is called, the closemu will be locked as well.
   337					// So we can access rs.lasterr.
   338					d.close(rows.lasterr)
   339					if parentCancel != nil {
   340						parentCancel()
   341					}
   342				}
   343				rows.closemu.Unlock()
   344				return nil
   345			}
   346		}
   347	
   348		var sv reflect.Value
   349	
   350		switch d := dest.(type) {
   351		case *string:
   352			sv = reflect.ValueOf(src)
   353			switch sv.Kind() {
   354			case reflect.Bool,
   355				reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
   356				reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
   357				reflect.Float32, reflect.Float64:
   358				*d = asString(src)
   359				return nil
   360			}
   361		case *[]byte:
   362			sv = reflect.ValueOf(src)
   363			if b, ok := asBytes(nil, sv); ok {
   364				*d = b
   365				return nil
   366			}
   367		case *RawBytes:
   368			sv = reflect.ValueOf(src)
   369			if b, ok := asBytes([]byte(*d)[:0], sv); ok {
   370				*d = RawBytes(b)
   371				return nil
   372			}
   373		case *bool:
   374			bv, err := driver.Bool.ConvertValue(src)
   375			if err == nil {
   376				*d = bv.(bool)
   377			}
   378			return err
   379		case *interface{}:
   380			*d = src
   381			return nil
   382		}
   383	
   384		if scanner, ok := dest.(Scanner); ok {
   385			return scanner.Scan(src)
   386		}
   387	
   388		dpv := reflect.ValueOf(dest)
   389		if dpv.Kind() != reflect.Ptr {
   390			return errors.New("destination not a pointer")
   391		}
   392		if dpv.IsNil() {
   393			return errNilPtr
   394		}
   395	
   396		if !sv.IsValid() {
   397			sv = reflect.ValueOf(src)
   398		}
   399	
   400		dv := reflect.Indirect(dpv)
   401		if sv.IsValid() && sv.Type().AssignableTo(dv.Type()) {
   402			switch b := src.(type) {
   403			case []byte:
   404				dv.Set(reflect.ValueOf(cloneBytes(b)))
   405			default:
   406				dv.Set(sv)
   407			}
   408			return nil
   409		}
   410	
   411		if dv.Kind() == sv.Kind() && sv.Type().ConvertibleTo(dv.Type()) {
   412			dv.Set(sv.Convert(dv.Type()))
   413			return nil
   414		}
   415	
   416		// The following conversions use a string value as an intermediate representation
   417		// to convert between various numeric types.
   418		//
   419		// This also allows scanning into user defined types such as "type Int int64".
   420		// For symmetry, also check for string destination types.
   421		switch dv.Kind() {
   422		case reflect.Ptr:
   423			if src == nil {
   424				dv.Set(reflect.Zero(dv.Type()))
   425				return nil
   426			}
   427			dv.Set(reflect.New(dv.Type().Elem()))
   428			return convertAssignRows(dv.Interface(), src, rows)
   429		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   430			if src == nil {
   431				return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
   432			}
   433			s := asString(src)
   434			i64, err := strconv.ParseInt(s, 10, dv.Type().Bits())
   435			if err != nil {
   436				err = strconvErr(err)
   437				return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
   438			}
   439			dv.SetInt(i64)
   440			return nil
   441		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
   442			if src == nil {
   443				return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
   444			}
   445			s := asString(src)
   446			u64, err := strconv.ParseUint(s, 10, dv.Type().Bits())
   447			if err != nil {
   448				err = strconvErr(err)
   449				return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
   450			}
   451			dv.SetUint(u64)
   452			return nil
   453		case reflect.Float32, reflect.Float64:
   454			if src == nil {
   455				return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
   456			}
   457			s := asString(src)
   458			f64, err := strconv.ParseFloat(s, dv.Type().Bits())
   459			if err != nil {
   460				err = strconvErr(err)
   461				return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
   462			}
   463			dv.SetFloat(f64)
   464			return nil
   465		case reflect.String:
   466			if src == nil {
   467				return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
   468			}
   469			switch v := src.(type) {
   470			case string:
   471				dv.SetString(v)
   472				return nil
   473			case []byte:
   474				dv.SetString(string(v))
   475				return nil
   476			}
   477		}
   478	
   479		return fmt.Errorf("unsupported Scan, storing driver.Value type %T into type %T", src, dest)
   480	}
   481	
   482	func strconvErr(err error) error {
   483		if ne, ok := err.(*strconv.NumError); ok {
   484			return ne.Err
   485		}
   486		return err
   487	}
   488	
   489	func cloneBytes(b []byte) []byte {
   490		if b == nil {
   491			return nil
   492		}
   493		c := make([]byte, len(b))
   494		copy(c, b)
   495		return c
   496	}
   497	
   498	func asString(src interface{}) string {
   499		switch v := src.(type) {
   500		case string:
   501			return v
   502		case []byte:
   503			return string(v)
   504		}
   505		rv := reflect.ValueOf(src)
   506		switch rv.Kind() {
   507		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   508			return strconv.FormatInt(rv.Int(), 10)
   509		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
   510			return strconv.FormatUint(rv.Uint(), 10)
   511		case reflect.Float64:
   512			return strconv.FormatFloat(rv.Float(), 'g', -1, 64)
   513		case reflect.Float32:
   514			return strconv.FormatFloat(rv.Float(), 'g', -1, 32)
   515		case reflect.Bool:
   516			return strconv.FormatBool(rv.Bool())
   517		}
   518		return fmt.Sprintf("%v", src)
   519	}
   520	
   521	func asBytes(buf []byte, rv reflect.Value) (b []byte, ok bool) {
   522		switch rv.Kind() {
   523		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   524			return strconv.AppendInt(buf, rv.Int(), 10), true
   525		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
   526			return strconv.AppendUint(buf, rv.Uint(), 10), true
   527		case reflect.Float32:
   528			return strconv.AppendFloat(buf, rv.Float(), 'g', -1, 32), true
   529		case reflect.Float64:
   530			return strconv.AppendFloat(buf, rv.Float(), 'g', -1, 64), true
   531		case reflect.Bool:
   532			return strconv.AppendBool(buf, rv.Bool()), true
   533		case reflect.String:
   534			s := rv.String()
   535			return append(buf, s...), true
   536		}
   537		return
   538	}
   539	
   540	var valuerReflectType = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
   541	
   542	// callValuerValue returns vr.Value(), with one exception:
   543	// If vr.Value is an auto-generated method on a pointer type and the
   544	// pointer is nil, it would panic at runtime in the panicwrap
   545	// method. Treat it like nil instead.
   546	// Issue 8415.
   547	//
   548	// This is so people can implement driver.Value on value types and
   549	// still use nil pointers to those types to mean nil/NULL, just like
   550	// string/*string.
   551	//
   552	// This function is mirrored in the database/sql/driver package.
   553	func callValuerValue(vr driver.Valuer) (v driver.Value, err error) {
   554		if rv := reflect.ValueOf(vr); rv.Kind() == reflect.Ptr &&
   555			rv.IsNil() &&
   556			rv.Type().Elem().Implements(valuerReflectType) {
   557			return nil, nil
   558		}
   559		return vr.Value()
   560	}
   561	
   562	// decimal composes or decomposes a decimal value to and from individual parts.
   563	// There are four parts: a boolean negative flag, a form byte with three possible states
   564	// (finite=0, infinite=1, NaN=2), a base-2 big-endian integer
   565	// coefficient (also known as a significand) as a []byte, and an int32 exponent.
   566	// These are composed into a final value as "decimal = (neg) (form=finite) coefficient * 10 ^ exponent".
   567	// A zero length coefficient is a zero value.
   568	// The big-endian integer coefficent stores the most significant byte first (at coefficent[0]).
   569	// If the form is not finite the coefficient and exponent should be ignored.
   570	// The negative parameter may be set to true for any form, although implementations are not required
   571	// to respect the negative parameter in the non-finite form.
   572	//
   573	// Implementations may choose to set the negative parameter to true on a zero or NaN value,
   574	// but implementations that do not differentiate between negative and positive
   575	// zero or NaN values should ignore the negative parameter without error.
   576	// If an implementation does not support Infinity it may be converted into a NaN without error.
   577	// If a value is set that is larger than what is supported by an implementation,
   578	// an error must be returned.
   579	// Implementations must return an error if a NaN or Infinity is attempted to be set while neither
   580	// are supported.
   581	//
   582	// NOTE(kardianos): This is an experimental interface. See https://golang.org/issue/30870
   583	type decimal interface {
   584		decimalDecompose
   585		decimalCompose
   586	}
   587	
   588	type decimalDecompose interface {
   589		// Decompose returns the internal decimal state in parts.
   590		// If the provided buf has sufficient capacity, buf may be returned as the coefficient with
   591		// the value set and length set as appropriate.
   592		Decompose(buf []byte) (form byte, negative bool, coefficient []byte, exponent int32)
   593	}
   594	
   595	type decimalCompose interface {
   596		// Compose sets the internal decimal value from parts. If the value cannot be
   597		// represented then an error should be returned.
   598		Compose(form byte, negative bool, coefficient []byte, exponent int32) error
   599	}
   600	

View as plain text