/*

Copyright 2017 Google LLC

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

*/

package spanner

import (

"bytes"

"database/sql"

"database/sql/driver"

"encoding/base64"

"encoding/json"

"errors"

"fmt"

"math"

"math/big"

"reflect"

"regexp"

"strconv"

"strings"

"time"

"cloud.google.com/go/civil"

"cloud.google.com/go/internal/fields"

sppb "cloud.google.com/go/spanner/apiv1/spannerpb"

"github.com/google/uuid"

"google.golang.org/grpc/codes"

"google.golang.org/protobuf/proto"

"google.golang.org/protobuf/protoadapt"

"google.golang.org/protobuf/reflect/protoreflect"

proto3 "google.golang.org/protobuf/types/known/structpb"

)

const (

// nullString is returned by the String methods of NullableValues when the

// underlying database value is null.

nullString = "<null>"

commitTimestampPlaceholderString = "spanner.commit_timestamp()"

// NumericPrecisionDigits is the maximum number of digits in a NUMERIC

// value.

NumericPrecisionDigits = 38

// NumericScaleDigits is the maximum number of digits after the decimal

// point in a NUMERIC value.

NumericScaleDigits = 9

)

// LossOfPrecisionHandlingOption describes the option to deal with loss of

// precision on numeric values.

type LossOfPrecisionHandlingOption int

const (

// NumericRound automatically rounds a numeric value that has a higher

// precision than what is supported by Spanner, e.g., 0.1234567895 rounds

// to 0.123456790.

NumericRound LossOfPrecisionHandlingOption = iota

// NumericError returns an error for numeric values that have a higher

// precision than what is supported by Spanner. E.g. the client returns an

// error if the application tries to insert the value 0.1234567895.

NumericError

)

// LossOfPrecisionHandling configures how to deal with loss of precision on

// numeric values. The value of this configuration is global and will be used

// for all Spanner clients.

var LossOfPrecisionHandling LossOfPrecisionHandlingOption

// NumericString returns a string representing a *big.Rat in a format compatible

// with Spanner SQL. It returns a floating-point literal with 9 digits after the

// decimal point.

func NumericString(r *big.Rat) string {

return r.FloatString(NumericScaleDigits)

}

// validateNumeric returns nil if there are no errors. It will return an error

// when the numeric number is not valid.

func validateNumeric(r *big.Rat) error {

if r == nil {

return nil

}

// Add one more digit to the scale component to find out if there are more

// digits than required.

strRep := r.FloatString(NumericScaleDigits + 1)

strRep = strings.TrimRight(strRep, "0")

strRep = strings.TrimLeft(strRep, "-")

s := strings.Split(strRep, ".")

whole := s[0]

scale := s[1]

if len(scale) > NumericScaleDigits {

return fmt.Errorf("max scale for a numeric is %d. The requested numeric has more", NumericScaleDigits)

}

if len(whole) > NumericPrecisionDigits-NumericScaleDigits {

return fmt.Errorf("max precision for the whole component of a numeric is %d. The requested numeric has a whole component with precision %d", NumericPrecisionDigits-NumericScaleDigits, len(whole))

}

return nil

}

var (

// CommitTimestamp is a special value used to tell Cloud Spanner to insert

// the commit timestamp of the transaction into a column. It can be used in

// a Mutation, or directly used in InsertStruct or InsertMap. See

// ExampleCommitTimestamp. This is just a placeholder and the actual value

// stored in this variable has no meaning.

CommitTimestamp = commitTimestamp

commitTimestamp = time.Unix(0, 0).In(time.FixedZone("CommitTimestamp placeholder", 0xDB))

jsonUseNumber bool

protoMsgReflectType = reflect.TypeOf((*proto.Message)(nil)).Elem()

protoEnumReflectType = reflect.TypeOf((*protoreflect.Enum)(nil)).Elem()

errPayloadNil = errors.New("payload should not be nil")

)

// UseNumberWithJSONDecoderEncoder specifies whether Cloud Spanner JSON numbers are decoded

// as Number (preserving precision) or float64 (risking loss).

// Defaults to the same behavior as the standard Go library, which means decoding to float64.

// Call this method to enable lossless precision.

// NOTE 1: Calling this method affects the behavior of all clients created by this library, both existing and future instances.

// NOTE 2: This method sets a global variable that is used by the client to encode/decode JSON numbers. Access to the global variable is not synchronized. You should only call this method when there are no goroutines encoding/decoding Cloud Spanner JSON values. It is recommended to only call this method during the initialization of your application, and preferably before you create any Cloud Spanner clients, and/or in tests when there are no queries being executed.

