module Fint.Variant

open System

open Fint.Utils

type VariantValue =

| VarNull

| VarBool of bool

| VarChar of char

| VarInt8 of sbyte

| VarUInt8 of byte

| VarInt16 of int16

| VarUInt16 of uint16

| VarInt32 of int32

| VarUInt32 of uint32

| VarInt64 of int64

| VarUInt64 of uint64

| VarSingle of float32

| VarDouble of double

| VarDecimal of decimal

| VarString of string

| VarObject of obj

let roundDouble (v: double) =

let t = Math.Truncate(v)

let a = if v - t > 0.5 then 1.0 else 0.0

t + a

let roundDecimal (v: decimal) =

let t = Math.Truncate(v)

let a = if v - t > decimal 0.5 then 1.0 else 0.0

t + decimal a

let boolI32(v: bool) = if v then 1 else 0

let boolU32(v: bool) = if v then 1u else 0u

let boolI64(v: bool) = if v then 1L else 0L

let boolU64(v: bool) = if v then 1UL else 0UL

let boolSingle(v: bool) = if v then float32 1 else float32 0

let boolDouble(v: bool) = if v then 1.0 else 0.0

let boolDecimal(v: bool) = if v then decimal 1 else decimal 0

let cmpI32(v: int32) =

if v = 0 then 0

elif v < 0 then -1

else 1

let cmpU32(v: uint32) =

if v = 0u then 0

elif v < 0u then -1

else 1

let cmpI64(v: int64) =

if v = 0L then 0

elif v < 0L then -1

else 1

let cmpU64(v: uint64) =

if v = 0UL then 0

elif v < 0UL then -1

else 1

let cmpSingle (v: float32) =

if v = float32 0 then 0

elif v < float32 0 then -1

else 1

let cmpDouble (v: double) =

if v = 0.0 then 0

elif v < 0.0 then -1

else 1

let cmpDecimal (v: decimal) =

if v = decimal 0 then 0

elif v < decimal 0 then -1

else 1

type Variant(value: VariantValue) =

member val value = value

static member Of(v: obj) =

match v with

| null -> Variant(VarNull)

| _ ->

match Type.GetTypeCode(v.GetType()) with

| TypeCode.Boolean -> Variant(VarBool(v :?> bool))

| TypeCode.Char -> Variant(VarChar(v :?> char))

| TypeCode.SByte -> Variant(VarInt8(v :?> sbyte))

| TypeCode.Byte -> Variant(VarUInt8(v :?> byte))

| TypeCode.Int16 -> Variant(VarInt16(v :?> int16))

| TypeCode.UInt16 -> Variant(VarUInt16(v :?> uint16))

| TypeCode.Int32 -> Variant(VarInt32(v :?> int32))

| TypeCode.UInt32 -> Variant(VarUInt32(v :?> uint32))

| TypeCode.Int64 -> Variant(VarInt64(v :?> int64))

| TypeCode.UInt64 -> Variant(VarUInt64(v :?> uint64))

| TypeCode.Single -> Variant(VarSingle(v :?> float32))

| TypeCode.Double -> Variant(VarDouble(v :?> double))

| TypeCode.Decimal -> Variant(VarDecimal(v :?> decimal))

| TypeCode.String -> Variant(VarString(v :?> string))

| _ -> Variant(VarObject(v))

member this.IsNull() =

match this.value with

| VarNull -> true

| _ -> false

member this.ToBoolean() =

match this.value with

| VarNull -> false

| VarBool t -> t

| VarChar t -> int t <> 0

| VarInt8 t -> int t <> 0

| VarUInt8 t -> int t <> 0

| VarInt16 t -> int t <> 0

| VarUInt16 t -> int t <> 0

| VarInt32 t -> t <> 0

| VarUInt32 t -> t <> 0u

| VarInt64 t -> t <> 0L

| VarUInt64 t -> t <> 0UL

| VarSingle t -> t <> float32 0

| VarDouble t -> t <> 0.0

| VarDecimal t -> t <> decimal 0

| VarString _ -> true

| VarObject _ -> true

member this.ToChar() =

match this.value with

| VarNull -> char 0

| VarBool t -> char(boolU32(t))

| VarChar t -> char t

| VarInt8 t -> char t

| VarUInt8 t -> char t

| VarInt16 t -> char t

| VarUInt16 t -> char t

| VarInt32 t -> char t

| VarUInt32 t -> char t

| VarInt64 t -> char t

| VarUInt64 t -> char t

| VarSingle t -> char t

| VarDouble t -> char t

| VarDecimal t -> char t

| _ -> notSupported()

member this.ToSByte() =

match this.value with

| VarNull -> sbyte 0

| VarBool t -> sbyte(boolI32(t))

| VarChar t -> sbyte t

| VarInt8 t -> sbyte t

| VarUInt8 t -> sbyte t

| VarInt16 t -> sbyte t

| VarUInt16 t -> sbyte t

| VarInt32 t -> sbyte t

| VarUInt32 t -> sbyte t

| VarInt64 t -> sbyte t

| VarUInt64 t -> sbyte t

| VarSingle t -> sbyte t

| VarDouble t -> sbyte t

| VarDecimal t -> sbyte t

| _ -> notSupported()

member this.ToByte() =

match this.value with

| VarNull -> byte 0

| VarBool t -> byte(boolI32(t))

| VarChar t -> byte t

| VarInt8 t -> byte t

| VarUInt8 t -> byte t

| VarInt16 t -> byte t

| VarUInt16 t -> byte t

| VarInt32 t -> byte t

| VarUInt32 t -> byte t

| VarInt64 t -> byte t

| VarUInt64 t -> byte t

| VarSingle t -> byte t

| VarDouble t -> byte t

| VarDecimal t -> byte t

| _ -> notSupported()

member this.ToInt16() =

match this.value with

| VarNull -> int16 0

| VarBool t -> int16(boolI32(t))

| VarChar t -> int16 t

| VarInt8 t -> int16 t

| VarUInt8 t -> int16 t

| VarInt16 t -> int16 t

| VarUInt16 t -> int16 t

| VarInt32 t -> int16 t

