libgo/go/database/sql/driver/types.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 package driver
   6
   7 import (
   8         "fmt"
   9         "reflect"
  10         "strconv"
  11         "time"
  12 )
  13
  14 // ValueConverter is the interface providing the ConvertValue method.
  15 //
  16 // Various implementations of ValueConverter are provided by the
  17 // driver package to provide consistent implementations of conversions
  18 // between drivers.  The ValueConverters have several uses:
  19 //
  20 //  * converting from the Value types as provided by the sql package
  21 //    into a database table's specific column type and making sure it
  22 //    fits, such as making sure a particular int64 fits in a
  23 //    table's uint16 column.
  24 //
  25 //  * converting a value as given from the database into one of the
  26 //    driver Value types.
  27 //
  28 //  * by the sql package, for converting from a driver's Value type
  29 //    to a user's type in a scan.
  30 type ValueConverter interface {
  31         // ConvertValue converts a value to a driver Value.
  32         ConvertValue(v interface{}) (Value, error)
  33 }
  34
  35 // Valuer is the interface providing the Value method.
  36 //
  37 // Types implementing Valuer interface are able to convert
  38 // themselves to a driver Value.
  39 type Valuer interface {
  40         // Value returns a driver Value.
  41         Value() (Value, error)
  42 }
  43
  44 // Bool is a ValueConverter that converts input values to bools.
  45 //
  46 // The conversion rules are:
  47 //  - booleans are returned unchanged
  48 //  - for integer types,
  49 //       1 is true
  50 //       0 is false,
  51 //       other integers are an error
  52 //  - for strings and []byte, same rules as strconv.ParseBool
  53 //  - all other types are an error
  54 var Bool boolType
  55
  56 type boolType struct{}
  57
  58 var _ ValueConverter = boolType{}
  59
  60 func (boolType) String() string { return "Bool" }
  61
  62 func (boolType) ConvertValue(src interface{}) (Value, error) {
  63         switch s := src.(type) {
  64         case bool:
  65                 return s, nil
  66         case string:
  67                 b, err := strconv.ParseBool(s)
  68                 if err != nil {
  69                         return nil, fmt.Errorf("sql/driver: couldn't convert %q into type bool", s)
  70                 }
  71                 return b, nil
  72         case []byte:
  73                 b, err := strconv.ParseBool(string(s))
  74                 if err != nil {
  75                         return nil, fmt.Errorf("sql/driver: couldn't convert %q into type bool", s)
  76                 }
  77                 return b, nil
  78         }
  79
  80         sv := reflect.ValueOf(src)
  81         switch sv.Kind() {
  82         case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  83                 iv := sv.Int()
  84                 if iv == 1 || iv == 0 {
  85                         return iv == 1, nil
  86                 }
  87                 return nil, fmt.Errorf("sql/driver: couldn't convert %d into type bool", iv)
  88         case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
  89                 uv := sv.Uint()
  90                 if uv == 1 || uv == 0 {
  91                         return uv == 1, nil
  92                 }
  93                 return nil, fmt.Errorf("sql/driver: couldn't convert %d into type bool", uv)
  94         }
  95
  96         return nil, fmt.Errorf("sql/driver: couldn't convert %v (%T) into type bool", src, src)
  97 }
  98
  99 // Int32 is a ValueConverter that converts input values to int64,
 100 // respecting the limits of an int32 value.
 101 var Int32 int32Type
 102
 103 type int32Type struct{}
 104
 105 var _ ValueConverter = int32Type{}
 106
 107 func (int32Type) ConvertValue(v interface{}) (Value, error) {
 108         rv := reflect.ValueOf(v)
 109         switch rv.Kind() {
 110         case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 111                 i64 := rv.Int()
 112                 if i64 > (1<<31)-1 || i64 < -(1<<31) {
 113                         return nil, fmt.Errorf("sql/driver: value %d overflows int32", v)
 114                 }
 115                 return i64, nil
 116         case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 117                 u64 := rv.Uint()
 118                 if u64 > (1<<31)-1 {
 119                         return nil, fmt.Errorf("sql/driver: value %d overflows int32", v)
 120                 }
 121                 return int64(u64), nil
 122         case reflect.String:
 123                 i, err := strconv.Atoi(rv.String())
 124                 if err != nil {
 125                         return nil, fmt.Errorf("sql/driver: value %q can't be converted to int32", v)
 126                 }
 127                 return int64(i), nil
 128         }
 129         return nil, fmt.Errorf("sql/driver: unsupported value %v (type %T) converting to int32", v, v)
 130 }
 131
 132 // String is a ValueConverter that converts its input to a string.
 133 // If the value is already a string or []byte, it's unchanged.
 134 // If the value is of another type, conversion to string is done
 135 // with fmt.Sprintf("%v", v).
 136 var String stringType
 137
 138 type stringType struct{}
 139
 140 func (stringType) ConvertValue(v interface{}) (Value, error) {
 141         switch v.(type) {
 142         case string, []byte:
 143                 return v, nil
 144         }
 145         return fmt.Sprintf("%v", v), nil
 146 }
 147
 148 // Null is a type that implements ValueConverter by allowing nil
 149 // values but otherwise delegating to another ValueConverter.
 150 type Null struct {
 151         Converter ValueConverter
 152 }
 153
 154 func (n Null) ConvertValue(v interface{}) (Value, error) {
 155         if v == nil {
 156                 return nil, nil
 157         }
 158         return n.Converter.ConvertValue(v)
 159 }
 160
 161 // NotNull is a type that implements ValueConverter by disallowing nil
 162 // values but otherwise delegating to another ValueConverter.
 163 type NotNull struct {
 164         Converter ValueConverter
 165 }
 166
 167 func (n NotNull) ConvertValue(v interface{}) (Value, error) {
 168         if v == nil {
 169                 return nil, fmt.Errorf("nil value not allowed")
 170         }
 171         return n.Converter.ConvertValue(v)
 172 }
 173
 174 // IsValue reports whether v is a valid Value parameter type.
 175 // Unlike IsScanValue, IsValue permits the string type.
 176 func IsValue(v interface{}) bool {
 177         if IsScanValue(v) {
 178                 return true
 179         }
 180         if _, ok := v.(string); ok {
 181                 return true
 182         }
 183         return false
 184 }
 185
 186 // IsScanValue reports whether v is a valid Value scan type.
 187 // Unlike IsValue, IsScanValue does not permit the string type.
 188 func IsScanValue(v interface{}) bool {
 189         if v == nil {
 190                 return true
 191         }
 192         switch v.(type) {
 193         case int64, float64, []byte, bool, time.Time:
 194                 return true
 195         }
 196         return false
 197 }
 198
 199 // DefaultParameterConverter is the default implementation of
 200 // ValueConverter that's used when a Stmt doesn't implement
 201 // ColumnConverter.
 202 //
 203 // DefaultParameterConverter returns the given value directly if
 204 // IsValue(value).  Otherwise integer type are converted to
 205 // int64, floats to float64, and strings to []byte.  Other types are
 206 // an error.
 207 var DefaultParameterConverter defaultConverter
 208
 209 type defaultConverter struct{}
 210
 211 var _ ValueConverter = defaultConverter{}
 212
 213 func (defaultConverter) ConvertValue(v interface{}) (Value, error) {
 214         if IsValue(v) {
 215                 return v, nil
 216         }
 217
 218         if svi, ok := v.(Valuer); ok {
 219                 sv, err := svi.Value()
 220                 if err != nil {
 221                         return nil, err
 222                 }
 223                 if !IsValue(sv) {
 224                         return nil, fmt.Errorf("non-Value type %T returned from Value", sv)
 225                 }
 226                 return sv, nil
 227         }
 228
 229         rv := reflect.ValueOf(v)
 230         switch rv.Kind() {
 231         case reflect.Ptr:
 232                 // indirect pointers
 233                 if rv.IsNil() {
 234                         return nil, nil
 235                 } else {
 236                         return defaultConverter{}.ConvertValue(rv.Elem().Interface())
 237                 }
 238         case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 239                 return rv.Int(), nil
 240         case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32:
 241                 return int64(rv.Uint()), nil
 242         case reflect.Uint64:
 243                 u64 := rv.Uint()
 244                 if u64 >= 1<<63 {
 245                         return nil, fmt.Errorf("uint64 values with high bit set are not supported")
 246                 }
 247                 return int64(u64), nil
 248         case reflect.Float32, reflect.Float64:
 249                 return rv.Float(), nil
 250         }
 251         return nil, fmt.Errorf("unsupported type %T, a %s", v, rv.Kind())
 252 }