func UseNumberWithJSONDecoderEncoder(useNumber bool) {

jsonUseNumber = useNumber

}

func jsonUnmarshal(data []byte, v any) error {

dec := json.NewDecoder(bytes.NewReader(data))

if jsonUseNumber {

dec.UseNumber()

}

return dec.Decode(v)

}

// jsonIsNull returns whether v matches JSON null literal

func jsonIsNull(v []byte) bool {

return string(v) == "null"

}

// Encoder is the interface implemented by a custom type that can be encoded to

// a supported type by Spanner. A code example:

//

// type customField struct {

// Prefix string

// Suffix string

// }

//

// // Convert a customField value to a string

// func (cf customField) EncodeSpanner() (interface{}, error) {

// var b bytes.Buffer

// b.WriteString(cf.Prefix)

// b.WriteString("-")

// b.WriteString(cf.Suffix)

// return b.String(), nil

// }

type Encoder interface {

EncodeSpanner() (interface{}, error)

}

// Decoder is the interface implemented by a custom type that can be decoded

// from a supported type by Spanner. A code example:

//

// type customField struct {

// Prefix string

// Suffix string

// }

//

// // Convert a string to a customField value

// func (cf *customField) DecodeSpanner(val interface{}) (err error) {

// strVal, ok := val.(string)

// if !ok {

// return fmt.Errorf("failed to decode customField: %v", val)

// }

// s := strings.Split(strVal, "-")

// if len(s) > 1 {

// cf.Prefix = s[0]

// cf.Suffix = s[1]

// }

// return nil

// }

type Decoder interface {

DecodeSpanner(input interface{}) error

}

// NullableValue is the interface implemented by all null value wrapper types.

type NullableValue interface {

// IsNull returns true if the underlying database value is null.

IsNull() bool

}

// NullInt64 represents a Cloud Spanner INT64 that may be NULL.

type NullInt64 struct {

Int64 int64 // Int64 contains the value when it is non-NULL, and zero when NULL.

Valid bool // Valid is true if Int64 is not NULL.

}

// IsNull implements NullableValue.IsNull for NullInt64.

func (n NullInt64) IsNull() bool {

return !n.Valid

}

// String implements Stringer.String for NullInt64

func (n NullInt64) String() string {

if !n.Valid {

return nullString

}

return fmt.Sprintf("%v", n.Int64)

}

// MarshalJSON implements json.Marshaler.MarshalJSON for NullInt64.

func (n NullInt64) MarshalJSON() ([]byte, error) {

return nulljson(n.Valid, n.Int64)

}

// UnmarshalJSON implements json.Unmarshaler.UnmarshalJSON for NullInt64.

func (n *NullInt64) UnmarshalJSON(payload []byte) error {

if payload == nil {

return errPayloadNil

}

if jsonIsNull(payload) {

n.Int64 = int64(0)

n.Valid = false

return nil

}

num, err := strconv.ParseInt(string(payload), 10, 64)

if err != nil {

return fmt.Errorf("payload cannot be converted to int64: got %v", string(payload))

}

n.Int64 = num

n.Valid = true

return nil

}

// Value implements the driver.Valuer interface.

func (n NullInt64) Value() (driver.Value, error) {

if n.IsNull() {

return nil, nil

}

return n.Int64, nil

}

// Scan implements the sql.Scanner interface.

func (n *NullInt64) Scan(value interface{}) error {

if value == nil {

n.Int64, n.Valid = 0, false

return nil

}

n.Valid = true

switch p := value.(type) {

default:

return spannerErrorf(codes.InvalidArgument, "invalid type for NullInt64: %v", p)

case *int64:

if p == nil {

n.Int64, n.Valid = 0, false

} else {

n.Int64 = *p

}

case int64:

n.Int64 = p

case *NullInt64:

if p == nil {

n.Int64, n.Valid = 0, false

} else {

n.Int64 = p.Int64

n.Valid = p.Valid

}

case NullInt64:

n.Int64 = p.Int64

n.Valid = p.Valid

case string:

i64, err := strconv.ParseInt(p, 10, 64)

if err != nil {

return err

}

n.Int64 = i64

n.Valid = true

case *string:

if p == nil {

n.Int64, n.Valid = 0, false

return nil

}

i64, err := strconv.ParseInt(*p, 10, 64)

if err != nil {

return err

}

n.Int64 = i64

n.Valid = true

}

return nil

}