| VarUInt32 t -> int16 t

| VarInt64 t -> int16 t

| VarUInt64 t -> int16 t

| VarSingle t -> int16 t

| VarDouble t -> int16 t

| VarDecimal t -> int16 t

| _ -> notSupported()

member this.ToUInt16() =

match this.value with

| VarNull -> uint16 0

| VarBool t -> uint16(boolI32(t))

| VarChar t -> uint16 t

| VarInt8 t -> uint16 t

| VarUInt8 t -> uint16 t

| VarInt16 t -> uint16 t

| VarUInt16 t -> uint16 t

| VarInt32 t -> uint16 t

| VarUInt32 t -> uint16 t

| VarInt64 t -> uint16 t

| VarUInt64 t -> uint16 t

| VarSingle t -> uint16 t

| VarDouble t -> uint16 t

| VarDecimal t -> uint16 t

| _ -> notSupported()

member this.ToInt32() =

match this.value with

| VarNull -> 0

| VarBool t -> boolI32(t)

| VarChar t -> int t

| VarInt8 t -> int t

| VarUInt8 t -> int t

| VarInt16 t -> int t

| VarUInt16 t -> int t

| VarInt32 t -> int t

| VarUInt32 t -> int t

| VarInt64 t -> int t

| VarUInt64 t -> int t

| VarSingle t -> int t

| VarDouble t -> int t

| VarDecimal t -> int t

| VarString t -> Convert.ToInt32(t)

| _ -> notSupported()

member this.ToUInt32() =

match this.value with

| VarNull -> 0u

| VarBool t -> boolU32(t)

| VarChar t -> uint32 t

| VarInt8 t -> uint32 t

| VarUInt8 t -> uint32 t

| VarInt16 t -> uint32 t

| VarUInt16 t -> uint32 t

| VarInt32 t -> uint32 t

| VarUInt32 t -> uint32 t

| VarInt64 t -> uint32 t

| VarUInt64 t -> uint32 t

| VarSingle t -> uint32 t

| VarDouble t -> uint32 t

| VarDecimal t -> uint32 t

| VarString t -> Convert.ToUInt32(t)

| _ -> notSupported()

member this.ToInt64() =

match this.value with

| VarNull -> 0L

| VarBool t -> if t then 1L else 0L

| VarChar t -> int64 t

| VarInt8 t -> int64 t

| VarUInt8 t -> int64 t

| VarInt16 t -> int64 t

| VarUInt16 t -> int64 t

| VarInt32 t -> int64 t

| VarUInt32 t -> int64 t

| VarInt64 t -> int64 t

| VarUInt64 t -> int64 t

| VarSingle t -> int64 t

| VarDouble t -> int64 t

| VarDecimal t -> int64 t

| VarString t -> Convert.ToInt64(t)

| _ -> notSupported()

member this.ToUInt64() =

match this.value with

| VarNull -> 0UL

| VarBool t -> if t then 1UL else 0UL

| VarChar t -> uint64 t

| VarInt8 t -> uint64 t

| VarUInt8 t -> uint64 t

| VarInt16 t -> uint64 t

| VarUInt16 t -> uint64 t

| VarInt32 t -> uint64 t

| VarUInt32 t -> uint64 t

| VarInt64 t -> uint64 t

| VarUInt64 t -> uint64 t

| VarSingle t -> uint64 t

| VarDouble t -> uint64 t

| VarDecimal t -> uint64 t

| VarString t -> Convert.ToUInt64(t)

| _ -> notSupported()

member this.ToSingle() =

match this.value with

| VarNull -> float32 0

| VarBool t -> if t then float32 1 else float32 0

| VarChar t -> float32 t

| VarInt8 t -> float32 t

| VarUInt8 t -> float32 t

| VarInt16 t -> float32 t

| VarUInt16 t -> float32 t

| VarInt32 t -> float32 t

| VarUInt32 t -> float32 t

| VarInt64 t -> float32 t

| VarUInt64 t -> float32 t

| VarSingle t -> float32 t

| VarDouble t -> float32 t

| VarDecimal t -> float32 t

| VarString t -> Convert.ToSingle(t)

| _ -> notSupported()

member this.ToDouble() =

match this.value with

| VarNull -> 0.0

| VarBool t -> if t then 1.0 else 0.0

| VarChar t -> double t

| VarInt8 t -> double t

| VarUInt8 t -> double t

| VarInt16 t -> double t

| VarUInt16 t -> double t

| VarInt32 t -> double t

| VarUInt32 t -> double t

| VarInt64 t -> double t

| VarUInt64 t -> double t

| VarSingle t -> double t

| VarDouble t -> double t

| VarDecimal t -> double t

| VarString t -> Convert.ToDouble(t)

| _ -> notSupported()

member this.ToDecimal() =

match this.value with

| VarNull -> decimal 0

| VarBool t -> if t then decimal 1 else decimal 0

| VarChar t -> decimal (uint32 t)

| VarInt8 t -> decimal t

| VarUInt8 t -> decimal t

| VarInt16 t -> decimal t

| VarUInt16 t -> decimal t

| VarInt32 t -> decimal t

| VarUInt32 t -> decimal t

| VarInt64 t -> decimal t

| VarUInt64 t -> decimal t

| VarSingle t -> decimal t

| VarDouble t -> decimal t

| VarDecimal t -> decimal t

| VarString t -> Convert.ToDecimal(t)

| _ -> notSupported()

member this.ToObject() =

match this.value with

| VarNull -> null

| VarBool t -> t :> obj

| VarChar t -> t :> obj

| VarInt8 t -> t :> obj

| VarUInt8 t -> t :> obj

| VarInt16 t -> t :> obj

| VarUInt16 t -> t :> obj

| VarInt32 t -> t :> obj

| VarUInt32 t -> t :> obj

| VarInt64 t -> t :> obj

| VarUInt64 t -> t :> obj

| VarSingle t -> t :> obj

| VarDouble t -> t :> obj

| VarDecimal t -> t :> obj

| VarString t -> t :> obj

| VarObject t -> t

override this.ToString() =

match this.value with

