Subversion Repositories openrisc

// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package driver

import (
        "fmt"
        "reflect"
        "strconv"
        "time"
)

// ValueConverter is the interface providing the ConvertValue method.
//
// Various implementations of ValueConverter are provided by the
// driver package to provide consistent implementations of conversions
// between drivers.  The ValueConverters have several uses:
//
//  * converting from the subset types as provided by the sql package
//    into a database table's specific column type and making sure it
//    fits, such as making sure a particular int64 fits in a
//    table's uint16 column.
//
//  * converting a value as given from the database into one of the
//    subset types.
//
//  * by the sql package, for converting from a driver's subset type
//    to a user's type in a scan.
type ValueConverter interface {
        // ConvertValue converts a value to a restricted subset type.
        ConvertValue(v interface{}) (interface{}, error)
}

// SubsetValuer is the interface providing the SubsetValue method.
//
// Types implementing SubsetValuer interface are able to convert
// themselves to one of the driver's allowed subset values.
type SubsetValuer interface {
        // SubsetValue returns a driver parameter subset value.
        SubsetValue() (interface{}, error)
}

// Bool is a ValueConverter that converts input values to bools.
//
// The conversion rules are:
//  - booleans are returned unchanged
//  - for integer types,
//       1 is true
//       0 is false,
//       other integers are an error
//  - for strings and []byte, same rules as strconv.ParseBool
//  - all other types are an error
var Bool boolType

type boolType struct{}

var _ ValueConverter = boolType{}

func (boolType) String() string { return "Bool" }

func (boolType) ConvertValue(src interface{}) (interface{}, error) {
        switch s := src.(type) {
        case bool:
                return s, nil
        case string:
                b, err := strconv.ParseBool(s)
                if err != nil {
                        return nil, fmt.Errorf("sql/driver: couldn't convert %q into type bool", s)
                }
                return b, nil
        case []byte:
                b, err := strconv.ParseBool(string(s))
                if err != nil {
                        return nil, fmt.Errorf("sql/driver: couldn't convert %q into type bool", s)
                }
                return b, nil
        }

        sv := reflect.ValueOf(src)
        switch sv.Kind() {
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                iv := sv.Int()
                if iv == 1 || iv == 0 {
                        return iv == 1, nil
                }
                return nil, fmt.Errorf("sql/driver: couldn't convert %d into type bool", iv)
        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
                uv := sv.Uint()
                if uv == 1 || uv == 0 {
                        return uv == 1, nil
                }
                return nil, fmt.Errorf("sql/driver: couldn't convert %d into type bool", uv)
        }

        return nil, fmt.Errorf("sql/driver: couldn't convert %v (%T) into type bool", src, src)
}

// Int32 is a ValueConverter that converts input values to int64,
// respecting the limits of an int32 value.
var Int32 int32Type

type int32Type struct{}

var _ ValueConverter = int32Type{}

func (int32Type) ConvertValue(v interface{}) (interface{}, error) {
        rv := reflect.ValueOf(v)
        switch rv.Kind() {
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                i64 := rv.Int()
                if i64 > (1<<31)-1 || i64 < -(1<<31) {
                        return nil, fmt.Errorf("sql/driver: value %d overflows int32", v)
                }
                return i64, nil
        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
                u64 := rv.Uint()
                if u64 > (1<<31)-1 {
                        return nil, fmt.Errorf("sql/driver: value %d overflows int32", v)
                }
                return int64(u64), nil
        case reflect.String:
                i, err := strconv.Atoi(rv.String())
                if err != nil {
                        return nil, fmt.Errorf("sql/driver: value %q can't be converted to int32", v)
                }
                return int64(i), nil
        }
        return nil, fmt.Errorf("sql/driver: unsupported value %v (type %T) converting to int32", v, v)
}

// String is a ValueConverter that converts its input to a string.
// If the value is already a string or []byte, it's unchanged.
// If the value is of another type, conversion to string is done
// with fmt.Sprintf("%v", v).
var String stringType

type stringType struct{}

func (stringType) ConvertValue(v interface{}) (interface{}, error) {
        switch v.(type) {
        case string, []byte:
                return v, nil
        }
        return fmt.Sprintf("%v", v), nil
}

// Null is a type that implements ValueConverter by allowing nil
// values but otherwise delegating to another ValueConverter.
type Null struct {
        Converter ValueConverter
}

func (n Null) ConvertValue(v interface{}) (interface{}, error) {
        if v == nil {
                return nil, nil
        }
        return n.Converter.ConvertValue(v)
}

// NotNull is a type that implements ValueConverter by disallowing nil
// values but otherwise delegating to another ValueConverter.
type NotNull struct {
        Converter ValueConverter
}

func (n NotNull) ConvertValue(v interface{}) (interface{}, error) {
        if v == nil {
                return nil, fmt.Errorf("nil value not allowed")
        }
        return n.Converter.ConvertValue(v)
}

// IsParameterSubsetType reports whether v is of a valid type for a
// parameter. These types are:
//
//   int64
//   float64
//   bool
//   nil
//   []byte
//   time.Time
//   string
//
// This is the same list as IsScanSubsetType, with the addition of
// string.
func IsParameterSubsetType(v interface{}) bool {
        if IsScanSubsetType(v) {
                return true
        }
        if _, ok := v.(string); ok {
                return true
        }
        return false
}

// IsScanSubsetType reports whether v is of a valid type for a
// value populated by Rows.Next. These types are:
//
//   int64
//   float64
//   bool
//   nil
//   []byte
//   time.Time
//
// This is the same list as IsParameterSubsetType, without string.
func IsScanSubsetType(v interface{}) bool {
        if v == nil {
                return true
        }
        switch v.(type) {
        case int64, float64, []byte, bool, time.Time:
                return true
        }
        return false
}

// DefaultParameterConverter is the default implementation of
// ValueConverter that's used when a Stmt doesn't implement
// ColumnConverter.
//
// DefaultParameterConverter returns the given value directly if
// IsSubsetType(value).  Otherwise integer type are converted to
// int64, floats to float64, and strings to []byte.  Other types are
// an error.
var DefaultParameterConverter defaultConverter

type defaultConverter struct{}

var _ ValueConverter = defaultConverter{}

func (defaultConverter) ConvertValue(v interface{}) (interface{}, error) {
        if IsParameterSubsetType(v) {
                return v, nil
        }

        if svi, ok := v.(SubsetValuer); ok {
                sv, err := svi.SubsetValue()
                if err != nil {
                        return nil, err
                }
                if !IsParameterSubsetType(sv) {
                        return nil, fmt.Errorf("non-subset type %T returned from SubsetValue", sv)
                }
                return sv, nil
        }

        rv := reflect.ValueOf(v)
        switch rv.Kind() {
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                return rv.Int(), nil
        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32:
                return int64(rv.Uint()), nil
        case reflect.Uint64:
                u64 := rv.Uint()
                if u64 >= 1<<63 {
                        return nil, fmt.Errorf("uint64 values with high bit set are not supported")
                }
                return int64(u64), nil
        case reflect.Float32, reflect.Float64:
                return rv.Float(), nil
        }
        return nil, fmt.Errorf("unsupported type %T, a %s", v, rv.Kind())
}