// GormDataType is used by gorm to determine the default data type for fields with this type.

func (n NullInt64) GormDataType() string {

return "INT64"

}

// NullString represents a Cloud Spanner STRING that may be NULL.

type NullString struct {

StringVal string // StringVal contains the value when it is non-NULL, and an empty string when NULL.

Valid bool // Valid is true if StringVal is not NULL.

}

// IsNull implements NullableValue.IsNull for NullString.

func (n NullString) IsNull() bool {

return !n.Valid

}

// String implements Stringer.String for NullString

func (n NullString) String() string {

if !n.Valid {

return nullString

}

return n.StringVal

}

// MarshalJSON implements json.Marshaler.MarshalJSON for NullString.

func (n NullString) MarshalJSON() ([]byte, error) {

return nulljson(n.Valid, n.StringVal)

}

// UnmarshalJSON implements json.Unmarshaler.UnmarshalJSON for NullString.

func (n *NullString) UnmarshalJSON(payload []byte) error {

if payload == nil {

return errPayloadNil

}

if jsonIsNull(payload) {

n.StringVal = ""

n.Valid = false

return nil

}

var s *string

if err := jsonUnmarshal(payload, &s); err != nil {

return err

}

if s != nil {

n.StringVal = *s

n.Valid = true

} else {

n.StringVal = ""

n.Valid = false

}

return nil

}

// Value implements the driver.Valuer interface.

func (n NullString) Value() (driver.Value, error) {

if n.IsNull() {

return nil, nil

}

return n.StringVal, nil

}

// Scan implements the sql.Scanner interface.

func (n *NullString) Scan(value interface{}) error {

if value == nil {

n.StringVal, n.Valid = "", false

return nil

}

n.Valid = true

switch p := value.(type) {

default:

return spannerErrorf(codes.InvalidArgument, "invalid type for NullString: %v", p)

case *string:

if p == nil {

n.StringVal, n.Valid = "", false

} else {

n.StringVal = *p

}

case string:

n.StringVal = p

case *NullString:

if p == nil {

n.StringVal, n.Valid = "", false

} else {

n.StringVal = p.StringVal

n.Valid = p.Valid

}

case NullString:

n.StringVal = p.StringVal

n.Valid = p.Valid

}

return nil

}

// GormDataType is used by gorm to determine the default data type for fields with this type.

func (n NullString) GormDataType() string {

return "STRING(MAX)"

}

// NullFloat64 represents a Cloud Spanner FLOAT64 that may be NULL.

type NullFloat64 struct {

Float64 float64 // Float64 contains the value when it is non-NULL, and zero when NULL.

Valid bool // Valid is true if Float64 is not NULL.

}

// IsNull implements NullableValue.IsNull for NullFloat64.

func (n NullFloat64) IsNull() bool {

return !n.Valid

}

// String implements Stringer.String for NullFloat64

func (n NullFloat64) String() string {

if !n.Valid {

return nullString

}

return fmt.Sprintf("%v", n.Float64)

}

// MarshalJSON implements json.Marshaler.MarshalJSON for NullFloat64.

func (n NullFloat64) MarshalJSON() ([]byte, error) {

return nulljson(n.Valid, n.Float64)

}

// UnmarshalJSON implements json.Unmarshaler.UnmarshalJSON for NullFloat64.

func (n *NullFloat64) UnmarshalJSON(payload []byte) error {

if payload == nil {

return errPayloadNil

}

if jsonIsNull(payload) {

n.Float64 = float64(0)

n.Valid = false

return nil

}

num, err := strconv.ParseFloat(string(payload), 64)

if err != nil {

return fmt.Errorf("payload cannot be converted to float64: got %v", string(payload))

}

n.Float64 = num

n.Valid = true

return nil

}

// Value implements the driver.Valuer interface.

func (n NullFloat64) Value() (driver.Value, error) {

if n.IsNull() {

return nil, nil

}

return n.Float64, nil

}

// Scan implements the sql.Scanner interface.