| VarNull -> null

| VarBool t -> t.ToString()

| VarChar t -> t.ToString()

| VarInt8 t -> t.ToString()

| VarUInt8 t -> t.ToString()

| VarInt16 t -> t.ToString()

| VarUInt16 t -> t.ToString()

| VarInt32 t -> t.ToString()

| VarUInt32 t -> t.ToString()

| VarInt64 t -> t.ToString()

| VarUInt64 t -> t.ToString()

| VarSingle t -> t.ToString()

| VarDouble t -> t.ToString()

| VarDecimal t -> t.ToString()

| VarString t -> t.ToString()

| VarObject t -> t.ToString()

member this.ToUnsigned() =

match this.value with

| VarBool x -> Variant(VarUInt32(boolU32(x)))

| VarChar x -> Variant(VarUInt32(uint32 x))

| VarInt8 x -> Variant(VarUInt32(uint32 x))

| VarInt16 x -> Variant(VarUInt32(uint32 x))

| VarInt32 x -> Variant(VarUInt32(uint32 x))

| VarInt64 x -> Variant(VarUInt64(uint64 x))

| _ -> this

member this.ChangeType(t: TypeCode) =

match t with

| TypeCode.Boolean -> Variant(VarBool(this.ToBoolean()))

| TypeCode.Char -> Variant(VarChar(this.ToChar()))

| TypeCode.SByte -> Variant(VarInt8(this.ToSByte()))

| TypeCode.Byte -> Variant(VarUInt8(this.ToByte()))

| TypeCode.Int16 -> Variant(VarInt16(this.ToInt16()))

| TypeCode.UInt16 -> Variant(VarUInt16(this.ToUInt16()))

| TypeCode.Int32 -> Variant(VarInt32(this.ToInt32()))

| TypeCode.UInt32 -> Variant(VarUInt32(this.ToUInt32()))

| TypeCode.Int64 -> Variant(VarInt64(this.ToInt64()))

| TypeCode.UInt64 -> Variant(VarUInt64(this.ToUInt64()))

| TypeCode.Single -> Variant(VarSingle(this.ToSingle()))

| TypeCode.Double -> Variant(VarDouble(this.ToDouble()))

| TypeCode.Decimal -> Variant(VarDecimal(this.ToDecimal()))

| TypeCode.String -> Variant(VarString(this.ToString()))

| _ -> notSupported()

static member Compare (a: Variant) (b: Variant) =

match a.value with

| VarNull ->

match b.value with

| VarNull -> 0

| _ -> -1

| VarBool x ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpI32(boolI32(x) - boolI32(y))

| VarChar y -> cmpI32(boolI32(x) - int32 y)

| VarInt8 y -> cmpI32(boolI32(x) - int32 y)

| VarUInt8 y -> cmpI32(boolI32(x) - int32 y)

| VarInt32 y -> cmpI32(boolI32(x) - int32 y)

| VarUInt32 y -> cmpU32(boolU32(x) - y)

| VarInt64 y -> cmpI64(boolI64(x) - y)

| VarUInt64 y -> cmpU64(boolU64(x) - y)

| VarSingle y -> cmpSingle(boolSingle(x) - y)

| VarDouble y -> cmpDouble(boolDouble(x) - y)

| VarDecimal y -> cmpDecimal(boolDecimal(x) - y)

| VarString _ -> cmpDecimal(boolDecimal(x) - b.ToDecimal())

| _ -> notSupported()

| VarChar x ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpI32(int32 x - boolI32(y))

| VarChar y -> cmpI32(int32 x - int32 y)

| VarInt8 y -> cmpI32(int32 x - int32 y)

| VarUInt8 y -> cmpI32(int32 x - int32 y)

| VarInt32 y -> cmpI32(int32 x - int32 y)

| VarUInt32 y -> cmpU32(uint32 x - y)

| VarInt64 y -> cmpI64(int64 x - y)

| VarUInt64 y -> cmpU64(uint64 x - y)

| VarSingle y -> cmpSingle(float32 x - y)

| VarDouble y -> cmpDouble(double x - y)

| VarDecimal y -> cmpDecimal(decimal(int32 x) - y)

| VarString _ -> cmpDecimal(decimal(int32 x) - b.ToDecimal())

| _ -> notSupported()

| VarInt8 x ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpI32(int32 x - boolI32(y))

| VarChar y -> cmpI32(int32 x - int32 y)

| VarInt8 y -> cmpI32(int32 x - int32 y)

| VarUInt8 y -> cmpI32(int32 x - int32 y)

| VarInt32 y -> cmpI32(int32 x - int32 y)

| VarUInt32 y -> cmpU32(uint32 x - y)

| VarInt64 y -> cmpI64(int64 x - y)

| VarUInt64 y -> cmpU64(uint64 x - y)

| VarSingle y -> cmpSingle(float32 x - y)

| VarDouble y -> cmpDouble(double x - y)

| VarDecimal y -> cmpDecimal(decimal x - y)

| VarString _ -> cmpDecimal(decimal x - b.ToDecimal())

| _ -> notSupported()

| VarUInt8 x ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpI32(int32 x - boolI32(y))

| VarChar y -> cmpI32(int32 x - int32 y)

| VarInt8 y -> cmpI32(int32 x - int32 y)

| VarUInt8 y -> cmpI32(int32 x - int32 y)

| VarInt32 y -> cmpI32(int32 x - int32 y)

| VarUInt32 y -> cmpU32(uint32 x - y)

| VarInt64 y -> cmpI64(int64 x - y)

| VarUInt64 y -> cmpU64(uint64 x - y)

| VarSingle y -> cmpSingle(float32 x - y)

| VarDouble y -> cmpDouble(double x - y)

| VarDecimal y -> cmpDecimal(decimal x - y)

| VarString _ -> cmpDecimal(decimal x - b.ToDecimal())

| _ -> notSupported()

| VarInt16 x ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpI32(int32 x - boolI32(y))

| VarChar y -> cmpI32(int32 x - int32 y)

| VarInt8 y -> cmpI32(int32 x - int32 y)

