Source file src/pkg/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 }