func (n *NullFloat64) Scan(value interface{}) error {

if value == nil {

n.Float64, n.Valid = 0, false

return nil

}

n.Valid = true

switch p := value.(type) {

default:

return spannerErrorf(codes.InvalidArgument, "invalid type for NullFloat64: %v", p)

case *float64:

if p == nil {

n.Float64, n.Valid = 0, false

} else {

n.Float64 = *p

}

case float64:

n.Float64 = p

case *NullFloat64:

if p == nil {

n.Float64, n.Valid = 0, false

} else {

n.Float64 = p.Float64

n.Valid = p.Valid

}

case NullFloat64:

n.Float64 = p.Float64

n.Valid = p.Valid

case string:

f, err := strconv.ParseFloat(p, 64)

if err != nil {

return err

}

n.Float64 = f

n.Valid = true

case *string:

if p == nil {

n.Float64, n.Valid = 0, false

return nil

}

f, err := strconv.ParseFloat(*p, 64)

if err != nil {

return err

}

n.Float64 = f

n.Valid = true

}

return nil

}

// GormDataType is used by gorm to determine the default data type for fields with this type.

func (n NullFloat64) GormDataType() string {

return "FLOAT64"

}

// NullFloat32 represents a Cloud Spanner FLOAT32 that may be NULL.

type NullFloat32 struct {

Float32 float32 // Float32 contains the value when it is non-NULL, and zero when NULL.

Valid bool // Valid is true if FLOAT32 is not NULL.

}

// IsNull implements NullableValue.IsNull for NullFloat32.

func (n NullFloat32) IsNull() bool {

return !n.Valid

}

// String implements Stringer.String for NullFloat32

func (n NullFloat32) String() string {

if !n.Valid {

return nullString

}

return fmt.Sprintf("%v", n.Float32)

}

// MarshalJSON implements json.Marshaler.MarshalJSON for NullFloat32.

func (n NullFloat32) MarshalJSON() ([]byte, error) {

return nulljson(n.Valid, n.Float32)

}

// UnmarshalJSON implements json.Unmarshaler.UnmarshalJSON for NullFloat32.

func (n *NullFloat32) UnmarshalJSON(payload []byte) error {

if payload == nil {

return errPayloadNil

}

if jsonIsNull(payload) {

n.Float32 = float32(0)

n.Valid = false

return nil

}

num, err := strconv.ParseFloat(string(payload), 32)

if err != nil {

return fmt.Errorf("payload cannot be converted to float32: got %v", string(payload))

}

n.Float32 = float32(num)

n.Valid = true

return nil

}

// Value implements the driver.Valuer interface.

func (n NullFloat32) Value() (driver.Value, error) {

if n.IsNull() {

return nil, nil

}

return n.Float32, nil

}

// Scan implements the sql.Scanner interface.

func (n *NullFloat32) Scan(value interface{}) error {

if value == nil {

n.Float32, n.Valid = 0, false

return nil

}

n.Valid = true

switch p := value.(type) {

default:

return spannerErrorf(codes.InvalidArgument, "invalid type for NullFloat32: %v", p)

case *float32:

if p == nil {

n.Float32, n.Valid = 0, false

} else {

n.Float32 = *p

}

case float32:

n.Float32 = p

case *NullFloat32:

if p == nil {

n.Float32, n.Valid = 0, false

} else {

n.Float32 = p.Float32

n.Valid = p.Valid

}

case NullFloat32:

n.Float32 = p.Float32

n.Valid = p.Valid

case string:

f, err := strconv.ParseFloat(p, 32)

if err != nil {

return err

}

n.Float32 = float32(f)

n.Valid = true

case *string:

if p == nil {

n.Float32, n.Valid = 0, false

return nil

}

f, err := strconv.ParseFloat(*p, 32)

if err != nil {

return err

}

n.Float32 = float32(f)

n.Valid = true

}

return nil

}

// GormDataType is used by gorm to determine the default data type for fields with this type.

func (n NullFloat32) GormDataType() string {

return "FLOAT32"

}

// NullBool represents a Cloud Spanner BOOL that may be NULL.

type NullBool struct {

Bool bool // Bool contains the value when it is non-NULL, and false when NULL.

Valid bool // Valid is true if Bool is not NULL.

}

// IsNull implements NullableValue.IsNull for NullBool.

func (n NullBool) IsNull() bool {

return !n.Valid

}

// String implements Stringer.String for NullBool

func (n NullBool) String() string {

if !n.Valid {

return nullString

}

return fmt.Sprintf("%v", n.Bool)

}

// MarshalJSON implements json.Marshaler.MarshalJSON for NullBool.

func (n NullBool) MarshalJSON() ([]byte, error) {

return nulljson(n.Valid, n.Bool)

}

// UnmarshalJSON implements json.Unmarshaler.UnmarshalJSON for NullBool.