| VarUInt8 y -> cmpI32(int32 x - int32 y)

| VarInt32 y -> cmpI32(int32 x - int32 y)

| VarUInt32 y -> cmpU32(uint32 x - y)

| VarInt64 y -> cmpI64(int64 x - y)

| VarUInt64 y -> cmpU64(uint64 x - y)

| VarSingle y -> cmpSingle(float32 x - y)

| VarDouble y -> cmpDouble(double x - y)

| VarDecimal y -> cmpDecimal(decimal x - y)

| VarString _ -> cmpDecimal(decimal x - b.ToDecimal())

| _ -> notSupported()

| VarUInt16 x ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpI32(int32 x - boolI32(y))

| VarChar y -> cmpI32(int32 x - int32 y)

| VarInt8 y -> cmpI32(int32 x - int32 y)

| VarUInt8 y -> cmpI32(int32 x - int32 y)

| VarInt32 y -> cmpI32(int32 x - int32 y)

| VarUInt32 y -> cmpU32(uint32 x - y)

| VarInt64 y -> cmpI64(int64 x - y)

| VarUInt64 y -> cmpU64(uint64 x - y)

| VarSingle y -> cmpSingle(float32 x - y)

| VarDouble y -> cmpDouble(double x - y)

| VarDecimal y -> cmpDecimal(decimal x - y)

| VarString _ -> cmpDecimal(decimal x - b.ToDecimal())

| _ -> notSupported()

| VarInt32 x ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpI32(x - boolI32(y))

| VarChar y -> cmpI32(x - int32 y)

| VarInt8 y -> cmpI32(x - int32 y)

| VarUInt8 y -> cmpI32(x - int32 y)

| VarInt32 y -> cmpI32(x - int32 y)

| VarUInt32 y -> cmpU32(uint32 x - y)

| VarInt64 y -> cmpI64(int64 x - y)

| VarUInt64 y -> cmpU64(uint64 x - y)

| VarSingle y -> cmpSingle(float32 x - y)

| VarDouble y -> cmpDouble(double x - y)

| VarDecimal y -> cmpDecimal(decimal x - y)

| VarString _ -> cmpDecimal(decimal x - b.ToDecimal())

| _ -> notSupported()

| VarUInt32 x ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpU32(x - boolU32(y))

| VarChar y -> cmpU32(x - uint32 y)

| VarInt8 y -> cmpU32(x - uint32 y)

| VarUInt8 y -> cmpU32(x - uint32 y)

| VarInt32 y -> cmpU32(x - uint32 y)

| VarUInt32 y -> cmpU32(x - y)

| VarInt64 y -> cmpI64(int64 x - y)

| VarUInt64 y -> cmpU64(uint64 x - y)

| VarSingle y -> cmpSingle(float32 x - y)

| VarDouble y -> cmpDouble(double x - y)

| VarDecimal y -> cmpDecimal(decimal x - y)

| VarString _ -> cmpDecimal(decimal x - b.ToDecimal())

| _ -> notSupported()

| VarInt64 x ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpI64(x - boolI64(y))

| VarChar y -> cmpI64(x - int64 y)

| VarInt8 y -> cmpI64(x - int64 y)

| VarUInt8 y -> cmpI64(x - int64 y)

| VarInt32 y -> cmpI64(x - int64 y)

| VarUInt32 y -> cmpI64(x - int64 y)

| VarInt64 y -> cmpI64(x - y)

| VarUInt64 y -> cmpU64(uint64 x - y)

| VarSingle y -> cmpSingle(float32 x - y)

| VarDouble y -> cmpDouble(double x - y)

| VarDecimal y -> cmpDecimal(decimal x - y)

| VarString _ -> cmpDecimal(decimal x - b.ToDecimal())

| _ -> notSupported()

| VarUInt64 x ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpI64(int64(x - boolU64(y)))

| VarChar y -> cmpU64(x - uint64 y)

| VarInt8 y -> cmpU64(x - uint64 y)

| VarUInt8 y -> cmpU64(x - uint64 y)

| VarInt32 y -> cmpU64(x - uint64 y)

| VarUInt32 y -> cmpU64(x - uint64 y)

| VarInt64 y -> cmpU64(x - uint64 y)

| VarUInt64 y -> cmpU64(x - y)

| VarSingle y -> cmpSingle(float32 x - y)

| VarDouble y -> cmpDouble(double x - y)

| VarDecimal y -> cmpDecimal(decimal x - y)

| VarString _ -> cmpDecimal(decimal x - b.ToDecimal())

| _ -> notSupported()

| VarSingle x ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpSingle(x - boolSingle(y))

| VarChar y -> cmpSingle(x - float32 y)

| VarInt8 y -> cmpSingle(x - float32 y)

| VarUInt8 y -> cmpSingle(x - float32 y)

| VarInt32 y -> cmpSingle(x - float32 y)

| VarUInt32 y -> cmpSingle(x - float32 y)

| VarInt64 y -> cmpSingle(x - float32 y)

| VarUInt64 y -> cmpSingle(x - float32 y)

| VarSingle y -> cmpSingle(x - y)

| VarDouble y -> cmpDouble(double x - y)

| VarDecimal y -> cmpDecimal(decimal x - y)

| VarString _ -> cmpDecimal(decimal x - b.ToDecimal())

| _ -> notSupported()

| VarDouble x ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpDouble(x - boolDouble(y))

| VarChar y -> cmpDouble(x - double y)

| VarInt8 y -> cmpDouble(x - double y)

| VarUInt8 y -> cmpDouble(x - double y)

| VarInt32 y -> cmpDouble(x - double y)

| VarUInt32 y -> cmpDouble(x - double y)

| VarInt64 y -> cmpDouble(x - double y)

| VarUInt64 y -> cmpDouble(x - double y)

| VarSingle y -> cmpDouble(x - double y)

| VarDouble y -> cmpDouble(x - y)

| VarDecimal y -> cmpDecimal(decimal x - y)

| VarString _ -> cmpDecimal(decimal x - b.ToDecimal())

| _ -> notSupported()

| VarDecimal x ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpDecimal(x - boolDecimal(y))

