// 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 (
	
	
	
	
)

// 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 Value 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
//    driver Value types.
//
//  * by the sql package, for converting from a driver's Value type
//    to a user's type in a scan.
type ValueConverter interface {
	// ConvertValue converts a value to a driver Value.
	ConvertValue(v interface{}) (Value, error)
}

// Valuer is the interface providing the Value method.
//
// Types implementing Valuer interface are able to convert
// themselves to a driver Value.
type Valuer interface {
	// Value returns a driver Value.
	// Value must not panic.
	Value() (Value, 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 { return "Bool" }

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

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

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

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

// 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) ( interface{}) (Value, error) {
	switch .(type) {
	case string, []byte:
		return , nil
	}
	return fmt.Sprintf("%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 ( Null) ( interface{}) (Value, error) {
	if  == nil {
		return nil, nil
	}
	return .Converter.ConvertValue()
}

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

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

// IsValue reports whether v is a valid Value parameter type.
func ( interface{}) bool {
	if  == nil {
		return true
	}
	switch .(type) {
	case []byte, bool, float64, int64, string, time.Time:
		return true
	case decimalDecompose:
		return true
	}
	return false
}

// IsScanValue is equivalent to IsValue.
// It exists for compatibility.
func ( interface{}) bool {
	return IsValue()
}

// DefaultParameterConverter is the default implementation of
// ValueConverter that's used when a Stmt doesn't implement
// ColumnConverter.
//
// DefaultParameterConverter returns its argument directly if
// IsValue(arg). Otherwise, if the argument implements Valuer, its
// Value method is used to return a Value. As a fallback, the provided
// argument's underlying type is used to convert it to a Value:
// underlying integer types are converted to int64, floats to float64,
// bool, string, and []byte to themselves. If the argument is a nil
// pointer, ConvertValue returns a nil Value. If the argument is a
// non-nil pointer, it is dereferenced and ConvertValue is called
// recursively. Other types are an error.
var DefaultParameterConverter defaultConverter

type defaultConverter struct{}

var _ ValueConverter = defaultConverter{}

var valuerReflectType = reflect.TypeOf((*Valuer)(nil)).Elem()

// callValuerValue returns vr.Value(), with one exception:
// If vr.Value is an auto-generated method on a pointer type and the
// pointer is nil, it would panic at runtime in the panicwrap
// method. Treat it like nil instead.
// Issue 8415.
//
// This is so people can implement driver.Value on value types and
// still use nil pointers to those types to mean nil/NULL, just like
// string/*string.
//
// This function is mirrored in the database/sql package.
func callValuerValue( Valuer) ( Value,  error) {
	if  := reflect.ValueOf(); .Kind() == reflect.Ptr &&
		.IsNil() &&
		.Type().Elem().Implements(valuerReflectType) {
		return nil, nil
	}
	return .Value()
}

func (defaultConverter) ( interface{}) (Value, error) {
	if IsValue() {
		return , nil
	}

	switch vr := .(type) {
	case Valuer:
		,  := callValuerValue()
		if  != nil {
			return nil, 
		}
		if !IsValue() {
			return nil, fmt.Errorf("non-Value type %T returned from Value", )
		}
		return , nil

	// For now, continue to prefer the Valuer interface over the decimal decompose interface.
	case decimalDecompose:
		return , nil
	}

	 := reflect.ValueOf()
	switch .Kind() {
	case reflect.Ptr:
		// indirect pointers
		if .IsNil() {
			return nil, nil
		} else {
			return defaultConverter{}.(.Elem().Interface())
		}
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return .Int(), nil
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32:
		return int64(.Uint()), nil
	case reflect.Uint64:
		 := .Uint()
		if  >= 1<<63 {
			return nil, fmt.Errorf("uint64 values with high bit set are not supported")
		}
		return int64(), nil
	case reflect.Float32, reflect.Float64:
		return .Float(), nil
	case reflect.Bool:
		return .Bool(), nil
	case reflect.Slice:
		 := .Type().Elem().Kind()
		if  == reflect.Uint8 {
			return .Bytes(), nil
		}
		return nil, fmt.Errorf("unsupported type %T, a slice of %s", , )
	case reflect.String:
		return .String(), nil
	}
	return nil, fmt.Errorf("unsupported type %T, a %s", , .Kind())
}

type decimalDecompose interface {
	// Decompose returns the internal decimal state into parts.
	// If the provided buf has sufficient capacity, buf may be returned as the coefficient with
	// the value set and length set as appropriate.
	Decompose(buf []byte) (form byte, negative bool, coefficient []byte, exponent int32)
}