func (n *NullBool) UnmarshalJSON(payload []byte) error {

if payload == nil {

return errPayloadNil

}

if jsonIsNull(payload) {

n.Bool = false

n.Valid = false

return nil

}

b, err := strconv.ParseBool(string(payload))

if err != nil {

return fmt.Errorf("payload cannot be converted to bool: got %v", string(payload))

}

n.Bool = b

n.Valid = true

return nil

}

// Value implements the driver.Valuer interface.

func (n NullBool) Value() (driver.Value, error) {

if n.IsNull() {

return nil, nil

}

return n.Bool, nil

}

// Scan implements the sql.Scanner interface.

func (n *NullBool) Scan(value interface{}) error {

if value == nil {

n.Bool, n.Valid = false, false

return nil

}

n.Valid = true

switch p := value.(type) {

default:

return spannerErrorf(codes.InvalidArgument, "invalid type for NullBool: %v", p)

case *bool:

if p == nil {

n.Bool, n.Valid = false, false

} else {

n.Bool = *p

}

case bool:

n.Bool = p

case *NullBool:

if p == nil {

n.Bool, n.Valid = false, false

} else {

n.Bool = p.Bool

n.Valid = p.Valid

}

case NullBool:

n.Bool = p.Bool

n.Valid = p.Valid

case string:

f, err := strconv.ParseBool(p)

if err != nil {

return err

}

n.Bool = f

n.Valid = true

case *string:

if p == nil {

n.Bool, n.Valid = false, false

return nil

}

f, err := strconv.ParseBool(*p)

if err != nil {

return err

}

n.Bool = f

n.Valid = true

}

return nil

}

// GormDataType is used by gorm to determine the default data type for fields with this type.

func (n NullBool) GormDataType() string {

return "BOOL"

}

// NullTime represents a Cloud Spanner TIMESTAMP that may be null.

type NullTime struct {

Time time.Time // Time contains the value when it is non-NULL, and a zero time.Time when NULL.

Valid bool // Valid is true if Time is not NULL.

}

// IsNull implements NullableValue.IsNull for NullTime.

func (n NullTime) IsNull() bool {

return !n.Valid

}

// String implements Stringer.String for NullTime

func (n NullTime) String() string {

if !n.Valid {

return nullString

}

return n.Time.Format(time.RFC3339Nano)

}

// MarshalJSON implements json.Marshaler.MarshalJSON for NullTime.

func (n NullTime) MarshalJSON() ([]byte, error) {

return nulljson(n.Valid, n.Time)

}

// UnmarshalJSON implements json.Unmarshaler.UnmarshalJSON for NullTime.

func (n *NullTime) UnmarshalJSON(payload []byte) error {

if payload == nil {

return errPayloadNil

}

if jsonIsNull(payload) {

n.Time = time.Time{}

n.Valid = false

return nil

}

payload, err := trimDoubleQuotes(payload)

if err != nil {

return err

}

s := string(payload)

t, err := time.Parse(time.RFC3339Nano, s)

if err != nil {

return fmt.Errorf("payload cannot be converted to time.Time: got %v", string(payload))

}

n.Time = t

n.Valid = true

return nil

}

// Value implements the driver.Valuer interface.

func (n NullTime) Value() (driver.Value, error) {

if n.IsNull() {

return nil, nil

}

return n.Time, nil

}

// Scan implements the sql.Scanner interface.

func (n *NullTime) Scan(value interface{}) error {

if value == nil {

n.Time, n.Valid = time.Time{}, false

return nil

}

n.Valid = true

switch p := value.(type) {

default:

return spannerErrorf(codes.InvalidArgument, "invalid type for NullTime: %v", p)

case *time.Time:

if p == nil {

n.Time, n.Valid = time.Time{}, false

} else {

n.Time = *p

}

case time.Time:

n.Time = p

case *NullTime:

if p == nil {

n.Time, n.Valid = time.Time{}, false

} else {

n.Time = p.Time

n.Valid = p.Valid

}

case NullTime:

n.Time = p.Time

n.Valid = p.Valid

case string:

f, err := time.Parse(time.RFC3339Nano, p)

if err != nil {

return err

}

n.Time = f

n.Valid = true

case *string:

if p == nil {

n.Time, n.Valid = time.Time{}, false

return nil

}

f, err := time.Parse(time.RFC3339Nano, *p)

if err != nil {

return err

}

n.Time = f

n.Valid = true

}

return nil

}

// GormDataType is used by gorm to determine the default data type for fields with this type.

func (n NullTime) GormDataType() string {

return "TIMESTAMP"

}

// NullDate represents a Cloud Spanner DATE that may be null.