| VarChar y -> cmpDecimal(x - decimal(uint32 y))

| VarInt8 y -> cmpDecimal(x - decimal y)

| VarUInt8 y -> cmpDecimal(x - decimal y)

| VarInt32 y -> cmpDecimal(x - decimal y)

| VarUInt32 y -> cmpDecimal(x - decimal y)

| VarInt64 y -> cmpDecimal(x - decimal y)

| VarUInt64 y -> cmpDecimal(x - decimal y)

| VarSingle y -> cmpDecimal(x - decimal y)

| VarDouble y -> cmpDecimal(x - decimal y)

| VarDecimal y -> cmpDecimal(x - y)

| VarString _ -> cmpDecimal(x - b.ToDecimal())

| _ -> notSupported()

| VarString _ ->

match b.value with

| VarNull -> 1

| VarBool y -> cmpDecimal(a.ToDecimal() - boolDecimal(y))

| VarChar y -> cmpDecimal(a.ToDecimal() - decimal(uint32 y))

| VarInt8 y -> cmpDecimal(a.ToDecimal() - decimal y)

| VarUInt8 y -> cmpDecimal(a.ToDecimal() - decimal y)

| VarInt32 y -> cmpDecimal(a.ToDecimal() - decimal y)

| VarUInt32 y -> cmpDecimal(a.ToDecimal() - decimal y)

| VarInt64 y -> cmpDecimal(a.ToDecimal() - decimal y)

| VarUInt64 y -> cmpDecimal(a.ToDecimal() - decimal y)

| VarSingle y -> cmpDecimal(a.ToDecimal() - decimal y)

| VarDouble y -> cmpDecimal(a.ToDecimal() - decimal y)

| VarDecimal y -> cmpDecimal(a.ToDecimal() - y)

| VarString _ -> cmpDecimal(a.ToDecimal() - b.ToDecimal())

| _ -> notSupported()

| _ -> notSupported()

interface IComparable<Variant> with

member this.CompareTo(v: Variant) = Variant.Compare this v

interface IComparable with

member this.CompareTo(v: obj) = Variant.Compare this (v :?> Variant)

override this.Equals(v: obj) =

if v :? Variant then Variant.Compare this (v :?> Variant) = 0

else false

override this.GetHashCode() =

match this.value with

| VarNull -> 0

| VarBool x -> x.GetHashCode()

| VarChar x -> x.GetHashCode()

| VarInt8 x -> x.GetHashCode()

| VarUInt8 x -> x.GetHashCode()

| VarInt16 x -> x.GetHashCode()

| VarUInt16 x -> x.GetHashCode()

| VarInt32 x -> x.GetHashCode()

| VarUInt32 x -> x.GetHashCode()

| VarInt64 x -> x.GetHashCode()

| VarUInt64 x -> x.GetHashCode()

| VarSingle x -> x.GetHashCode()

| VarDouble x -> x.GetHashCode()

| VarDecimal x -> x.GetHashCode()

| VarString x -> x.GetHashCode()

| VarObject x -> x.GetHashCode()

// <, >, <=, >= operators

static member op_Equality (a: Variant, b: Variant) = Variant.Compare a b = 0

static member op_Inequality (a: Variant, b: Variant) = Variant.Compare a b <> 0

static member op_LessThan (a: Variant, b: Variant) = Variant.Compare a b < 0

static member op_GreaterThan (a: Variant, b: Variant) = Variant.Compare a b > 0

static member op_LessThanOrEqual (a: Variant, b: Variant) = Variant.Compare a b <= 0

static member op_GreaterThanOrEqual (a: Variant, b: Variant) = Variant.Compare a b >= 0

// unary minus

static member op_Negate (a: Variant) =

match a.value with

| VarNull -> a

| VarBool x -> Variant(VarInt32(-boolI32(x)))

| VarChar x -> Variant(VarInt32(-(int32 x)))

| VarInt8 x -> Variant(VarInt8(-x))

| VarUInt8 x -> Variant(VarInt32(-(int32 x)))

| VarInt16 x -> Variant(VarInt16(-x))

| VarUInt16 x -> Variant(VarInt32(-(int32 x)))

| VarInt32 x -> Variant(VarInt32(-x))

| VarUInt32 x -> Variant(VarInt32(-(int32 x)))

| VarInt64 x -> Variant(VarInt64(-x))

| VarUInt64 x -> Variant(VarInt64(-(int64 x)))

| VarSingle x -> Variant(VarSingle(-x))

| VarDouble x -> Variant(VarDouble(-x))

| VarDecimal x -> Variant(VarDecimal(-x))

| VarString _ -> Variant(VarDecimal(-a.ToDecimal()))

| _ -> notSupported()

// operator +

static member (+) (a: Variant, b: Variant) =

match a.value with

| VarNull ->

match b.value with

| VarString _ -> Variant(VarDecimal(b.ToDecimal()))

| VarObject _ -> notSupported()

| _ -> b

| VarBool x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarInt32(boolI32(x) + boolI32(y)))

| VarChar y -> Variant(VarInt32(boolI32(x) + int32 y))

| VarInt8 y -> Variant(VarInt32(boolI32(x) + int32 y))

| VarUInt8 y -> Variant(VarUInt32(boolU32(x) + uint32 y))

| VarInt16 y -> Variant(VarInt32(boolI32(x) + int32 y))

| VarUInt16 y -> Variant(VarUInt32(boolU32(x) + uint32 y))

| VarInt32 y -> Variant(VarInt32(boolI32(x) + int32 y))

| VarUInt32 y -> Variant(VarUInt32(boolU32(x) + y))

| VarInt64 y -> Variant(VarInt64(boolI64(x) + y))

| VarUInt64 y -> Variant(VarUInt64(boolU64(x) + y))

| VarSingle y -> Variant(VarSingle(boolSingle(x) + y))

| VarDouble y -> Variant(VarDouble(boolDouble(x) + y))

| VarDecimal y -> Variant(VarDecimal(boolDecimal(x) + y))

| VarString _ -> Variant(VarDecimal(boolDecimal(x) + b.ToDecimal()))

| _ -> notSupported()

| VarChar x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarUInt32(uint32 x + boolU32(y)))

| VarChar y -> Variant(VarUInt32(uint32 x + uint32 y))

| VarInt8 y -> Variant(VarInt32(int32 x + int32 y))

| VarUInt8 y -> Variant(VarUInt32(uint32 x + uint32 y))

| VarInt16 y -> Variant(VarInt32(int32 x + int32 y))

| VarUInt16 y -> Variant(VarUInt32(uint32 x + uint32 y))

| VarInt32 y -> Variant(VarInt32(int32 x + y))

| VarUInt32 y -> Variant(VarUInt32(uint32 x + y))

| VarInt64 y -> Variant(VarInt64(int64 x + y))

| VarUInt64 y -> Variant(VarUInt64(uint64 x + y))

| VarSingle y -> Variant(VarSingle(float32 x + y))

| VarDouble y -> Variant(VarDouble(double x + y))

| VarDecimal y -> Variant(VarDecimal(decimal(int32 x) + y))

| VarString _ -> Variant(VarDecimal(decimal(int32 x) + b.ToDecimal()))

| _ -> notSupported()

| VarInt8 x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarInt32(int32 x + boolI32(y)))

| VarChar y -> Variant(VarInt32(int32 x + int32 y))

| VarInt8 y -> Variant(VarInt32(int32 x + int32 y))

| VarUInt8 y -> Variant(VarInt32(int32 x + int32 y))

| VarInt16 y -> Variant(VarInt32(int32 x + int32 y))

| VarUInt16 y -> Variant(VarInt32(int32 x + int32 y))

| VarInt32 y -> Variant(VarInt32(int32 x + y))

| VarUInt32 y -> Variant(VarUInt32(uint32 x + y))

| VarInt64 y -> Variant(VarInt64(int64 x + y))

| VarUInt64 y -> Variant(VarUInt64(uint64 x + y))

| VarSingle y -> Variant(VarSingle(float32 x + y))

| VarDouble y -> Variant(VarDouble(double x + y))

| VarDecimal y -> Variant(VarDecimal(decimal x + y))

| VarString _ -> Variant(VarDecimal(decimal x + b.ToDecimal()))

| _ -> notSupported()

| VarUInt8 x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarUInt32(uint32 x + boolU32(y)))

| VarChar y -> Variant(VarUInt32(uint32 x + uint32 y))

| VarInt8 y -> Variant(VarInt32(int32 x + int32 y))

| VarUInt8 y -> Variant(VarUInt32(uint32 x + uint32 y))

| VarInt16 y -> Variant(VarInt32(int32 x + int32 y))

| VarUInt16 y -> Variant(VarUInt32(uint32 x + uint32 y))

| VarInt32 y -> Variant(VarInt32(int32 x + y))

| VarUInt32 y -> Variant(VarUInt32(uint32 x + y))

| VarInt64 y -> Variant(VarInt64(int64 x + y))

| VarUInt64 y -> Variant(VarUInt64(uint64 x + y))

| VarSingle y -> Variant(VarSingle(float32 x + y))

| VarDouble y -> Variant(VarDouble(double x + y))

| VarDecimal y -> Variant(VarDecimal(decimal x + y))

| VarString _ -> Variant(VarDecimal(decimal x + b.ToDecimal()))

| _ -> notSupported()

| VarInt16 x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarInt32(int32 x + boolI32(y)))

| VarChar y -> Variant(VarInt32(int32 x + int32 y))

| VarInt8 y -> Variant(VarInt32(int32 x + int32 y))

| VarUInt8 y -> Variant(VarInt32(int32 x + int32 y))

| VarInt16 y -> Variant(VarInt32(int32 x + int32 y))

| VarUInt16 y -> Variant(VarInt32(int32 x + int32 y))

| VarInt32 y -> Variant(VarInt32(int32 x + y))

| VarUInt32 y -> Variant(VarUInt32(uint32 x + y))

| VarInt64 y -> Variant(VarInt64(int64 x + y))

| VarUInt64 y -> Variant(VarUInt64(uint64 x + y))

| VarSingle y -> Variant(VarSingle(float32 x + y))

| VarDouble y -> Variant(VarDouble(double x + y))

| VarDecimal y -> Variant(VarDecimal(decimal x + y))

| VarString _ -> Variant(VarDecimal(decimal x + b.ToDecimal()))

| _ -> notSupported()

| VarUInt16 x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarUInt32(uint32 x + boolU32(y)))

| VarChar y -> Variant(VarUInt32(uint32 x + uint32 y))

| VarInt8 y -> Variant(VarInt32(int32 x + int32 y))

| VarUInt8 y -> Variant(VarUInt32(uint32 x + uint32 y))

| VarInt16 y -> Variant(VarInt32(int32 x + int32 y))

| VarUInt16 y -> Variant(VarUInt32(uint32 x + uint32 y))

| VarInt32 y -> Variant(VarInt32(int32 x + y))

| VarUInt32 y -> Variant(VarUInt32(uint32 x + y))

| VarInt64 y -> Variant(VarInt64(int64 x + y))

| VarUInt64 y -> Variant(VarUInt64(uint64 x + y))

| VarSingle y -> Variant(VarSingle(float32 x + y))

| VarDouble y -> Variant(VarDouble(double x + y))

| VarDecimal y -> Variant(VarDecimal(decimal x + y))

| VarString _ -> Variant(VarDecimal(decimal x + b.ToDecimal()))

| _ -> notSupported()

| VarInt32 x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarInt32(x + boolI32(y)))

| VarChar y -> Variant(VarInt32(x + int32 y))

| VarInt8 y -> Variant(VarInt32(x + int32 y))

| VarUInt8 y -> Variant(VarInt32(x + int32 y))

| VarInt16 y -> Variant(VarInt32(x + int32 y))

| VarUInt16 y -> Variant(VarInt32(x + int32 y))

| VarInt32 y -> Variant(VarInt32(x + y))

| VarUInt32 y -> Variant(VarInt32(x + int32 y))

| VarInt64 y -> Variant(VarInt64(int64 x + y))

| VarUInt64 y -> Variant(VarUInt64(uint64 x + y))

| VarSingle y -> Variant(VarSingle(float32 x + y))

| VarDouble y -> Variant(VarDouble(double x + y))

| VarDecimal y -> Variant(VarDecimal(decimal x + y))

| VarString _ -> Variant(VarDecimal(decimal x + b.ToDecimal()))

| _ -> notSupported()

| VarUInt32 x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarUInt32(x + boolU32(y)))

| VarChar y -> Variant(VarUInt32(x + uint32 y))

| VarInt8 y -> Variant(VarUInt32(x + uint32 y))

| VarUInt8 y -> Variant(VarUInt32(x + uint32 y))

| VarInt16 y -> Variant(VarUInt32(x + uint32 y))

| VarUInt16 y -> Variant(VarUInt32(x + uint32 y))

| VarInt32 y -> Variant(VarInt32(int32 x + y))

| VarUInt32 y -> Variant(VarUInt32(uint32 x + y))

| VarInt64 y -> Variant(VarInt64(int64 x + y))

| VarUInt64 y -> Variant(VarUInt64(uint64 x + y))

| VarSingle y -> Variant(VarSingle(float32 x + y))

| VarDouble y -> Variant(VarDouble(double x + y))

| VarDecimal y -> Variant(VarDecimal(decimal x + y))

| VarString _ -> Variant(VarDecimal(decimal x + b.ToDecimal()))

| _ -> notSupported()

| VarInt64 x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarInt64(x + boolI64(y)))

| VarChar y -> Variant(VarInt64(x + int64 y))

| VarInt8 y -> Variant(VarInt64(x + int64 y))

| VarUInt8 y -> Variant(VarInt64(x + int64 y))

| VarInt16 y -> Variant(VarInt64(x + int64 y))

| VarUInt16 y -> Variant(VarInt64(x + int64 y))

| VarInt32 y -> Variant(VarInt64(x + int64 y))

| VarUInt32 y -> Variant(VarInt64(x + int64 y))

| VarInt64 y -> Variant(VarInt64(x + y))

| VarUInt64 y -> Variant(VarInt64(x + int64 y))

| VarSingle y -> Variant(VarDouble(double x + double y))

| VarDouble y -> Variant(VarDouble(double x + y))

| VarDecimal y -> Variant(VarDecimal(decimal x + y))

| VarString _ -> Variant(VarDecimal(decimal x + b.ToDecimal()))

| _ -> notSupported()

| VarUInt64 x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarUInt64(x + boolU64(y)))

| VarChar y -> Variant(VarUInt64(x + uint64 y))

| VarInt8 y -> Variant(VarInt64(int64 x + int64 y))

| VarUInt8 y -> Variant(VarUInt64(x + uint64 y))

| VarInt16 y -> Variant(VarInt64(int64 x + int64 y))

| VarUInt16 y -> Variant(VarUInt64(x + uint64 y))

| VarInt32 y -> Variant(VarInt64(int64 x + int64 y))

| VarUInt32 y -> Variant(VarUInt64(x + uint64 y))

| VarInt64 y -> Variant(VarInt64(int64 x + y))

| VarUInt64 y -> Variant(VarUInt64(x + y))

| VarSingle y -> Variant(VarDouble(double x + double y))

| VarDouble y -> Variant(VarDouble(double x + y))

| VarDecimal y -> Variant(VarDecimal(decimal x + y))

| VarString _ -> Variant(VarDecimal(decimal x + b.ToDecimal()))

| _ -> notSupported()

| VarSingle x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarSingle(x + boolSingle(y)))

| VarChar y -> Variant(VarSingle(x + float32 y))

| VarInt8 y -> Variant(VarSingle(x + float32 y))

| VarUInt8 y -> Variant(VarSingle(x + float32 y))

| VarInt16 y -> Variant(VarSingle(x + float32 y))

| VarUInt16 y -> Variant(VarSingle(x + float32 y))

| VarInt32 y -> Variant(VarSingle(x + float32 y))

| VarUInt32 y -> Variant(VarSingle(x + float32 y))

| VarInt64 y -> Variant(VarSingle(x + float32 y))

| VarUInt64 y -> Variant(VarSingle(x + float32 y))

| VarSingle y -> Variant(VarSingle(x + y))

| VarDouble y -> Variant(VarDouble(double x + y))

| VarDecimal y -> Variant(VarDecimal(decimal x + y))

| VarString _ -> Variant(VarDecimal(decimal x + b.ToDecimal()))

| _ -> notSupported()

| VarDouble x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarDouble(x + boolDouble(y)))

| VarChar y -> Variant(VarDouble(x + double y))

| VarInt8 y -> Variant(VarDouble(x + double y))

| VarUInt8 y -> Variant(VarDouble(x + double y))

| VarInt16 y -> Variant(VarDouble(x + double y))

| VarUInt16 y -> Variant(VarDouble(x + double y))

| VarInt32 y -> Variant(VarDouble(x + double y))

| VarUInt32 y -> Variant(VarDouble(x + double y))

| VarInt64 y -> Variant(VarDouble(x + double y))

| VarUInt64 y -> Variant(VarDouble(x + double y))

| VarSingle y -> Variant(VarDouble(x + double y))

| VarDouble y -> Variant(VarDouble(x + y))

| VarDecimal y -> Variant(VarDecimal(decimal x + y))

| VarString _ -> Variant(VarDecimal(decimal x + b.ToDecimal()))

| _ -> notSupported()

| VarDecimal x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarDecimal(x + boolDecimal(y)))

| VarChar y -> Variant(VarDecimal(x + decimal(int32 y)))

| VarInt8 y -> Variant(VarDecimal(x + decimal y))

| VarUInt8 y -> Variant(VarDecimal(x + decimal y))

| VarInt16 y -> Variant(VarDecimal(x + decimal y))

| VarUInt16 y -> Variant(VarDecimal(x + decimal y))

| VarInt32 y -> Variant(VarDecimal(x + decimal y))

| VarUInt32 y -> Variant(VarDecimal(x + decimal y))

| VarInt64 y -> Variant(VarDecimal(x + decimal y))

| VarUInt64 y -> Variant(VarDecimal(x + decimal y))

| VarSingle y -> Variant(VarDecimal(x + decimal y))

| VarDouble y -> Variant(VarDecimal(x + decimal y))

| VarDecimal y -> Variant(VarDecimal(x + y))

| VarString _ -> Variant(VarDecimal(decimal x + b.ToDecimal()))

| _ -> notSupported()

| VarString _ ->

match b.value with

| VarNull -> Variant(VarDecimal(a.ToDecimal()))

| VarBool y -> Variant(VarDecimal(a.ToDecimal() + boolDecimal(y)))

| VarChar y -> Variant(VarDecimal(a.ToDecimal() + decimal(int32 y)))

| VarInt8 y -> Variant(VarDecimal(a.ToDecimal() + decimal y))

| VarUInt8 y -> Variant(VarDecimal(a.ToDecimal() + decimal y))

| VarInt16 y -> Variant(VarDecimal(a.ToDecimal() + decimal y))

| VarUInt16 y -> Variant(VarDecimal(a.ToDecimal() + decimal y))

| VarInt32 y -> Variant(VarDecimal(a.ToDecimal() + decimal y))

| VarUInt32 y -> Variant(VarDecimal(a.ToDecimal() + decimal y))

| VarInt64 y -> Variant(VarDecimal(a.ToDecimal() + decimal y))

| VarUInt64 y -> Variant(VarDecimal(a.ToDecimal() + decimal y))

| VarSingle y -> Variant(VarDecimal(a.ToDecimal() + decimal y))

| VarDouble y -> Variant(VarDecimal(a.ToDecimal() + decimal y))

| VarDecimal y -> Variant(VarDecimal(a.ToDecimal() + y))

| VarString _ -> Variant(VarDecimal(a.ToDecimal() + b.ToDecimal()))

| _ -> notSupported()

| _ -> notSupported()

// operator -

static member (-) (a: Variant, b: Variant) =

match a.value with

| VarNull ->

match b.value with

| VarString _ -> Variant(VarDecimal(-b.ToDecimal()))

| VarObject _ -> notSupported()

| _ -> Variant.op_Negate(b)

| VarBool x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarInt32(boolI32(x) - boolI32(y)))

| VarChar y -> Variant(VarInt32(boolI32(x) - int32 y))

| VarInt8 y -> Variant(VarInt32(boolI32(x) - int32 y))

| VarUInt8 y -> Variant(VarInt32(boolI32(x) - int32 y))

| VarInt16 y -> Variant(VarInt32(boolI32(x) - int32 y))

| VarUInt16 y -> Variant(VarInt32(boolI32(x) - int32 y))

| VarInt32 y -> Variant(VarInt32(boolI32(x) - int32 y))

| VarUInt32 y -> Variant(VarUInt32(boolU32(x) - y))

| VarInt64 y -> Variant(VarInt64(boolI64(x) - y))

| VarUInt64 y -> Variant(VarUInt64(boolU64(x) - y))

| VarSingle y -> Variant(VarSingle(boolSingle(x) - y))

| VarDouble y -> Variant(VarDouble(boolDouble(x) - y))

| VarDecimal y -> Variant(VarDecimal(boolDecimal(x) - y))

| VarString _ -> Variant(VarDecimal(boolDecimal(x) - b.ToDecimal()))

| _ -> notSupported()

| VarChar x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarInt32(int32 x - boolI32(y)))

| VarChar y -> Variant(VarInt32(int32 x - int32 y))

| VarInt8 y -> Variant(VarInt32(int32 x - int32 y))

| VarUInt8 y -> Variant(VarInt32(int32 x - int32 y))

| VarInt16 y -> Variant(VarInt32(int32 x - int32 y))

| VarUInt16 y -> Variant(VarInt32(int32 x - int32 y))

| VarInt32 y -> Variant(VarInt32(int32 x - y))

| VarUInt32 y -> Variant(VarUInt32(uint32 x - y))

| VarInt64 y -> Variant(VarInt64(int64 x - y))

| VarUInt64 y -> Variant(VarUInt64(uint64 x - y))

| VarSingle y -> Variant(VarSingle(float32 x - y))

| VarDouble y -> Variant(VarDouble(double x - y))

| VarDecimal y -> Variant(VarDecimal(decimal(int32 x) - y))

| VarString _ -> Variant(VarDecimal(decimal(int32 x) - b.ToDecimal()))

| _ -> notSupported()

| VarInt8 x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarInt32(int32 x - boolI32(y)))

| VarChar y -> Variant(VarInt32(int32 x - int32 y))

| VarInt8 y -> Variant(VarInt32(int32 x - int32 y))

| VarUInt8 y -> Variant(VarInt32(int32 x - int32 y))

| VarInt16 y -> Variant(VarInt32(int32 x - int32 y))

| VarUInt16 y -> Variant(VarInt32(int32 x - int32 y))

| VarInt32 y -> Variant(VarInt32(int32 x - y))

| VarUInt32 y -> Variant(VarUInt32(uint32 x - y))

| VarInt64 y -> Variant(VarInt64(int64 x - y))

| VarUInt64 y -> Variant(VarUInt64(uint64 x - y))

| VarSingle y -> Variant(VarSingle(float32 x - y))

| VarDouble y -> Variant(VarDouble(double x - y))

| VarDecimal y -> Variant(VarDecimal(decimal x - y))

| VarString _ -> Variant(VarDecimal(decimal x - b.ToDecimal()))

| _ -> notSupported()

| VarUInt8 x ->

match b.value with

| VarNull -> a

| VarBool y -> Variant(VarInt32(int32 x - boolI32(y)))

| VarChar y -> Variant(VarInt32(int32 x - int32 y))

| VarInt8 y -> Variant(VarInt32(int32 x - int32 y))

| VarUInt8 y -> Variant(VarInt32(int32 x - int32 y))

| VarInt16 y -> Variant(VarInt32(int32 x - int32 y))

| VarUInt16 y -> Variant(VarInt32(int32 x - int32 y))