type NullDate struct {

Date civil.Date // Date contains the value when it is non-NULL, and a zero civil.Date when NULL.

Valid bool // Valid is true if Date is not NULL.

}

// IsNull implements NullableValue.IsNull for NullDate.

func (n NullDate) IsNull() bool {

return !n.Valid

}

// String implements Stringer.String for NullDate

func (n NullDate) String() string {

if !n.Valid {

return nullString

}

return n.Date.String()

}

// MarshalJSON implements json.Marshaler.MarshalJSON for NullDate.

func (n NullDate) MarshalJSON() ([]byte, error) {

return nulljson(n.Valid, n.Date)

}

// UnmarshalJSON implements json.Unmarshaler.UnmarshalJSON for NullDate.

func (n *NullDate) UnmarshalJSON(payload []byte) error {

if payload == nil {

return errPayloadNil

}

if jsonIsNull(payload) {

n.Date = civil.Date{}

n.Valid = false

return nil

}

payload, err := trimDoubleQuotes(payload)

if err != nil {

return err

}

s := string(payload)

t, err := civil.ParseDate(s)

if err != nil {

return fmt.Errorf("payload cannot be converted to civil.Date: got %v", string(payload))

}

n.Date = t

n.Valid = true

return nil

}

// Value implements the driver.Valuer interface.

func (n NullDate) Value() (driver.Value, error) {

if n.IsNull() {

return nil, nil

}

return n.Date, nil

}

// Scan implements the sql.Scanner interface.

func (n *NullDate) Scan(value interface{}) error {

if value == nil {

n.Date, n.Valid = civil.Date{}, false

return nil

}

n.Valid = true

switch p := value.(type) {

default:

d := civil.Date{}

if err := d.Scan(value); err != nil {

return err

}

n.Date = d

n.Valid = true

case *civil.Date:

if p == nil {

n.Date, n.Valid = civil.Date{}, false

} else {

n.Date = *p

}

case civil.Date:

n.Date = p

case *NullDate:

if p == nil {

n.Date, n.Valid = civil.Date{}, false

} else {

n.Date = p.Date

n.Valid = p.Valid

}

case NullDate:

n.Date = p.Date

n.Valid = p.Valid

}

return nil

}

// GormDataType is used by gorm to determine the default data type for fields with this type.

func (n NullDate) GormDataType() string {

return "DATE"

}

// NullNumeric represents a Cloud Spanner Numeric that may be NULL.

type NullNumeric struct {

Numeric big.Rat // Numeric contains the value when it is non-NULL, and a zero big.Rat when NULL.

Valid bool // Valid is true if Numeric is not NULL.

}

// IsNull implements NullableValue.IsNull for NullNumeric.

func (n NullNumeric) IsNull() bool {

return !n.Valid

}

// String implements Stringer.String for NullNumeric

func (n NullNumeric) String() string {

if !n.Valid {

return nullString

}

return fmt.Sprintf("%v", NumericString(&n.Numeric))

}

// MarshalJSON implements json.Marshaler.MarshalJSON for NullNumeric.

func (n NullNumeric) MarshalJSON() ([]byte, error) {

return nulljson(n.Valid, NumericString(&n.Numeric))

}

// UnmarshalJSON implements json.Unmarshaler.UnmarshalJSON for NullNumeric.

func (n *NullNumeric) UnmarshalJSON(payload []byte) error {

if payload == nil {

return errPayloadNil

}

if jsonIsNull(payload) {

n.Numeric = big.Rat{}

n.Valid = false

return nil

}

payload, err := trimDoubleQuotes(payload)

if err != nil {

return err

}

s := string(payload)

val, ok := (&big.Rat{}).SetString(s)

if !ok {

return fmt.Errorf("payload cannot be converted to big.Rat: got %v", string(payload))

}

n.Numeric = *val

n.Valid = true

return nil

}

// Value implements the driver.Valuer interface.

func (n NullNumeric) Value() (driver.Value, error) {

if n.IsNull() {

return nil, nil

}

return n.Numeric, nil

}

// Scan implements the sql.Scanner interface.

func (n *NullNumeric) Scan(value interface{}) error {

if value == nil {

n.Numeric, n.Valid = big.Rat{}, false

return nil

}

n.Valid = true

switch p := value.(type) {

default:

return spannerErrorf(codes.InvalidArgument, "invalid type for NullNumeric: %v", p)

case *big.Rat:

if p == nil {

n.Numeric, n.Valid = big.Rat{}, false

} else {

n.Numeric = *p

}

case big.Rat: