diff --git a/contrib/babelfishpg_common/sql/bit.sql b/contrib/babelfishpg_common/sql/bit.sql index 73ee44a25c7..f40aa9e14d3 100644 --- a/contrib/babelfishpg_common/sql/bit.sql +++ b/contrib/babelfishpg_common/sql/bit.sql @@ -504,3 +504,191 @@ WITH FUNCTION sys.varchar2bit(sys.VARCHAR) AS IMPLICIT; CREATE CAST (bool AS sys.BIT) WITHOUT FUNCTION AS IMPLICIT; + + +-- bit smallmoney +CREATE FUNCTION sys.bitsmallmoneypl(sys.BIT, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'bitsmallmoneypl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sys.bitsmallmoneymi(sys.BIT, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'bitsmallmoneymi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sys.bitsmallmoneymul(sys.BIT, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'bitsmallmoneymul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sys.bitsmallmoneydiv(sys.BIT, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'bitsmallmoneydiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR sys.+ ( + LEFTARG = sys.BIT, + RIGHTARG = sys.SMALLMONEY, + COMMUTATOR = +, + PROCEDURE = sys.bitsmallmoneypl +); + +CREATE OPERATOR sys.- ( + LEFTARG = sys.BIT, + RIGHTARG = sys.SMALLMONEY, + PROCEDURE = sys.bitsmallmoneymi +); + +CREATE OPERATOR sys.* ( + LEFTARG = sys.BIT, + RIGHTARG = sys.SMALLMONEY, + PROCEDURE = sys.bitsmallmoneymul +); + +CREATE OPERATOR sys./ ( + LEFTARG = sys.BIT, + RIGHTARG = sys.SMALLMONEY, + PROCEDURE = sys.bitsmallmoneydiv +); + + +-- smallmoney bit +CREATE FUNCTION sys.smallmoneybitpl(sys.SMALLMONEY, sys.BIT) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'smallmoneybitpl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sys.smallmoneybitmi(sys.SMALLMONEY, sys.BIT) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'smallmoneybitmi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sys.smallmoneybitmul(sys.SMALLMONEY, sys.BIT) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'smallmoneybitmul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sys.smallmoneybitdiv(sys.SMALLMONEY, sys.BIT) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'smallmoneybitdiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR sys.+ ( + LEFTARG = sys.SMALLMONEY, + RIGHTARG = sys.BIT, + COMMUTATOR = +, + PROCEDURE = sys.smallmoneybitpl +); + +CREATE OPERATOR sys.- ( + LEFTARG = sys.SMALLMONEY, + RIGHTARG = sys.BIT, + PROCEDURE = sys.smallmoneybitmi +); + +CREATE OPERATOR sys.* ( + LEFTARG = sys.SMALLMONEY, + RIGHTARG = sys.BIT, + PROCEDURE = sys.smallmoneybitmul +); + +CREATE OPERATOR sys./ ( + LEFTARG = sys.SMALLMONEY, + RIGHTARG = sys.BIT, + PROCEDURE = sys.smallmoneybitdiv +); + + +-- float bit +CREATE FUNCTION sys.floatbitpl(float8, sys.BIT) +RETURNS sys.float +AS 'babelfishpg_common', 'floatbitpl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sys.floatbitmi(float8, sys.BIT) +RETURNS sys.float +AS 'babelfishpg_common', 'floatbitmi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sys.floatbitmul(float8, sys.BIT) +RETURNS sys.float +AS 'babelfishpg_common', 'floatbitmul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sys.floatbitdiv(float8, sys.BIT) +RETURNS sys.float +AS 'babelfishpg_common', 'floatbitdiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR sys.+ ( + LEFTARG = float8, + RIGHTARG = sys.BIT, + COMMUTATOR = +, + PROCEDURE = sys.floatbitpl +); + +CREATE OPERATOR sys.- ( + LEFTARG = float8, + RIGHTARG = sys.BIT, + PROCEDURE = sys.floatbitmi +); + +CREATE OPERATOR sys.* ( + LEFTARG = float8, + RIGHTARG = sys.BIT, + PROCEDURE = sys.floatbitmul +); + +CREATE OPERATOR sys./ ( + LEFTARG = float8, + RIGHTARG = sys.BIT, + PROCEDURE = sys.floatbitdiv +); + + +-- bit float +CREATE FUNCTION sys.bitfloatpl(sys.BIT, float8) +RETURNS sys.float +AS 'babelfishpg_common', 'bitfloatpl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sys.bitfloatmi(sys.BIT, float8) +RETURNS sys.float +AS 'babelfishpg_common', 'bitfloatmi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sys.bitfloatmul(sys.BIT, float8) +RETURNS sys.float +AS 'babelfishpg_common', 'bitfloatmul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sys.bitfloatdiv(sys.BIT, float8) +RETURNS sys.float +AS 'babelfishpg_common', 'bitfloatdiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR sys.+ ( + LEFTARG = sys.BIT, + RIGHTARG = float8, + COMMUTATOR = +, + PROCEDURE = sys.bitfloatpl +); + +CREATE OPERATOR sys.- ( + LEFTARG = sys.BIT, + RIGHTARG = float8, + PROCEDURE = sys.bitfloatmi +); + +CREATE OPERATOR sys.* ( + LEFTARG = sys.BIT, + RIGHTARG = float8, + PROCEDURE = sys.bitfloatmul +); + +CREATE OPERATOR sys./ ( + LEFTARG = sys.BIT, + RIGHTARG = float8, + PROCEDURE = sys.bitfloatdiv +); \ No newline at end of file diff --git a/contrib/babelfishpg_common/sql/money/fixeddecimal--1.1.0_base_parallel.sql b/contrib/babelfishpg_common/sql/money/fixeddecimal--1.1.0_base_parallel.sql index 1909bac03df..ec5f7ade244 100755 --- a/contrib/babelfishpg_common/sql/money/fixeddecimal--1.1.0_base_parallel.sql +++ b/contrib/babelfishpg_common/sql/money/fixeddecimal--1.1.0_base_parallel.sql @@ -689,6 +689,10 @@ RETURNS sys.MONEY AS 'babelfishpg_money', 'int8fixeddecimalmul' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- this function is currently not used in any operator +-- hence for now it is okay for it to return a float8 +-- func int8fixeddecimaldiv_money wraps this function +-- and returns money CREATE FUNCTION sys.int8fixeddecimaldiv(INT8, FIXEDDECIMAL) RETURNS DOUBLE PRECISION AS 'babelfishpg_money', 'int8fixeddecimaldiv' @@ -1641,22 +1645,22 @@ LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimalpl(sys.SMALLMONEY, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalpl' +AS 'babelfishpg_money', 'smallmoneypl' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimalmi(sys.SMALLMONEY, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalmi' +AS 'babelfishpg_money', 'smallmoneymi' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimalmul(sys.SMALLMONEY, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalmul' +AS 'babelfishpg_money', 'smallmoneymul' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimaldiv(sys.SMALLMONEY, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimaldiv' +AS 'babelfishpg_money', 'smallmoneydiv' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimalmod(sys.SMALLMONEY, sys.SMALLMONEY) @@ -1703,22 +1707,22 @@ CREATE OPERATOR sys.% ( CREATE FUNCTION sys.fixeddecimalint8pl(sys.SMALLMONEY, INT8) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalint8pl' +AS 'babelfishpg_money', 'smallmoneyint8pl' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimalint8mi(sys.SMALLMONEY, INT8) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalint8mi' +AS 'babelfishpg_money', 'smallmoneyint8mi' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimalint8mul(sys.SMALLMONEY, INT8) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalint8mul' +AS 'babelfishpg_money', 'smallmoneyint8mul' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimalint8div(sys.SMALLMONEY, INT8) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalint8div' +AS 'babelfishpg_money', 'smallmoneyint8div' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OPERATOR sys.+ ( @@ -1749,22 +1753,22 @@ CREATE OPERATOR sys./ ( CREATE FUNCTION sys.fixeddecimalint4pl(sys.SMALLMONEY, INT4) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalint4pl' +AS 'babelfishpg_money', 'smallmoneyint4pl' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimalint4mi(sys.SMALLMONEY, INT4) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalint4mi' +AS 'babelfishpg_money', 'smallmoneyint4mi' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimalint4mul(sys.SMALLMONEY, INT4) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalint4mul' +AS 'babelfishpg_money', 'smallmoneyint4mul' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimalint4div(sys.SMALLMONEY, INT4) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalint4div' +AS 'babelfishpg_money', 'smallmoneyint4div' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OPERATOR sys.+ ( @@ -1795,22 +1799,22 @@ CREATE OPERATOR sys./ ( CREATE FUNCTION sys.fixeddecimalint2pl(sys.SMALLMONEY, INT2) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalint2pl' +AS 'babelfishpg_money', 'smallmoneyint2pl' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimalint2mi(sys.SMALLMONEY, INT2) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalint2mi' +AS 'babelfishpg_money', 'smallmoneyint2mi' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimalint2mul(sys.SMALLMONEY, INT2) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalint2mul' +AS 'babelfishpg_money', 'smallmoneyint2mul' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.fixeddecimalint2div(sys.SMALLMONEY, INT2) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'fixeddecimalint2div' +AS 'babelfishpg_money', 'smallmoneyint2div' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OPERATOR sys.+ ( @@ -1839,22 +1843,25 @@ CREATE OPERATOR sys./ ( PROCEDURE = fixeddecimalint2div ); - CREATE FUNCTION sys.int8fixeddecimalpl(INT8, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'int8fixeddecimalpl' +AS 'babelfishpg_money', 'int8smallmoneypl' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.int8fixeddecimalmi(INT8, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'int8fixeddecimalmi' +AS 'babelfishpg_money', 'int8smallmoneymi' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.int8fixeddecimalmul(INT8, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'int8fixeddecimalmul' +AS 'babelfishpg_money', 'int8smallmoneymul' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- this function is currently not used in any operator +-- hence for now it is okay for it to return a float8 +-- func int8fixeddecimaldiv_smallmoney implements div +-- and is used by the division operator CREATE FUNCTION sys.int8fixeddecimaldiv(INT8, sys.SMALLMONEY) RETURNS DOUBLE PRECISION AS 'babelfishpg_money', 'int8fixeddecimaldiv' @@ -1862,9 +1869,8 @@ LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.int8fixeddecimaldiv_smallmoney(INT8, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS $$ - SELECT sys.int8fixeddecimaldiv($1, $2)::sys.SMALLMONEY; -$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +AS 'babelfishpg_money', 'int8smallmoneydiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OPERATOR sys.+ ( LEFTARG = INT8, @@ -1894,19 +1900,23 @@ CREATE OPERATOR sys./ ( CREATE FUNCTION sys.int4fixeddecimalpl(INT4, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'int4fixeddecimalpl' +AS 'babelfishpg_money', 'int4smallmoneypl' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.int4fixeddecimalmi(INT4, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'int4fixeddecimalmi' +AS 'babelfishpg_money', 'int4smallmoneymi' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.int4fixeddecimalmul(INT4, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'int4fixeddecimalmul' +AS 'babelfishpg_money', 'int4smallmoneymul' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- this function is currently not used in any operator +-- hence for now it is okay for it to return a float8 +-- func int4fixeddecimaldiv_smallmoney implements div +-- and is used by the division operator CREATE FUNCTION sys.int4fixeddecimaldiv(INT4, sys.SMALLMONEY) RETURNS DOUBLE PRECISION AS 'babelfishpg_money', 'int4fixeddecimaldiv' @@ -1914,9 +1924,8 @@ LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.int4fixeddecimaldiv_smallmoney(INT4, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS $$ - SELECT sys.int4fixeddecimaldiv($1, $2)::sys.SMALLMONEY; -$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +AS 'babelfishpg_money', 'int4smallmoneydiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OPERATOR sys.+ ( LEFTARG = INT4, @@ -1946,19 +1955,23 @@ CREATE OPERATOR sys./ ( CREATE FUNCTION sys.int2fixeddecimalpl(INT2, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'int2fixeddecimalpl' +AS 'babelfishpg_money', 'int2smallmoneypl' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.int2fixeddecimalmi(INT2, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'int2fixeddecimalmi' +AS 'babelfishpg_money', 'int2smallmoneymi' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.int2fixeddecimalmul(INT2, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS 'babelfishpg_money', 'int2fixeddecimalmul' +AS 'babelfishpg_money', 'int2smallmoneymul' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- this function is currently not used in any operator +-- hence for now it is okay for it to return a float8 +-- func int2fixeddecimaldiv_smallmoney implements div +-- and is used by the division operator CREATE FUNCTION sys.int2fixeddecimaldiv(INT2, sys.SMALLMONEY) RETURNS DOUBLE PRECISION AS 'babelfishpg_money', 'int2fixeddecimaldiv' @@ -1966,9 +1979,8 @@ LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION sys.int2fixeddecimaldiv_smallmoney(INT2, sys.SMALLMONEY) RETURNS sys.SMALLMONEY -AS $$ - SELECT sys.int2fixeddecimaldiv($1, $2)::sys.SMALLMONEY; -$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +AS 'babelfishpg_money', 'int2smallmoneydiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OPERATOR sys.+ ( LEFTARG = INT2, diff --git a/contrib/babelfishpg_common/sql/upgrades/babelfish_common_helper--4.6.0--4.7.0.sql b/contrib/babelfishpg_common/sql/upgrades/babelfish_common_helper--4.6.0--4.7.0.sql index 9cf90210c86..21e8ebe3249 100644 --- a/contrib/babelfishpg_common/sql/upgrades/babelfish_common_helper--4.6.0--4.7.0.sql +++ b/contrib/babelfishpg_common/sql/upgrades/babelfish_common_helper--4.6.0--4.7.0.sql @@ -132,6 +132,529 @@ BEGIN FUNCTION 1 sys.numeric_int8_cmp(numeric, int8); END IF; END $$; +-- arithmetic functions where one of the +-- operand is smallmoney + +-- smallmoney smallmoney +CREATE OR REPLACE FUNCTION sys.fixeddecimalpl(sys.SMALLMONEY, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneypl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.fixeddecimalmi(sys.SMALLMONEY, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneymi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.fixeddecimalmul(sys.SMALLMONEY, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneymul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.fixeddecimaldiv(sys.SMALLMONEY, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneydiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + + +-- smallmoney int8 +CREATE OR REPLACE FUNCTION sys.fixeddecimalint8pl(sys.SMALLMONEY, INT8) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneyint8pl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.fixeddecimalint8mi(sys.SMALLMONEY, INT8) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneyint8mi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.fixeddecimalint8mul(sys.SMALLMONEY, INT8) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneyint8mul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.fixeddecimalint8div(sys.SMALLMONEY, INT8) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneyint8div' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + + +-- smallmoney int4 +CREATE OR REPLACE FUNCTION sys.fixeddecimalint4pl(sys.SMALLMONEY, INT4) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneyint4pl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.fixeddecimalint4mi(sys.SMALLMONEY, INT4) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneyint4mi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.fixeddecimalint4mul(sys.SMALLMONEY, INT4) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneyint4mul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.fixeddecimalint4div(sys.SMALLMONEY, INT4) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneyint4div' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + + +-- smallmoney int2 +CREATE OR REPLACE FUNCTION sys.fixeddecimalint2pl(sys.SMALLMONEY, INT2) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneyint2pl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.fixeddecimalint2mi(sys.SMALLMONEY, INT2) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneyint2mi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.fixeddecimalint2mul(sys.SMALLMONEY, INT2) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneyint2mul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.fixeddecimalint2div(sys.SMALLMONEY, INT2) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'smallmoneyint2div' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + + +-- int8 smallmoney +CREATE OR REPLACE FUNCTION sys.int8fixeddecimalpl(INT8, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'int8smallmoneypl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.int8fixeddecimalmi(INT8, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'int8smallmoneymi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.int8fixeddecimalmul(INT8, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'int8smallmoneymul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.int8fixeddecimaldiv_smallmoney(INT8, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'int8smallmoneydiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + + +-- int4 smallmoney +CREATE OR REPLACE FUNCTION sys.int4fixeddecimalpl(INT4, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'int4smallmoneypl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.int4fixeddecimalmi(INT4, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'int4smallmoneymi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.int4fixeddecimalmul(INT4, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'int4smallmoneymul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.int4fixeddecimaldiv_smallmoney(INT4, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'int4smallmoneydiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + + +-- int2 smallmoney +CREATE OR REPLACE FUNCTION sys.int2fixeddecimalpl(INT2, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'int2smallmoneypl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.int2fixeddecimalmi(INT2, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'int2smallmoneymi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.int2fixeddecimalmul(INT2, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'int2smallmoneymul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.int2fixeddecimaldiv_smallmoney(INT2, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_money', 'int2smallmoneydiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/** +* Arithmetic operators for bit, smallmoney +*/ + +CREATE OR REPLACE FUNCTION sys.bitsmallmoneymi(sys.BIT, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'bitsmallmoneymi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'sys.bit'::pg_catalog.regtype and oprright = 'sys.smallmoney'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '-' and oprresult != 0) THEN + + CREATE OPERATOR sys.- ( + LEFTARG = sys.BIT, + RIGHTARG = sys.SMALLMONEY, + PROCEDURE = sys.bitsmallmoneymi + ); + + END IF; +END $$; + + + +CREATE OR REPLACE FUNCTION sys.bitsmallmoneypl(sys.BIT, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'bitsmallmoneypl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'sys.bit'::pg_catalog.regtype and oprright = 'sys.smallmoney'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '+' and oprresult != 0) THEN + + CREATE OPERATOR sys.+ ( + LEFTARG = sys.BIT, + RIGHTARG = sys.SMALLMONEY, + COMMUTATOR = +, + PROCEDURE = sys.bitsmallmoneypl + ); + + END IF; +END $$; + + + + +CREATE OR REPLACE FUNCTION sys.bitsmallmoneymul(sys.BIT, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'bitsmallmoneymul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'sys.bit'::pg_catalog.regtype and oprright = 'sys.smallmoney'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '*' and oprresult != 0) THEN + + CREATE OPERATOR sys.* ( + LEFTARG = sys.BIT, + RIGHTARG = sys.SMALLMONEY, + PROCEDURE = sys.bitsmallmoneymul + ); + + END IF; +END $$; + + + + +CREATE OR REPLACE FUNCTION sys.bitsmallmoneydiv(sys.BIT, sys.SMALLMONEY) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'bitsmallmoneydiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'sys.bit'::pg_catalog.regtype and oprright = 'sys.smallmoney'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '/' and oprresult != 0) THEN + + CREATE OPERATOR sys./ ( + LEFTARG = sys.BIT, + RIGHTARG = sys.SMALLMONEY, + PROCEDURE = sys.bitsmallmoneydiv + ); + + END IF; +END $$; + +/** +* Arithmetic operators for smallmoney, bit +*/ + +CREATE OR REPLACE FUNCTION sys.smallmoneybitmi(sys.SMALLMONEY, sys.BIT) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'smallmoneybitmi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'sys.smallmoney'::pg_catalog.regtype and oprright = 'sys.bit'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '-' and oprresult != 0) THEN + + CREATE OPERATOR sys.- ( + LEFTARG = sys.SMALLMONEY, + RIGHTARG = sys.BIT, + PROCEDURE = sys.smallmoneybitmi + ); + + END IF; +END $$; + + + + +CREATE OR REPLACE FUNCTION sys.smallmoneybitpl(sys.SMALLMONEY, sys.BIT) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'smallmoneybitpl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'sys.smallmoney'::pg_catalog.regtype and oprright = 'sys.bit'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '+' and oprresult != 0) THEN + + CREATE OPERATOR sys.+ ( + LEFTARG = sys.SMALLMONEY, + RIGHTARG = sys.BIT, + COMMUTATOR = +, + PROCEDURE = sys.smallmoneybitpl + ); + + END IF; +END $$; + + +CREATE OR REPLACE FUNCTION sys.smallmoneybitmul(sys.SMALLMONEY, sys.BIT) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'smallmoneybitmul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'sys.smallmoney'::pg_catalog.regtype and oprright = 'sys.bit'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '*' and oprresult != 0) THEN + + CREATE OPERATOR sys.* ( + LEFTARG = sys.SMALLMONEY, + RIGHTARG = sys.BIT, + PROCEDURE = sys.smallmoneybitmul + ); + + END IF; +END $$; + + + + +CREATE OR REPLACE FUNCTION sys.smallmoneybitdiv(sys.SMALLMONEY, sys.BIT) +RETURNS sys.SMALLMONEY +AS 'babelfishpg_common', 'smallmoneybitdiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'sys.smallmoney'::pg_catalog.regtype and oprright = 'sys.bit'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '/' and oprresult != 0) THEN + + CREATE OPERATOR sys./ ( + LEFTARG = sys.SMALLMONEY, + RIGHTARG = sys.BIT, + PROCEDURE = sys.smallmoneybitdiv + ); + + END IF; +END $$; + +/** +* Arithmetic operators for float, bit +*/ + +CREATE OR REPLACE FUNCTION sys.floatbitmi(float8, sys.BIT) +RETURNS sys.float +AS 'babelfishpg_common', 'floatbitmi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'float8'::pg_catalog.regtype and oprright = 'sys.bit'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '-' and oprresult != 0) THEN + + CREATE OPERATOR sys.- ( + LEFTARG = float8, + RIGHTARG = sys.BIT, + PROCEDURE = sys.floatbitmi + ); + + END IF; +END $$; + + + + +CREATE OR REPLACE FUNCTION sys.floatbitpl(float8, sys.BIT) +RETURNS sys.float +AS 'babelfishpg_common', 'floatbitpl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'float8'::pg_catalog.regtype and oprright = 'sys.bit'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '+' and oprresult != 0) THEN + + CREATE OPERATOR sys.+ ( + LEFTARG = float8, + RIGHTARG = sys.BIT, + COMMUTATOR = +, + PROCEDURE = sys.floatbitpl + ); + + END IF; +END $$; + + + + +CREATE OR REPLACE FUNCTION sys.floatbitmul(float8, sys.BIT) +RETURNS sys.float +AS 'babelfishpg_common', 'floatbitmul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'float8'::pg_catalog.regtype and oprright = 'sys.bit'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '*' and oprresult != 0) THEN + + CREATE OPERATOR sys.* ( + LEFTARG = float8, + RIGHTARG = sys.BIT, + PROCEDURE = sys.floatbitmul + ); + + END IF; +END $$; + + + +CREATE OR REPLACE FUNCTION sys.floatbitdiv(float8, sys.BIT) +RETURNS sys.float +AS 'babelfishpg_common', 'floatbitdiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'float8'::pg_catalog.regtype and oprright = 'sys.bit'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '/' and oprresult != 0) THEN + + CREATE OPERATOR sys./ ( + LEFTARG = float8, + RIGHTARG = sys.BIT, + PROCEDURE = sys.floatbitdiv + ); + + END IF; +END $$; + +/** +* Arithmetic operators for bit, float +*/ + +CREATE OR REPLACE FUNCTION sys.bitfloatmi(sys.BIT, float8) +RETURNS sys.float +AS 'babelfishpg_common', 'bitfloatmi' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'sys.bit'::pg_catalog.regtype and oprright = 'float8'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '-' and oprresult != 0) THEN + + CREATE OPERATOR sys.- ( + LEFTARG = sys.BIT, + RIGHTARG = float8, + PROCEDURE = sys.bitfloatmi + ); + + END IF; +END $$; + + +CREATE OR REPLACE FUNCTION sys.bitfloatpl(sys.BIT, float8) +RETURNS sys.float +AS 'babelfishpg_common', 'bitfloatpl' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'sys.bit'::pg_catalog.regtype and oprright = 'float8'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '+' and oprresult != 0) THEN + + CREATE OPERATOR sys.+ ( + LEFTARG = sys.BIT, + RIGHTARG = float8, + COMMUTATOR = +, + PROCEDURE = sys.bitfloatpl + ); + + END IF; +END $$; + + + +CREATE OR REPLACE FUNCTION sys.bitfloatmul(sys.BIT, float8) +RETURNS sys.float +AS 'babelfishpg_common', 'bitfloatmul' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'sys.bit'::pg_catalog.regtype and oprright = 'float8'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '*' and oprresult != 0) THEN + + CREATE OPERATOR sys.* ( + LEFTARG = sys.BIT, + RIGHTARG = float8, + PROCEDURE = sys.bitfloatmul + ); + + END IF; +END $$; + + + +CREATE OR REPLACE FUNCTION sys.bitfloatdiv(sys.BIT, float8) +RETURNS sys.float +AS 'babelfishpg_common', 'bitfloatdiv' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +DO $$ +BEGIN + IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_operator + WHERE oprleft = 'sys.bit'::pg_catalog.regtype and oprright = 'float8'::pg_catalog.regtype + and oprnamespace = 'sys'::regnamespace and oprname = '/' and oprresult != 0) THEN + + CREATE OPERATOR sys./ ( + LEFTARG = sys.BIT, + RIGHTARG = float8, + PROCEDURE = sys.bitfloatdiv + ); + + END IF; +END $$; -- Reset search_path to not affect any subsequent scripts SELECT set_config('search_path', trim(leading 'sys, ' from current_setting('search_path')), false); \ No newline at end of file diff --git a/contrib/babelfishpg_common/src/bit.c b/contrib/babelfishpg_common/src/bit.c index a1ded6fed47..b3897031fa9 100644 --- a/contrib/babelfishpg_common/src/bit.c +++ b/contrib/babelfishpg_common/src/bit.c @@ -9,16 +9,19 @@ #include "postgres.h" #include +#include #include "libpq/pqformat.h" #include "utils/builtins.h" #include "utils/numeric.h" #include "utils/varbit.h" #include "varatt.h" +#include "common/int.h" #include "instr.h" #include "typecode.h" #include "numeric.h" +#include "utils/float.h" PG_FUNCTION_INFO_V1(bitin); @@ -62,6 +65,26 @@ PG_FUNCTION_INFO_V1(bitint4le); PG_FUNCTION_INFO_V1(bitint4gt); PG_FUNCTION_INFO_V1(bitint4ge); +/* Arithmetic operations smallmoney, bit */ +PG_FUNCTION_INFO_V1(smallmoneybitpl); +PG_FUNCTION_INFO_V1(smallmoneybitmi); +PG_FUNCTION_INFO_V1(smallmoneybitmul); +PG_FUNCTION_INFO_V1(smallmoneybitdiv); +PG_FUNCTION_INFO_V1(bitsmallmoneypl); +PG_FUNCTION_INFO_V1(bitsmallmoneymi); +PG_FUNCTION_INFO_V1(bitsmallmoneymul); +PG_FUNCTION_INFO_V1(bitsmallmoneydiv); + +/* Arithmetic operations float, bit */ +PG_FUNCTION_INFO_V1(floatbitpl); +PG_FUNCTION_INFO_V1(floatbitmi); +PG_FUNCTION_INFO_V1(floatbitmul); +PG_FUNCTION_INFO_V1(floatbitdiv); +PG_FUNCTION_INFO_V1(bitfloatpl); +PG_FUNCTION_INFO_V1(bitfloatmi); +PG_FUNCTION_INFO_V1(bitfloatmul); +PG_FUNCTION_INFO_V1(bitfloatdiv); + /* * Try to interpret value as boolean value. Valid values are: true, * false, TRUE, FALSE, digital string as well as unique prefixes thereof. @@ -568,3 +591,261 @@ varchar2bit(PG_FUNCTION_ARGS) pfree(str); PG_RETURN_BOOL(result); } + +Datum +smallmoneybitpl(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + bool arg2 = PG_GETARG_BOOL(1); + int32 adder = (int32) arg2 * FIXEDDECIMAL_MULTIPLIER; + int32 result; + + /* + * Overflow check. If the result of addition + * does not fit in 32 bit, then pg_add_s32_overflow + * returns true + */ + if (pg_add_s32_overflow(arg1, adder, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +smallmoneybitmi(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + bool arg2 = PG_GETARG_BOOL(1); + int32 subtractor = (int32) arg2 * FIXEDDECIMAL_MULTIPLIER; + int32 result; + + /* + * Overflow check. If the result of subtraction + * does not fit in 32 bit, then pg_sub_s64_overflow + * returns true + */ + if (pg_sub_s32_overflow(arg1, subtractor, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +smallmoneybitmul(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + bool arg2 = PG_GETARG_BOOL(1); + + if (!arg2) + { + PG_RETURN_INT64(0); + } + PG_RETURN_INT64(arg1); +} + +Datum +smallmoneybitdiv(PG_FUNCTION_ARGS) +{ + int32 arg1 = PG_GETARG_INT32(0); + bool arg2 = PG_GETARG_BOOL(1); + + if (!arg2) + ereport(ERROR, + (errcode(ERRCODE_DIVISION_BY_ZERO), + errmsg("division by zero"))); + + PG_RETURN_INT64(arg1); +} + +Datum +bitsmallmoneypl(PG_FUNCTION_ARGS) +{ + bool arg1 = PG_GETARG_BOOL(0); + int64 arg2 = PG_GETARG_INT64(1); + int32 adder = (int32) arg1 * FIXEDDECIMAL_MULTIPLIER; + int32 result; + + /* + * Overflow check. If the result of addition + * does not fit in 32 bit, then pg_add_s32_overflow + * returns true + */ + if (pg_add_s32_overflow(adder, arg2, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +bitsmallmoneymi(PG_FUNCTION_ARGS) +{ + bool arg1 = PG_GETARG_BOOL(0); + int64 arg2 = PG_GETARG_INT64(1); + int32 subtractor = (int32) arg1 * FIXEDDECIMAL_MULTIPLIER; + int32 result; + + /* + * Overflow check. If the result of subtraction + * does not fit in 32 bit, then pg_sub_s64_overflow + * returns true + */ + if (pg_sub_s32_overflow(subtractor, arg2, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +bitsmallmoneymul(PG_FUNCTION_ARGS) +{ + bool arg1 = PG_GETARG_BOOL(0); + int64 arg2 = PG_GETARG_INT64(1); + + if (!arg1) + { + PG_RETURN_INT64(0); + } + PG_RETURN_INT64(arg2); +} + +Datum +bitsmallmoneydiv(PG_FUNCTION_ARGS) +{ + bool arg1 = PG_GETARG_BOOL(0); + float8 arg2 = (float8) PG_GETARG_INT32(1) / FIXEDDECIMAL_MULTIPLIER; + float8 t; + int64 result; + + if (arg2 == 0) + { + ereport(ERROR, + (errcode(ERRCODE_DIVISION_BY_ZERO), + errmsg("division by zero"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + if (!arg1) + { + PG_RETURN_INT64(0); + } + + t = (float8) 1 / arg2; + t *= FIXEDDECIMAL_MULTIPLIER; + t = rint(t); + + result = (int64) t; + + if (result > INT32_MAX || result < INT32_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +floatbitpl(PG_FUNCTION_ARGS) +{ + float8 arg1 = PG_GETARG_FLOAT8(0); + bool arg2 = PG_GETARG_BOOL(1); + if (!arg2) + { + PG_RETURN_FLOAT8(arg1); + } + PG_RETURN_FLOAT8(float8_pl(arg1, (float8) 1)); +} + +Datum +floatbitmi(PG_FUNCTION_ARGS) +{ + float8 arg1 = PG_GETARG_FLOAT8(0); + bool arg2 = PG_GETARG_BOOL(1); + if (!arg2) + { + PG_RETURN_FLOAT8(arg1); + } + PG_RETURN_FLOAT8(float8_mi(arg1, (float8) 1)); +} + +Datum +floatbitmul(PG_FUNCTION_ARGS) +{ + float8 arg1 = PG_GETARG_FLOAT8(0); + bool arg2 = PG_GETARG_BOOL(1); + if (!arg2) + { + PG_RETURN_FLOAT8((float8) 0); + } + PG_RETURN_FLOAT8(arg1); +} + +Datum +floatbitdiv(PG_FUNCTION_ARGS) +{ + float8 arg1 = PG_GETARG_FLOAT8(0); + bool arg2 = PG_GETARG_BOOL(1); + if (!arg2) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("division by zero"))); + } + PG_RETURN_FLOAT8(arg1); +} + +Datum +bitfloatpl(PG_FUNCTION_ARGS) +{ + bool arg1 = PG_GETARG_BOOL(0); + float8 arg2 = PG_GETARG_FLOAT8(1); + if (!arg1) + { + PG_RETURN_FLOAT8(arg2); + } + PG_RETURN_FLOAT8(float8_pl((float8) 1, arg2)); +} + +Datum +bitfloatmi(PG_FUNCTION_ARGS) +{ + bool arg1 = PG_GETARG_BOOL(0); + float8 arg2 = PG_GETARG_FLOAT8(1); + if (!arg1) + { + PG_RETURN_FLOAT8(-arg2); + } + PG_RETURN_FLOAT8(float8_mi((float8) 1, arg2)); +} + +Datum +bitfloatmul(PG_FUNCTION_ARGS) +{ + bool arg1 = PG_GETARG_BOOL(0); + float8 arg2 = PG_GETARG_FLOAT8(1); + if (!arg1) + { + PG_RETURN_FLOAT8((float8) 0); + } + PG_RETURN_FLOAT8(arg2); +} + +Datum +bitfloatdiv(PG_FUNCTION_ARGS) +{ + bool arg1 = PG_GETARG_BOOL(0); + float8 arg2 = PG_GETARG_FLOAT8(1); + if (!arg1) + { + PG_RETURN_FLOAT8(0); + } + PG_RETURN_FLOAT8(float8_div((float8) 1, arg2)); +} \ No newline at end of file diff --git a/contrib/babelfishpg_money/Makefile b/contrib/babelfishpg_money/Makefile index 673d4cc0f46..cf9b0fb3922 100755 --- a/contrib/babelfishpg_money/Makefile +++ b/contrib/babelfishpg_money/Makefile @@ -1,5 +1,6 @@ MODULE_big = babelfishpg_money OBJS = fixeddecimal.o +OBJS += smallmoney.o EXTENSION = babelfishpg_money diff --git a/contrib/babelfishpg_money/fixeddecimal.c b/contrib/babelfishpg_money/fixeddecimal.c old mode 100755 new mode 100644 index a8492959483..ac84cdea278 --- a/contrib/babelfishpg_money/fixeddecimal.c +++ b/contrib/babelfishpg_money/fixeddecimal.c @@ -27,26 +27,7 @@ #include "utils/array.h" #include "utils/builtins.h" #include "utils/numeric.h" - -/* - * The scale which the number is actually stored. - * For example: 100 will allow 2 decimal places of precision - * This must always be a '1' followed by a number of '0's. - */ -#define FIXEDDECIMAL_MULTIPLIER 10000LL - -/* - * This ensures that we round up the result in case the 5th decimal place >= 5 - * in case of fixeddecimal multiplication. - */ -#define FIXEDDECIMAL_ROUNDUP 5000 - -/* - * Number of decimal places to store. - * This number should be the number of decimal digits that it takes to - * represent FIXEDDECIMAL_MULTIPLIER - 1 - */ -#define FIXEDDECIMAL_SCALE 4 +#include "fixeddecimal.h" /* Sanity checks */ #if FIXEDDECIMAL_SCALE == 0 @@ -57,25 +38,6 @@ #error "FIXEDDECIMAL_SCALE cannot be greater than 19" #endif -/* - * This is bounded by the maximum and minimum values of int64. - * 9223372036854775807 is 19 decimal digits long. - */ -#define FIXEDDECIMAL_MAX_PRECISION 19 - -/* Define this if your compiler has _builtin_add_overflow() */ -/* #define HAVE_BUILTIN_OVERFLOW */ - -#ifndef HAVE_BUILTIN_OVERFLOW -#define SAMESIGN(a,b) (((a) < 0) == ((b) < 0)) -#endif /* HAVE_BUILTIN_OVERFLOW */ - -#define FIXEDDECIMAL_MAX (INT64_MAX/FIXEDDECIMAL_MULTIPLIER) -#define FIXEDDECIMAL_MIN (INT64_MIN/FIXEDDECIMAL_MULTIPLIER) - -/* Compiler must have a working 128 int type */ -typedef __int128 int128; - #ifdef PG_MODULE_MAGIC PG_MODULE_MAGIC; #endif @@ -222,6 +184,10 @@ PG_FUNCTION_INFO_V1(char_to_fixeddecimal); PG_FUNCTION_INFO_V1(int8_to_money); PG_FUNCTION_INFO_V1(int8_to_smallmoney); +PG_FUNCTION_INFO_V1(fixeddecimal_ceiling); +PG_FUNCTION_INFO_V1(fixeddecimal_floor); +PG_FUNCTION_INFO_V1(fixeddecimal_power); + /* Aggregate Internal State */ typedef struct FixedDecimalAggState @@ -1678,24 +1644,15 @@ fixeddecimalpl(PG_FUNCTION_ARGS) int64 arg2 = PG_GETARG_INT64(1); int64 result; -#ifdef HAVE_BUILTIN_OVERFLOW - if (__builtin_add_overflow(arg1, arg2, &result)) - ereport(ERROR, - (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), - errmsg("fixeddecimal out of range"))); -#else - result = arg1 + arg2; - /* - * Overflow check. If the inputs are of different signs then their sum - * cannot overflow. If the inputs are of the same sign, their sum had - * better be that sign too. + * Overflow check. If the result of addition + * does not fit in 64 bit, then pg_add_s64_overflow + * returns true */ - if (SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) + if (pg_add_s64_overflow(arg1, arg2, &result)) ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("fixeddecimal out of range"))); -#endif /* HAVE_BUILTIN_OVERFLOW */ PG_RETURN_INT64(result); } @@ -1707,24 +1664,15 @@ fixeddecimalmi(PG_FUNCTION_ARGS) int64 arg2 = PG_GETARG_INT64(1); int64 result; -#ifdef HAVE_BUILTIN_OVERFLOW - if (__builtin_sub_overflow(arg1, arg2, &result)) - ereport(ERROR, - (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), - errmsg("fixeddecimal out of range"))); -#else - result = arg1 - arg2; - /* - * Overflow check. If the inputs are of the same sign then their - * difference cannot overflow. If they are of different signs then the - * result should be of the same sign as the first input. + * Overflow check. If the result of subtraction + * does not fit in 64 bit, then pg_sub_s64_overflow + * returns true */ - if (!SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) + if (pg_sub_s64_overflow(arg1, arg2, &result)) ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), - errmsg("fixeddecimal out of range"))); -#endif /* HAVE_BUILTIN_OVERFLOW */ + errmsg("fixeddecimal out of range"))); /* HAVE_BUILTIN_OVERFLOW */ PG_RETURN_INT64(result); } @@ -1741,10 +1689,19 @@ fixeddecimalmul(PG_FUNCTION_ARGS) * Remember that arg2 is the number multiplied by FIXEDDECIMAL_MULTIPLIER, * we must divide the result by this to get the correct result. */ - result = (int128) arg1 * arg2 / FIXEDDECIMAL_MULTIPLIER; - /* Round off the result to FIXEDDECIMAL_SCALE. */ - if ((((int128) arg1 * arg2 % FIXEDDECIMAL_MULTIPLIER)) >= FIXEDDECIMAL_ROUNDUP) - result++; + result = ((int128) arg1 * arg2) / FIXEDDECIMAL_MULTIPLIER; + /* + * Round off the result to FIXEDDECIMAL_SCALE. + * abs() in order to deal with -ve result as well + * if the result is negative we subtract 1, else add 1 + */ + if (abs((arg1%FIXEDDECIMAL_MULTIPLIER * arg2%FIXEDDECIMAL_MULTIPLIER) % FIXEDDECIMAL_MULTIPLIER) >= FIXEDDECIMAL_ROUNDUP) + { + if (result < 0) + result--; + else + result++; + } if (result != ((int64) result)) @@ -1863,27 +1820,34 @@ Datum fixeddecimalint8pl(PG_FUNCTION_ARGS) { int64 arg1 = PG_GETARG_INT64(0); - int64 adder = PG_GETARG_INT64(1) * FIXEDDECIMAL_MULTIPLIER; + int64 arg2 = PG_GETARG_INT64(1); + int64 adder; int64 result; -#ifdef HAVE_BUILTIN_OVERFLOW - if (__builtin_add_overflow(arg1, adder, &result)) + /* + * Overflow check. If the result of multiplication + * does not fit in 64 bit, then pg_mul_s64_overflow + * returns true + */ + if (pg_mul_s64_overflow(arg2, (int64) FIXEDDECIMAL_MULTIPLIER, &adder)) + { ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("fixeddecimal out of range"))); -#else - result = arg1 + adder; + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } /* - * Overflow check. If the inputs are of different signs then their sum - * cannot overflow. If the inputs are of the same sign, their sum had - * better be that sign too. + * Overflow check. If the result of addition + * does not fit in 64 bit, then pg_add_s64_overflow + * returns true */ - if (SAMESIGN(arg1, adder) && !SAMESIGN(result, arg1)) + if (pg_add_s64_overflow(arg1, adder, &result)) ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("fixeddecimal out of range"))); -#endif /* HAVE_BUILTIN_OVERFLOW */ + PG_RETURN_INT64(result); } @@ -1892,28 +1856,34 @@ Datum fixeddecimalint8mi(PG_FUNCTION_ARGS) { int64 arg1 = PG_GETARG_INT64(0); - int64 subtractor = PG_GETARG_INT64(1) * FIXEDDECIMAL_MULTIPLIER; + int64 arg2 = PG_GETARG_INT64(1); + int64 subtractor; int64 result; - -#ifdef HAVE_BUILTIN_OVERFLOW - if (__builtin_sub_overflow(arg1, subtractor, &result)) + /* + * Overflow check. If the result of multiplication + * does not fit in 64 bit, then pg_mul_s64_overflow + * returns true + */ + if (pg_mul_s64_overflow(arg2, (int64) FIXEDDECIMAL_MULTIPLIER, &subtractor)) + { ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("fixeddecimal out of range"))); -#else - result = arg1 - subtractor; + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } /* - * Overflow check. If the inputs are of the same sign then their - * difference cannot overflow. If they are of different signs then the - * result should be of the same sign as the first input. + * Overflow check. If the result of subtraction + * does not fit in 64 bit, then pg_sub_s64_overflow + * returns true */ - if (!SAMESIGN(arg1, subtractor) && !SAMESIGN(result, arg1)) + if (pg_sub_s64_overflow(arg1, subtractor, &result)) ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("fixeddecimal out of range"))); -#endif /* HAVE_BUILTIN_OVERFLOW */ + PG_RETURN_INT64(result); } @@ -1923,28 +1893,19 @@ fixeddecimalint8mul(PG_FUNCTION_ARGS) { int64 arg1 = PG_GETARG_INT64(0); int64 arg2 = PG_GETARG_INT64(1); - int128 result; - -#ifdef HAVE_BUILTIN_OVERFLOW - if (__builtin_mul_overflow(arg1, arg2, &result)) - ereport(ERROR, - (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), - errmsg("fixeddecimal out of range"))); -#else - result = (int128) arg1 * arg2; + int64 result; /* - * Overflow check. We should not be testing based only on, if indiviudal arg (agr1) - * is convertible to int32 as the result could still overflow. Hence we directly check - * if result is in int64 range; if so, no overflow is possible. + * Overflow check. If the result of multiplication + * does not fit in 64 bit, then pg_mul_s64_overflow + * returns true */ - if (result != (int128) ((int64) result)) + if (pg_mul_s64_overflow(arg1, arg2, &result)) ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("fixeddecimal out of range"))); -#endif /* HAVE_BUILTIN_OVERFLOW */ - PG_RETURN_INT64((int64) result); + PG_RETURN_INT64(result); } Datum @@ -1979,19 +1940,20 @@ fixeddecimalint8div(PG_FUNCTION_ARGS) (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("fixeddecimal out of range"))); #else - result = -arg1; - /* overflow check (needed for INT64_MIN) */ - if (arg1 != 0 && SAMESIGN(result, arg1)) + if (unlikely(arg1 == INT64_MIN)) + { ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("fixeddecimal out of range"))); + PG_RETURN_NULL(); + } + result = -arg1; + #endif /* HAVE_BUILTIN_OVERFLOW */ - PG_RETURN_INT64(result); } /* No overflow is possible */ - result = arg1 / arg2; PG_RETURN_INT64(result); @@ -2000,28 +1962,34 @@ fixeddecimalint8div(PG_FUNCTION_ARGS) Datum int8fixeddecimalpl(PG_FUNCTION_ARGS) { - int64 adder = PG_GETARG_INT64(0) * FIXEDDECIMAL_MULTIPLIER; + int64 arg1 = PG_GETARG_INT64(0); + int64 adder; int64 arg2 = PG_GETARG_INT64(1); int64 result; -#ifdef HAVE_BUILTIN_OVERFLOW - if (__builtin_add_overflow(adder, arg2, &result)) + /* + * Overflow check. If the result of multiplication + * does not fit in 64 bit, then pg_mul_s64_overflow + * returns true + */ + if (pg_mul_s64_overflow(arg1, (int64) FIXEDDECIMAL_MULTIPLIER, &adder)) + { ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("fixeddecimal out of range"))); -#else - result = adder + arg2; + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } /* - * Overflow check. If the inputs are of different signs then their sum - * cannot overflow. If the inputs are of the same sign, their sum had - * better be that sign too. + * Overflow check. If the result of addition + * does not fit in 64 bit, then pg_add_s64_overflow + * returns true */ - if (SAMESIGN(adder, arg2) && !SAMESIGN(result, adder)) + if (pg_add_s64_overflow(adder, arg2, &result)) ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("fixeddecimal out of range"))); -#endif /* HAVE_BUILTIN_OVERFLOW */ PG_RETURN_INT64(result); } @@ -2029,28 +1997,34 @@ int8fixeddecimalpl(PG_FUNCTION_ARGS) Datum int8fixeddecimalmi(PG_FUNCTION_ARGS) { - int64 subtractor = PG_GETARG_INT64(0) * FIXEDDECIMAL_MULTIPLIER; + int64 arg1 = PG_GETARG_INT64(0); + int64 subtractor; int64 arg2 = PG_GETARG_INT64(1); int64 result; -#ifdef HAVE_BUILTIN_OVERFLOW - if (__builtin_sub_overflow(subtractor, arg2, &result)) + /* + * Overflow check. If the result of multiplication + * does not fit in 64 bit, then pg_mul_s64_overflow + * returns true + */ + if (pg_mul_s64_overflow(arg1, (int64) FIXEDDECIMAL_MULTIPLIER, &subtractor)) + { ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("fixeddecimal out of range"))); -#else - result = subtractor - arg2; - + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + /* - * Overflow check. If the inputs are of the same sign then their - * difference cannot overflow. If they are of different signs then the - * result should be of the same sign as the first input. + * Overflow check. If the result of subtraction + * does not fit in 64 bit, then pg_sub_s64_overflow + * returns true */ - if (!SAMESIGN(subtractor, arg2) && !SAMESIGN(result, subtractor)) + if (pg_sub_s64_overflow(subtractor, arg2, &result)) ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("fixeddecimal out of range"))); -#endif /* HAVE_BUILTIN_OVERFLOW */ PG_RETURN_INT64(result); } @@ -2060,28 +2034,19 @@ int8fixeddecimalmul(PG_FUNCTION_ARGS) { int64 arg1 = PG_GETARG_INT64(0); int64 arg2 = PG_GETARG_INT64(1); - int128 result; - -#ifdef HAVE_BUILTIN_OVERFLOW - if (__builtin_mul_overflow(arg1, arg2, &result)) - ereport(ERROR, - (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), - errmsg("fixeddecimal out of range"))); -#else - result = (int128) arg1 * arg2; + int64 result; /* - * Overflow check. We should not be testing based only on, if indiviudal arg (agr2) - * is convertible to int32 as the result could still overflow. Hence we directly check - * if result is in int64 range; if so, no overflow is possible. + * Overflow check. If the result of multiplication + * does not fit in 64 bit, then pg_mul_s64_overflow + * returns true */ - if (result != (int128) ((int64) result)) + if (pg_mul_s64_overflow(arg1, arg2, &result)) ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("fixeddecimal out of range"))); -#endif /* HAVE_BUILTIN_OVERFLOW */ - PG_RETURN_INT64((int64) result); + PG_RETURN_INT64(result); } Datum @@ -2613,6 +2578,7 @@ int2fixeddecimaldiv(PG_FUNCTION_ARGS) PG_RETURN_FLOAT8((float8) arg1 / arg2); } + /*---------------------------------------------------------- * Conversion operators. *---------------------------------------------------------*/ @@ -3145,3 +3111,77 @@ char_to_fixeddecimal(PG_FUNCTION_ARGS) PG_RETURN_INT64(result); } + +/* + * Mathematic functions + */ +Datum +fixeddecimal_ceiling(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int64 truncvalue = arg1 - (arg1 % FIXEDDECIMAL_MULTIPLIER); + int64 result = truncvalue; + + if (arg1 > 0 && arg1 % FIXEDDECIMAL_MULTIPLIER) + { + /* + * Overflow check. If the result of addition + * does not fit in 64 bit, then pg_add_s64_overflow + * returns true + */ + if (pg_add_s64_overflow(truncvalue, FIXEDDECIMAL_MULTIPLIER, &result)) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("fixeddecimal out of range"))); + PG_RETURN_NULL(); + } + } + + PG_RETURN_INT64(result); +} + +Datum +fixeddecimal_floor(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int64 truncvalue = arg1 - (arg1 % FIXEDDECIMAL_MULTIPLIER); + int64 result = truncvalue; + + if (arg1 < 0 && arg1 % FIXEDDECIMAL_MULTIPLIER) + { + /* + * Overflow check. If the result of subtraction + * does not fit in 64 bit, then pg_sub_s64_overflow + * returns true + */ + if (pg_sub_s64_overflow(truncvalue, FIXEDDECIMAL_MULTIPLIER, &result)) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("fixeddecimal out of range"))); + PG_RETURN_NULL(); + } + } + + PG_RETURN_INT64(result); +} + +Datum +fixeddecimal_power(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + float8 arg1_float = (float8) arg1 / FIXEDDECIMAL_MULTIPLIER; + Numeric arg2 = PG_GETARG_NUMERIC(1); + int64 result; + Numeric arg1_numeric, + result_numeric; + + arg1_numeric = DatumGetNumeric(DirectFunctionCall1(float8_numeric, Float8GetDatum(arg1_float))); + result_numeric = DatumGetNumeric(DirectFunctionCall2(numeric_power, NumericGetDatum(arg1_numeric), NumericGetDatum(arg2))); + result_numeric = DatumGetNumeric(DirectFunctionCall2(numeric_mul, NumericGetDatum(result_numeric), + DirectFunctionCall1(int8_numeric, FIXEDDECIMAL_MULTIPLIER))); + result = DatumGetInt64(DirectFunctionCall1(numeric_int8, NumericGetDatum(result_numeric))); + + PG_RETURN_INT64(result); +} diff --git a/contrib/babelfishpg_money/fixeddecimal.h b/contrib/babelfishpg_money/fixeddecimal.h new file mode 100644 index 00000000000..69669a36d89 --- /dev/null +++ b/contrib/babelfishpg_money/fixeddecimal.h @@ -0,0 +1,38 @@ +/* + * The scale which the number is actually stored. + * For example: 100 will allow 2 decimal places of precision + * This must always be a '1' followed by a number of '0's. + */ +#define FIXEDDECIMAL_MULTIPLIER 10000LL +/* + * Number of decimal places to store. + * This number should be the number of decimal digits that it takes to + * represent FIXEDDECIMAL_MULTIPLIER - 1 + */ +#define FIXEDDECIMAL_SCALE 4 +/* + * This ensures that we round up the result in case the 5th decimal place >= 5 + * in case of fixeddecimal multiplication. + */ +#define FIXEDDECIMAL_ROUNDUP 5000 +/* + * This is bounded by the maximum and minimum values of int64. + * 9223372036854775807 is 19 decimal digits long. + */ +#define FIXEDDECIMAL_MAX_PRECISION 19 + +#define FIXEDDECIMAL_MAX (INT64_MAX/FIXEDDECIMAL_MULTIPLIER) +#define FIXEDDECIMAL_MIN (INT64_MIN/FIXEDDECIMAL_MULTIPLIER) + +#define SMALLMONEY_MAX (INT32_MAX/FIXEDDECIMAL_MULTIPLIER) +#define SMALLMONEY_MIN (INT32_MIN/FIXEDDECIMAL_MULTIPLIER) + +/* Define this if your compiler has _builtin_add_overflow() */ +/* #define HAVE_BUILTIN_OVERFLOW */ + +#ifndef HAVE_BUILTIN_OVERFLOW +#define SAMESIGN(a,b) (((a) < 0) == ((b) < 0)) +#endif /* HAVE_BUILTIN_OVERFLOW */ + +/* Compiler must have a working 128 int type */ +typedef __int128 int128; \ No newline at end of file diff --git a/contrib/babelfishpg_money/smallmoney.c b/contrib/babelfishpg_money/smallmoney.c new file mode 100644 index 00000000000..7f181188f7a --- /dev/null +++ b/contrib/babelfishpg_money/smallmoney.c @@ -0,0 +1,906 @@ +/*------------------------------------------------------------------------- + * + * smallmoney.c + * Fixed Decimal numeric type extension + *------------------------------------------------------------------------- + */ +#include "postgres.h" +#include "varatt.h" + +#include +#include +#include + +#include "funcapi.h" +#include "libpq/pqformat.h" +#include "access/hash.h" +#include "common/int.h" +#include "utils/array.h" +#include "utils/numeric.h" +#include "fixeddecimal.h" + +PG_FUNCTION_INFO_V1(smallmoneyint8pl); +PG_FUNCTION_INFO_V1(smallmoneyint8mi); +PG_FUNCTION_INFO_V1(smallmoneyint8mul); +PG_FUNCTION_INFO_V1(smallmoneyint8div); +PG_FUNCTION_INFO_V1(smallmoneyint4pl); +PG_FUNCTION_INFO_V1(smallmoneyint4mi); +PG_FUNCTION_INFO_V1(smallmoneyint4mul); +PG_FUNCTION_INFO_V1(smallmoneyint4div); +PG_FUNCTION_INFO_V1(smallmoneyint2pl); +PG_FUNCTION_INFO_V1(smallmoneyint2mi); +PG_FUNCTION_INFO_V1(smallmoneyint2mul); +PG_FUNCTION_INFO_V1(smallmoneyint2div); + +PG_FUNCTION_INFO_V1(smallmoneypl); +PG_FUNCTION_INFO_V1(smallmoneymi); +PG_FUNCTION_INFO_V1(smallmoneymul); +PG_FUNCTION_INFO_V1(smallmoneydiv); + +PG_FUNCTION_INFO_V1(int8smallmoneypl); +PG_FUNCTION_INFO_V1(int8smallmoneymi); +PG_FUNCTION_INFO_V1(int8smallmoneymul); +PG_FUNCTION_INFO_V1(int8smallmoneydiv); +PG_FUNCTION_INFO_V1(int4smallmoneypl); +PG_FUNCTION_INFO_V1(int4smallmoneymi); +PG_FUNCTION_INFO_V1(int4smallmoneymul); +PG_FUNCTION_INFO_V1(int4smallmoneydiv); +PG_FUNCTION_INFO_V1(int2smallmoneypl); +PG_FUNCTION_INFO_V1(int2smallmoneymi); +PG_FUNCTION_INFO_V1(int2smallmoneymul); +PG_FUNCTION_INFO_V1(int2smallmoneydiv); + + +/*---------------------------------------------------------- + * Arithmetic operators on smallmoney. + *---------------------------------------------------------*/ + +/* + Even though the range of smallmoney is within INT32_MIN and INT32_MAX, + we have created it as a domain on top of FIXEDDECIMAL which is represented + as a 64 bit INT. Hence, we will also use 64 bit to smallmoney manipulation. + But we can be guaranteed that the smallmoney arg will always fit in 32bits + In other words, INT32_MIN <= arg <= INT32_MAX +*/ + +Datum +smallmoneypl(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int64 arg2 = PG_GETARG_INT64(1); + int32 result; + + /* + * Overflow check. If the result of addition + * does not fit in 32 bit, then pg_add_s32_overflow + * returns true + */ + if (pg_add_s32_overflow(arg1, arg2, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +smallmoneymi(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int64 arg2 = PG_GETARG_INT64(1); + int32 result; + + /* + * Overflow check. If the result of subtraction + * does not fit in 32 bit, then pg_sub_s32_overflow + * returns true + */ + if (pg_sub_s32_overflow(arg1, arg2, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +smallmoneymul(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int64 arg2 = PG_GETARG_INT64(1); + int64 result; + + /* + * We need to promote this to 64bit as we may overflow int32 here. + * Remember that arg2 is the number multiplied by FIXEDDECIMAL_MULTIPLIER, + * we must divide the result by this to get the correct result. + * We are sure not to overflow int64 because even though arg1 and arg2 are of + * int64 type, they are always guaranteed to fit in int32 + */ + result = ((int64) arg1 * arg2) / FIXEDDECIMAL_MULTIPLIER; + + /* Round off the result to FIXEDDECIMAL_SCALE. + * abs() in order to deal with -ve result as well + * if the result is negative we subtract 1, else add 1 + */ + if (abs((arg1%FIXEDDECIMAL_MULTIPLIER * arg2%FIXEDDECIMAL_MULTIPLIER) % FIXEDDECIMAL_MULTIPLIER) >= FIXEDDECIMAL_ROUNDUP) + { + if (result < 0) + result--; + else + result++; + } + + /* + * Overflow check. If the result is outside the + * INT32 range, then we know that the value oveflows + */ + if (result > INT32_MAX || result < INT32_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + PG_RETURN_INT64(result); +} + +Datum +smallmoneydiv(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int64 arg2 = PG_GETARG_INT64(1); + int64 result; + + if (arg2 == 0) + { + ereport(ERROR, + (errcode(ERRCODE_DIVISION_BY_ZERO), + errmsg("division by zero"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + /* + * this can't overflow, but we can end up with a number that's too big for + * int32 + */ + result = (int64) arg1 * FIXEDDECIMAL_MULTIPLIER / arg2; + + /* + * Overflow check. If the result is outside the + * INT32 range, then we know that the value oveflows + */ + if (result > INT32_MAX || result < INT32_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +smallmoneyint8pl(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int64 arg2 = PG_GETARG_INT64(1); + int64 adder; + int128 result; + + /* + * Overflow check. If the result of multiplication + * does not fit in 64 bit, then pg_mul_s64_overflow + * returns true + */ + if (pg_mul_s64_overflow(arg2, (int64) FIXEDDECIMAL_MULTIPLIER, &adder)) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + result = arg1 + adder; + + /* + * Overflow check. If the result is outside the + * INT32 range, then we know that the value oveflows + */ + if (result > INT32_MAX || result < INT32_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + PG_RETURN_INT64(result); +} + +Datum +smallmoneyint8mi(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int64 arg2 = PG_GETARG_INT64(1); + int64 subtractor; + int128 result; + + + /* + * Overflow check. If the result of multiplication + * does not fit in 64 bit, then pg_mul_s64_overflow + * returns true + */ + if (pg_mul_s64_overflow(arg2, (int64) FIXEDDECIMAL_MULTIPLIER, &subtractor)) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + + result = arg1 - subtractor; + + /* + * Overflow check. If the result is outside the + * INT32 range, then we know that the value oveflows + */ + if (result > INT32_MAX || result < INT32_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +smallmoneyint8mul(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int64 arg2 = PG_GETARG_INT64(1); + int128 result; + + result = (int128) arg1 * arg2; + + /* + * Overflow check. If the result is outside the + * INT32 range, then we know that the value oveflows + */ + if (result > INT32_MAX || result < INT32_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +smallmoneyint8div(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int64 arg2 = PG_GETARG_INT64(1); + int64 result; + + if (arg2 == 0) + { + ereport(ERROR, + (errcode(ERRCODE_DIVISION_BY_ZERO), + errmsg("division by zero"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + /* + * INT64_MIN / -1 is problematic, since the result can't be represented on + * a two's-complement machine. Some machines produce INT64_MIN, some + * produce zero, some throw an exception. We can dodge the problem by + * recognizing that division by -1 is the same as negation. + */ + if (arg2 == -1) + { + if (unlikely(arg1 == INT32_MIN)) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + PG_RETURN_NULL(); + } + result = -arg1; + PG_RETURN_INT64(result); + } + + /* No overflow possible */ + result = arg1 / arg2; + + PG_RETURN_INT64(result); +} + +Datum +smallmoneyint4pl(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int32 arg2 = PG_GETARG_INT32(1); + int32 adder; + int32 result; + + /* + * Overflow check. If the result of multiplication + * does not fit in 32 bit, then pg_mul_s32_overflow + * returns true + */ + if (pg_mul_s32_overflow(arg2, (int32) FIXEDDECIMAL_MULTIPLIER, &adder)) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + /* + * Overflow check. If the result of addition + * does not fit in 32 bit, then pg_add_s32_overflow + * returns true + */ + if (pg_add_s32_overflow(arg1, adder, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +smallmoneyint4mi(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int32 arg2 = PG_GETARG_INT32(1); + int32 subtractor; + int32 result; + + /* + * Overflow check. If the result of multiplication + * does not fit in 32 bit, then pg_mul_s32_overflow + * returns true + */ + if (pg_mul_s32_overflow(arg2, (int32) FIXEDDECIMAL_MULTIPLIER, &subtractor)) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + /* + * Overflow check. If the result of subtraction + * does not fit in 32 bit, then pg_sub_s32_overflow + * returns true + */ + if (pg_sub_s32_overflow(arg1, subtractor, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +smallmoneyint4mul(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int32 arg2 = PG_GETARG_INT32(1); + int32 result; + + /* + * Overflow check. If the result of multiplication + * does not fit in 32 bit, then pg_mul_s32_overflow + * returns true + */ + if (pg_mul_s32_overflow(arg1, arg2, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + + PG_RETURN_INT64(result); +} + +Datum +smallmoneyint4div(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int32 arg2 = PG_GETARG_INT32(1); + int64 result; + + if (arg2 == 0) + { + ereport(ERROR, + (errcode(ERRCODE_DIVISION_BY_ZERO), + errmsg("division by zero"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + /* + * INT64_MIN / -1 is problematic, since the result can't be represented on + * a two's-complement machine. Some machines produce INT64_MIN, some + * produce zero, some throw an exception. We can dodge the problem by + * recognizing that division by -1 is the same as negation. + */ + if (arg2 == -1) + { + if (unlikely(arg1 == INT32_MIN)) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + PG_RETURN_NULL(); + } + result = -arg1; + PG_RETURN_INT64(result); + } + + /* No overflow possible */ + result = arg1 / arg2; + + PG_RETURN_INT64(result); +} + +Datum +smallmoneyint2pl(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int32 adder = (int32) PG_GETARG_INT16(1) * (int32) FIXEDDECIMAL_MULTIPLIER; + int32 result; + + + /* + * Overflow check. If the result of addition + * does not fit in 32 bit, then pg_add_s32_overflow + * returns true + */ + if (pg_add_s32_overflow(arg1, adder, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + + PG_RETURN_INT64(result); +} + +Datum +smallmoneyint2mi(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int32 subtractor = (int32) PG_GETARG_INT16(1) * (int32) FIXEDDECIMAL_MULTIPLIER; + int32 result; + + /* + * Overflow check. If the result of subtraction + * does not fit in 32 bit, then pg_sub_s32_overflow + * returns true + */ + if (pg_sub_s32_overflow(arg1, subtractor, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +smallmoneyint2mul(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int16 arg2 = PG_GETARG_INT16(1); + int32 result; + + + /* + * multiplying arg1 and arg2 and storing into result + * pg_mul_s32_overflow does an additional check + * whether the result overflows 32 bits + */ + if (pg_mul_s32_overflow(arg1, (int32) arg2, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + + PG_RETURN_INT64(result); +} + +Datum +smallmoneyint2div(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int16 arg2 = PG_GETARG_INT16(1); + int32 result; + + if (arg2 == 0) + { + ereport(ERROR, + (errcode(ERRCODE_DIVISION_BY_ZERO), + errmsg("division by zero"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + /* + * INT64_MIN / -1 is problematic, since the result can't be represented on + * a two's-complement machine. Some machines produce INT64_MIN, some + * produce zero, some throw an exception. We can dodge the problem by + * recognizing that division by -1 is the same as negation. + */ + if (arg2 == -1) + { + if (unlikely(arg1 == INT32_MIN)) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + PG_RETURN_NULL(); + } + result = -arg1; + PG_RETURN_INT64(result); + } + + /* No overflow is possible */ + result = arg1 / arg2; + + PG_RETURN_INT64(result); +} + +Datum +int2smallmoneypl(PG_FUNCTION_ARGS) +{ + int32 adder = (int32) PG_GETARG_INT16(0) * FIXEDDECIMAL_MULTIPLIER; + int64 arg2 = PG_GETARG_INT64(1); + int32 result; + + + /* + * Overflow check. If the result of addition + * does not fit in 32 bit, then pg_add_s32_overflow + * returns true + */ + if (pg_add_s32_overflow(adder, arg2, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + + PG_RETURN_INT64(result); +} + +Datum +int2smallmoneymi(PG_FUNCTION_ARGS) +{ + int32 subtractor = (int32) PG_GETARG_INT16(0) * FIXEDDECIMAL_MULTIPLIER; + int64 arg2 = PG_GETARG_INT64(1); + int32 result; + + + /* + * Overflow check. If the result of subtraction + * does not fit in 32 bit, then pg_sub_s32_overflow + * returns true + */ + if (pg_sub_s32_overflow(subtractor, arg2, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + + PG_RETURN_INT64(result); +} + +Datum +int2smallmoneymul(PG_FUNCTION_ARGS) +{ + int16 arg1 = PG_GETARG_INT16(0); + int64 arg2 = PG_GETARG_INT64(1); + int32 result; + + /* + * Overflow check. If the result of multiplication + * does not fit in 32 bit, then pg_mul_s32_overflow + * returns true + */ + if (pg_mul_s32_overflow(arg1, arg2, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + + PG_RETURN_INT64(result); +} + +Datum +int2smallmoneydiv(PG_FUNCTION_ARGS) +{ + int16 arg1 = PG_GETARG_INT16(0); + float8 arg2 = (float8) PG_GETARG_INT64(1) / FIXEDDECIMAL_MULTIPLIER; + float8 t; + int64 result; + + if (arg2 == 0) + { + ereport(ERROR, + (errcode(ERRCODE_DIVISION_BY_ZERO), + errmsg("division by zero"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + t = (float8) arg1 / arg2; + t *= FIXEDDECIMAL_MULTIPLIER; + t = rint(t); + + result = (int64) t; + + /* + * Overflow check. If the result is outside the + * INT32 range, then we know that the value oveflows + */ + if (result > INT32_MAX || result < INT32_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +int4smallmoneypl(PG_FUNCTION_ARGS) +{ + int32 arg1 = PG_GETARG_INT32(0); + int32 adder; + int64 arg2 = PG_GETARG_INT64(1); + int32 result; + + + /* + * Overflow check. If the result of multiplication + * does not fit in 32 bit, then pg_mul_s32_overflow + * returns true + */ + if (pg_mul_s32_overflow(arg1, (int32) FIXEDDECIMAL_MULTIPLIER, &adder)) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + /* + * Overflow check. If the result of addition + * does not fit in 32 bit, then pg_add_s32_overflow + * returns true + */ + if (pg_add_s32_overflow(adder, arg2, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +int4smallmoneymi(PG_FUNCTION_ARGS) +{ + int32 arg1 = PG_GETARG_INT32(0); + int32 subtractor; + int64 arg2 = PG_GETARG_INT64(1); + int32 result; + + + /* + * Overflow check. If the result of multiplication + * does not fit in 32 bit, then pg_mul_s32_overflow + * returns true + */ + if (pg_mul_s32_overflow(arg1, (int32) FIXEDDECIMAL_MULTIPLIER, &subtractor)) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + /* + * Overflow check. If the result of subtraction + * does not fit in 32 bit, then pg_sub_s32_overflow + * returns true + */ + if (pg_sub_s32_overflow(subtractor, arg2, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +int4smallmoneymul(PG_FUNCTION_ARGS) +{ + int32 arg1 = PG_GETARG_INT32(0); + int64 arg2 = PG_GETARG_INT64(1); + int32 result; + + /* + * Overflow check. If the result of multiplication + * does not fit in 32 bit, then pg_mul_s32_overflow + * returns true + */ + if (pg_mul_s32_overflow(arg1, arg2, &result)) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + + PG_RETURN_INT64(result); +} + +Datum +int4smallmoneydiv(PG_FUNCTION_ARGS) +{ + int32 arg1 = PG_GETARG_INT32(0); + float8 arg2 = (float8) PG_GETARG_INT64(1) / FIXEDDECIMAL_MULTIPLIER; + float8 t; + int64 result; + + if (arg2 == 0) + { + ereport(ERROR, + (errcode(ERRCODE_DIVISION_BY_ZERO), + errmsg("division by zero"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + t = (float8) arg1 / arg2; + t *= FIXEDDECIMAL_MULTIPLIER; + t = rint(t); + + result = (int64) t; + + /* + * Overflow check. If the result is outside the + * INT32 range, then we know that the value oveflows + */ + if (result > INT32_MAX || result < INT32_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + + +Datum +int8smallmoneypl(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int64 adder; + int64 arg2 = PG_GETARG_INT64(1); + int128 result; + + /* + * Overflow check. If the result of multiplication + * does not fit in 64 bit, then pg_mul_s64_overflow + * returns true + */ + if (pg_mul_s64_overflow(arg1, (int64) FIXEDDECIMAL_MULTIPLIER, &adder)) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + result = adder + arg2; + + /* + * Overflow check. If the result is outside the + * INT32 range, then we know that the value oveflows + */ + if (result > INT32_MAX || result < INT32_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +int8smallmoneymi(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int64 subtractor; + int64 arg2 = PG_GETARG_INT64(1); + int128 result; + + /* + * Overflow check. If the result of multiplication + * does not fit in 64 bit, then pg_mul_s64_overflow + * returns true + */ + if (pg_mul_s64_overflow(arg1, (int64) FIXEDDECIMAL_MULTIPLIER, &subtractor)) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + result = subtractor - arg2; + + /* + * Overflow check. If the result is outside the + * INT32 range, then we know that the value oveflows + */ + if (result > INT32_MAX || result < INT32_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +int8smallmoneymul(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + int64 arg2 = PG_GETARG_INT64(1); + int128 result; + + result = (int128) arg1 * arg2; + + /* + * Overflow check. If the result is outside the + * INT32 range, then we know that the value oveflows + */ + if (result > INT32_MAX || result < INT32_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} + +Datum +int8smallmoneydiv(PG_FUNCTION_ARGS) +{ + int64 arg1 = PG_GETARG_INT64(0); + float8 arg2 = (float8) PG_GETARG_INT64(1) / FIXEDDECIMAL_MULTIPLIER; + float8 t; + int64 result; + + if (arg2 == 0) + { + ereport(ERROR, + (errcode(ERRCODE_DIVISION_BY_ZERO), + errmsg("division by zero"))); + /* ensure compiler realizes we mustn't reach the division (gcc bug) */ + PG_RETURN_NULL(); + } + + t = (float8) arg1 / arg2; + t *= FIXEDDECIMAL_MULTIPLIER; + t = rint(t); + + result = (int64) t; + + /* + * Overflow check. If the result is outside the + * INT32 range, then we know that the value oveflows + */ + if (result > INT32_MAX || result < INT32_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallmoney out of range"))); + + PG_RETURN_INT64(result); +} \ No newline at end of file diff --git a/contrib/babelfishpg_tsql/sql/sys_functions.sql b/contrib/babelfishpg_tsql/sql/sys_functions.sql index b0e3fb36ac7..cb81c327f09 100644 --- a/contrib/babelfishpg_tsql/sql/sys_functions.sql +++ b/contrib/babelfishpg_tsql/sql/sys_functions.sql @@ -2310,6 +2310,9 @@ AS 'babelfishpg_tsql', 'int_floor' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION sys.floor(tinyint) RETURNS TINYINT AS 'babelfishpg_tsql', 'int_floor' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE OR REPLACE FUNCTION sys.floor(sys.fixeddecimal) RETURNS sys.MONEY +AS 'babelfishpg_money', 'fixeddecimal_floor' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + -- Ceiling for bit CREATE OR REPLACE FUNCTION sys.ceiling(sys.bit) RETURNS DOUBLE PRECISION AS 'babelfishpg_tsql', 'bit_ceiling' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; @@ -2327,6 +2330,9 @@ AS 'babelfishpg_tsql', 'int_ceiling' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION sys.ceiling(tinyint) RETURNS TINYINT AS 'babelfishpg_tsql', 'int_ceiling' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE OR REPLACE FUNCTION sys.ceiling(sys.fixeddecimal) RETURNS sys.MONEY +AS 'babelfishpg_money', 'fixeddecimal_ceiling' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + CREATE AGGREGATE sys.STDEV(float8) ( SFUNC = float8_accum, FINALFUNC = float8_stddev_samp, @@ -2471,6 +2477,7 @@ CREATE OR REPLACE FUNCTION sys.sign(IN arg SMALLINT) RETURNS INT AS $BODY$ SELECT sys.sign(arg::INT); $BODY$ +STRICT LANGUAGE SQL IMMUTABLE PARALLEL SAFE; GRANT EXECUTE ON FUNCTION sys.sign(SMALLINT) TO PUBLIC; @@ -2478,6 +2485,7 @@ CREATE OR REPLACE FUNCTION sys.sign(IN arg SYS.TINYINT) RETURNS INT AS $BODY$ SELECT sys.sign(arg::INT); $BODY$ +STRICT LANGUAGE SQL IMMUTABLE PARALLEL SAFE; GRANT EXECUTE ON FUNCTION sys.sign(SYS.TINYINT) TO PUBLIC; @@ -2490,6 +2498,7 @@ SELECT ELSE 0::BIGINT END; $BODY$ +STRICT LANGUAGE SQL IMMUTABLE PARALLEL SAFE; GRANT EXECUTE ON FUNCTION sys.sign(BIGINT) TO PUBLIC; @@ -2502,6 +2511,7 @@ SELECT ELSE 0::SYS.MONEY END; $BODY$ +STRICT LANGUAGE SQL IMMUTABLE PARALLEL SAFE; GRANT EXECUTE ON FUNCTION sys.sign(SYS.MONEY) TO PUBLIC; @@ -2509,6 +2519,7 @@ CREATE OR REPLACE FUNCTION sys.sign(IN arg SYS.SMALLMONEY) RETURNS SYS.MONEY AS $BODY$ SELECT sys.sign(arg::SYS.MONEY); $BODY$ +STRICT LANGUAGE SQL IMMUTABLE PARALLEL SAFE; GRANT EXECUTE ON FUNCTION sys.sign(SYS.SMALLMONEY) TO PUBLIC; @@ -2518,6 +2529,7 @@ $BODY$ SELECT sign(arg::SYS.FLOAT); $BODY$ +STRICT LANGUAGE SQL IMMUTABLE PARALLEL SAFE; GRANT EXECUTE ON FUNCTION sys.sign(ANYELEMENT) TO PUBLIC; @@ -2527,6 +2539,7 @@ $BODY$ SELECT sign(arg::SYS.FLOAT); $BODY$ +STRICT LANGUAGE SQL IMMUTABLE PARALLEL SAFE; GRANT EXECUTE ON FUNCTION sys.sign(TEXT) TO PUBLIC; @@ -4307,6 +4320,10 @@ CREATE OR REPLACE FUNCTION sys.power(IN arg1 TINYINT, IN arg2 NUMERIC) RETURNS int AS 'babelfishpg_tsql','smallint_power' LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; GRANT EXECUTE ON FUNCTION sys.power(TINYINT,NUMERIC) TO PUBLIC; +CREATE OR REPLACE FUNCTION sys.power(IN arg1 sys.FIXEDDECIMAL, IN arg2 NUMERIC) +RETURNS sys.MONEY AS 'babelfishpg_money','fixeddecimal_power' LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; +GRANT EXECUTE ON FUNCTION sys.power(sys.FIXEDDECIMAL,NUMERIC) TO PUBLIC; + CREATE OR REPLACE FUNCTION sys.degrees(IN arg1 NUMERIC) RETURNS numeric AS 'babelfishpg_tsql','numeric_degrees' LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; GRANT EXECUTE ON FUNCTION sys.degrees(NUMERIC) TO PUBLIC; diff --git a/contrib/babelfishpg_tsql/sql/upgrades/babelfishpg_tsql--4.6.0--4.7.0.sql b/contrib/babelfishpg_tsql/sql/upgrades/babelfishpg_tsql--4.6.0--4.7.0.sql index b7129b6ffd5..6a6aa699418 100644 --- a/contrib/babelfishpg_tsql/sql/upgrades/babelfishpg_tsql--4.6.0--4.7.0.sql +++ b/contrib/babelfishpg_tsql/sql/upgrades/babelfishpg_tsql--4.6.0--4.7.0.sql @@ -736,6 +736,86 @@ WHERE sch.nspname = t.typnamespace::regnamespace::name AND t.typtypmod = -1 AND t.typtype = 'd'; +CREATE OR REPLACE FUNCTION sys.power(IN arg1 sys.FIXEDDECIMAL, IN arg2 NUMERIC) +RETURNS sys.MONEY AS 'babelfishpg_money','fixeddecimal_power' LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; +GRANT EXECUTE ON FUNCTION sys.power(sys.FIXEDDECIMAL,NUMERIC) TO PUBLIC; + +CREATE OR REPLACE FUNCTION sys.sign(IN arg SMALLINT) RETURNS INT AS +$BODY$ +SELECT sys.sign(arg::INT); +$BODY$ +STRICT +LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +GRANT EXECUTE ON FUNCTION sys.sign(SMALLINT) TO PUBLIC; + +CREATE OR REPLACE FUNCTION sys.sign(IN arg SYS.TINYINT) RETURNS INT AS +$BODY$ +SELECT sys.sign(arg::INT); +$BODY$ +STRICT +LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +GRANT EXECUTE ON FUNCTION sys.sign(SYS.TINYINT) TO PUBLIC; + +CREATE OR REPLACE FUNCTION sys.sign(IN arg BIGINT) RETURNS BIGINT AS +$BODY$ +SELECT + CASE + WHEN arg > 0::BIGINT THEN 1::BIGINT + WHEN arg < 0::BIGINT THEN -1::BIGINT + ELSE 0::BIGINT + END; +$BODY$ +STRICT +LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +GRANT EXECUTE ON FUNCTION sys.sign(BIGINT) TO PUBLIC; + +CREATE OR REPLACE FUNCTION sys.sign(IN arg SYS.MONEY) RETURNS SYS.MONEY AS +$BODY$ +SELECT + CASE + WHEN arg > 0::SYS.MONEY THEN 1::SYS.MONEY + WHEN arg < 0::SYS.MONEY THEN -1::SYS.MONEY + ELSE 0::SYS.MONEY + END; +$BODY$ +STRICT +LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +GRANT EXECUTE ON FUNCTION sys.sign(SYS.MONEY) TO PUBLIC; + +CREATE OR REPLACE FUNCTION sys.sign(IN arg SYS.SMALLMONEY) RETURNS SYS.MONEY AS +$BODY$ +SELECT sys.sign(arg::SYS.MONEY); +$BODY$ +STRICT +LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +GRANT EXECUTE ON FUNCTION sys.sign(SYS.SMALLMONEY) TO PUBLIC; + +-- To handle remaining input datatypes +CREATE OR REPLACE FUNCTION sys.sign(IN arg ANYELEMENT) RETURNS SYS.FLOAT AS +$BODY$ +SELECT + sign(arg::SYS.FLOAT); +$BODY$ +STRICT +LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +GRANT EXECUTE ON FUNCTION sys.sign(ANYELEMENT) TO PUBLIC; + +-- Duplicate functions with arg TEXT since ANYELEMNT cannot handle type unknown. +CREATE OR REPLACE FUNCTION sys.sign(IN arg TEXT) RETURNS SYS.FLOAT AS +$BODY$ +SELECT + sign(arg::SYS.FLOAT); +$BODY$ +STRICT +LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +GRANT EXECUTE ON FUNCTION sys.sign(TEXT) TO PUBLIC; + +CREATE OR REPLACE FUNCTION sys.floor(sys.fixeddecimal) RETURNS sys.MONEY +AS 'babelfishpg_money', 'fixeddecimal_floor' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION sys.ceiling(sys.fixeddecimal) RETURNS sys.MONEY +AS 'babelfishpg_money', 'fixeddecimal_ceiling' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + CREATE OR REPLACE FUNCTION sys.OBJECT_DEFINITION(IN object_id INT) RETURNS sys.NVARCHAR AS $$ @@ -761,6 +841,7 @@ BEGIN END; $$ LANGUAGE plpgsql STABLE; + create or replace function sys.PATINDEX(in pattern varchar, in expression varchar) returns bigint as $body$ declare diff --git a/test/JDBC/expected/Test-spatial-functions-2-vu-verify.out b/test/JDBC/expected/Test-spatial-functions-2-vu-verify.out index 93a51764115..a4713e5b3fd 100644 --- a/test/JDBC/expected/Test-spatial-functions-2-vu-verify.out +++ b/test/JDBC/expected/Test-spatial-functions-2-vu-verify.out @@ -367,7 +367,7 @@ bit --Use in a Group By Clause DECLARE @referencePoint geometry = geometry::Point(0.0, 0.0, 4326); -DECLARE @intersection_points BIT = 1; +DECLARE @intersection_points INT = 1; SELECT ROUND(PointColumn.STIntersects(@referencePoint) / @intersection_points, 0) * @intersection_points AS Intersectinggroup, COUNT(*) AS PointCount FROM TestGeospatialMethods_YourTableTemp @@ -375,9 +375,9 @@ GROUP BY ROUND(PointColumn.STIntersects(@referencePoint) / @intersection_points, ORDER BY Intersectinggroup; go ~~START~~ -numeric#!#int +int#!#int #!#1 -0E-8#!#2 +0#!#2 ~~END~~ @@ -856,7 +856,7 @@ SET @pnt = geometry::STGeomFromText('POINT(-122.34900 47.65100)', 4326); select geometry::Point(@pnt.STY, @pnt.STX, 4326).STDisjoint(@pnt) --Use in a Group By Clause DECLARE @referencePoint geometry = geometry::Point(0.0, 0.0, 4326); -DECLARE @disjoints BIT = 1; +DECLARE @disjoints INT = 1; SELECT ROUND(PointColumn.STDisjoint(@referencePoint) / @disjoints, 0) * @disjoints AS Grp, COUNT(*) AS PointCount FROM TestGeospatialMethods_YourTableTemp @@ -869,9 +869,9 @@ bit ~~END~~ ~~START~~ -numeric#!#int +int#!#int #!#1 -0E-8#!#2 +0#!#2 ~~END~~ diff --git a/test/JDBC/expected/Test-spatial-functions-vu-verify.out b/test/JDBC/expected/Test-spatial-functions-vu-verify.out index f4a4d388eba..f86dd3dadb8 100644 --- a/test/JDBC/expected/Test-spatial-functions-vu-verify.out +++ b/test/JDBC/expected/Test-spatial-functions-vu-verify.out @@ -394,7 +394,7 @@ bit DECLARE @referencePoint geometry = geometry::Point(0.0, 0.0, 4326); -DECLARE @equal BIT = 1; +DECLARE @equal INT = 1; SELECT ROUND(PointColumn.STEquals(@referencePoint) / @equal, 0) * @equal AS Equalitygroup, COUNT(*) AS PointCount FROM TestSpatialFunction_YourTableTemp @@ -402,9 +402,9 @@ GROUP BY ROUND(PointColumn.STEquals(@referencePoint) / @equal, 0) * @equal ORDER BY Equalitygroup; GO ~~START~~ -numeric#!#int +int#!#int #!#1 -0E-8#!#2 +0#!#2 ~~END~~ @@ -795,7 +795,7 @@ DECLARE @pnt geometry; SET @pnt = geometry::STGeomFromText('POINT(-122.34900 47.65100)', 4326); select geometry::Point(@pnt.STY, @pnt.STX, 4326).STContains(@pnt) DECLARE @referencePoint geometry = geometry::Point(0.0, 0.0, 4326); -DECLARE @contains BIT = 1; +DECLARE @contains INT = 1; SELECT ROUND(PointColumn.STContains(@referencePoint) / @contains, 0) * @contains AS Grp, COUNT(*) AS PointCount FROM TestSpatialFunction_YourTableTemp @@ -808,9 +808,9 @@ bit ~~END~~ ~~START~~ -numeric#!#int +int#!#int #!#1 -0E-8#!#2 +0#!#2 ~~END~~ diff --git a/test/JDBC/expected/TestExactNumeric.out b/test/JDBC/expected/TestExactNumeric.out index f322e84588b..2c21698e652 100644 --- a/test/JDBC/expected/TestExactNumeric.out +++ b/test/JDBC/expected/TestExactNumeric.out @@ -518,27 +518,27 @@ FROM exactnumeric_table; GO ~~START~~ int#!#int#!#int#!#bigint -0#!##!##!#0 -#!#-1#!##!#0 -#!##!#-1#!#0 +0#!##!##!# +#!#-1#!##!# +#!##!#-1#!# #!##!##!#-1 -1#!##!##!#0 -#!#1#!##!#0 -#!##!#1#!#0 +1#!##!##!# +#!#1#!##!# +#!##!#1#!# #!##!##!#1 +#!##!##!# +#!##!##!# +#!##!##!# +#!##!##!# +0#!##!##!# +#!#0#!##!# +#!##!#0#!# #!##!##!#0 +0#!##!##!# +#!#0#!##!# +#!##!#0#!# #!##!##!#0 -#!##!##!#0 -#!##!##!#0 -0#!##!##!#0 -#!#0#!##!#0 -#!##!#0#!#0 -#!##!##!#0 -0#!##!##!#0 -#!#0#!##!#0 -#!##!#0#!#0 -#!##!##!#0 -1#!##!##!#0 +1#!##!##!# 1#!#1#!#1#!#1 ~~END~~ diff --git a/test/JDBC/expected/TestStrings.out b/test/JDBC/expected/TestStrings.out index d425a79c706..c0382288758 100644 --- a/test/JDBC/expected/TestStrings.out +++ b/test/JDBC/expected/TestStrings.out @@ -4261,15 +4261,9 @@ GO SELECT 'Prefix_' + BitCol AS BitConcat FROM ImplicitToStringTest; SELECT N'Prefix_' + BitCol AS BitConcatN FROM ImplicitToStringTest; GO -~~START~~ -varchar -Prefix_1 -~~END~~ +~~ERROR (Code: 33557097)~~ -~~START~~ -nvarchar -Prefix_1 -~~END~~ +~~ERROR (Message: invalid input syntax for type double precision: "Prefix_")~~ -- DECIMAL diff --git a/test/JDBC/expected/babel_varbinary-vu-verify.out b/test/JDBC/expected/babel_varbinary-vu-verify.out index dd90a06833e..120e2d3eb0a 100644 --- a/test/JDBC/expected/babel_varbinary-vu-verify.out +++ b/test/JDBC/expected/babel_varbinary-vu-verify.out @@ -713,7 +713,7 @@ Index Only Scan using babel_varbinary_test_indbabel_v93c04b51675320c0200287b6080 ~~START~~ text -Babelfish T-SQL Batch Parsing Time: 7.781 ms +Babelfish T-SQL Batch Parsing Time: 4.031 ms ~~END~~ @@ -728,7 +728,7 @@ Index Only Scan using babel_varbinary_test_indbabel_v93c04b51675320c0200287b6080 ~~START~~ text -Babelfish T-SQL Batch Parsing Time: 0.217 ms +Babelfish T-SQL Batch Parsing Time: 0.182 ms ~~END~~ @@ -743,7 +743,7 @@ Index Only Scan using babel_varbinary_test_indbabel_v93c04b51675320c0200287b6080 ~~START~~ text -Babelfish T-SQL Batch Parsing Time: 7.684 ms +Babelfish T-SQL Batch Parsing Time: 3.663 ms ~~END~~ @@ -762,7 +762,7 @@ Finalize Aggregate ~~START~~ text -Babelfish T-SQL Batch Parsing Time: 33.697 ms +Babelfish T-SQL Batch Parsing Time: 16.572 ms ~~END~~ @@ -781,7 +781,7 @@ Finalize Aggregate ~~START~~ text -Babelfish T-SQL Batch Parsing Time: 0.216 ms +Babelfish T-SQL Batch Parsing Time: 0.144 ms ~~END~~ @@ -917,8 +917,8 @@ ORDER BY float_binary_add; GO ~~START~~ -float#!#float#!#float#!#float#!#float#!#float#!#float#!#datetime#!#float#!#varchar#!#datetime#!#bigint -201.0#!#201.0#!#1100.5#!#200.5#!#110.5#!#101.5#!#201.0#!#1900-04-11 12:00:00.0#!#201.0#!#100.5A1A2A3A4-B1B2-C1C2-D1D2-E1E2E3E4E5E6#!##!#100 +float#!#float#!#float#!#float#!#float#!#float#!#float#!#float#!#float#!#varchar#!#datetime#!#bigint +201.0#!#201.0#!#1100.5#!#200.5#!#110.5#!#101.5#!#201.0#!#100.5#!#201.0#!#100.5A1A2A3A4-B1B2-C1C2-D1D2-E1E2E3E4E5E6#!##!#100 ~~END~~ @@ -952,8 +952,8 @@ ORDER BY real_binary_add; GO ~~START~~ -real#!#float#!#real#!#real#!#real#!#real#!#real#!#datetime#!#real#!#varchar#!#datetime#!#bigint -201.0#!#201.0#!#1100.5#!#200.5#!#110.5#!#101.5#!#201.0#!#1900-04-11 12:00:00.0#!#201.0#!#100.5A1A2A3A4-B1B2-C1C2-D1D2-E1E2E3E4E5E6#!##!#100 +real#!#float#!#real#!#real#!#real#!#real#!#real#!#float#!#real#!#varchar#!#datetime#!#bigint +201.0#!#201.0#!#1100.5#!#200.5#!#110.5#!#101.5#!#201.0#!#100.5#!#201.0#!#100.5A1A2A3A4-B1B2-C1C2-D1D2-E1E2E3E4E5E6#!##!#100 ~~END~~ @@ -1142,7 +1142,6 @@ SELECT bit_col + smallint_col as bit_smallint_add, bit_col + tinyint_col as bit_tinyint_add, bit_col + money_col as bit_money_add, - bit_col + bit_col as bit_bit_add, bit_col + guid_col as bit_guid_add, bit_col + image_col as bit_image_add, bit_col + binary_col as bit_binary_add @@ -1156,14 +1155,13 @@ ORDER BY bit_smallint_add, bit_tinyint_add, bit_money_add, - bit_bit_add, bit_guid_add, bit_image_add, bit_binary_add; GO ~~START~~ -numeric#!#datetime#!#datetime#!#bigint#!#int#!#smallint#!#smallint#!#money#!#datetime#!#varchar#!#datetime#!#bigint -100.50#!#1900-04-11 12:00:00.0#!#1900-04-11 12:00:00.0#!#1000#!#100#!#10#!#1#!#100.5000#!#1900-01-01 00:00:00.0#!#0A1A2A3A4-B1B2-C1C2-D1D2-E1E2E3E4E5E6#!##!#0 +numeric#!#float#!#float#!#bigint#!#int#!#smallint#!#smallint#!#money#!#varchar#!#datetime#!#bigint +100.50#!#100.5#!#100.5#!#1000#!#100#!#10#!#1#!#100.5000#!#0A1A2A3A4-B1B2-C1C2-D1D2-E1E2E3E4E5E6#!##!#0 ~~END~~ diff --git a/test/JDBC/expected/bit_arith-vu-cleanup.out b/test/JDBC/expected/bit_arith-vu-cleanup.out new file mode 100644 index 00000000000..9371731c05a --- /dev/null +++ b/test/JDBC/expected/bit_arith-vu-cleanup.out @@ -0,0 +1,74 @@ +DROP VIEW bitfloatpl_vu; +GO + +DROP VIEW bitfloatmi_vu; +GO + +DROP VIEW bitfloatmul_vu; +GO + +DROP VIEW bitfloatdiv_vu; +GO + +DROP VIEW floatbitpl_vu; +GO + +DROP VIEW floatbitmi_vu; +GO + +DROP VIEW floatbitmul_vu; +GO + +DROP VIEW floatbitdiv_vu; +GO + +DROP VIEW floatbitdivfail_vu; +GO + +DROP VIEW bitbigintpl_vu; +GO + +DROP VIEW bitbigintmi_vu; +GO + +DROP VIEW bitbigintmul_vu; +GO + +DROP VIEW bitbigintdiv_vu; +GO + +DROP VIEW bitbigintdivfail_vu; +GO + +DROP VIEW bitnumericpl_vu; +GO + +DROP VIEW bitnumericmi_vu; +GO + +DROP VIEW bitnumericmul_vu; +GO + +DROP VIEW bitnumericdiv_vu; +GO + +DROP VIEW bitfloatdivfail_vu; +GO + +DROP VIEW bitsmallmoneymul_vu +GO + +DROP VIEW bitsmallmoneydiv_vu +GO + +DROP VIEW smallmoneybitmul_vu +GO + +DROP VIEW smallmoneybitdiv_vu +GO + +DROP VIEW bitsmallmoneydivfail_vu +GO + +DROP VIEW smallmoneybitdivfail_vu +GO diff --git a/test/JDBC/expected/bit_arith-vu-prepare.out b/test/JDBC/expected/bit_arith-vu-prepare.out new file mode 100644 index 00000000000..ba99e1586d2 --- /dev/null +++ b/test/JDBC/expected/bit_arith-vu-prepare.out @@ -0,0 +1,74 @@ +CREATE VIEW bitfloatpl_vu AS SELECT CAST(1 AS sys.BIT) + CAST(1234.03456 as float) AS result; +GO + +CREATE VIEW bitfloatmi_vu AS SELECT CAST(1 AS sys.BIT) - CAST(1234.03456 as float) AS result; +GO + +CREATE VIEW bitfloatmul_vu AS SELECT CAST(1 AS sys.BIT) * CAST(1234.03456 as float) AS result; +GO + +CREATE VIEW bitfloatdiv_vu AS SELECT CAST(1 AS sys.BIT) / CAST(1234.03456 as float) AS result; +GO + +CREATE VIEW bitfloatdivfail_vu AS SELECT CAST(1 AS sys.BIT) / CAST(0 as float) AS result; +GO + +CREATE VIEW floatbitpl_vu AS SELECT CAST(1234.03456 as float) + CAST(1 AS sys.BIT) AS result; +GO + +CREATE VIEW floatbitmi_vu AS SELECT CAST(1234.03456 as float) - CAST(1 AS sys.BIT) AS result; +GO + +CREATE VIEW floatbitmul_vu AS SELECT CAST(1234.03456 as float) * CAST(1 AS sys.BIT) AS result; +GO + +CREATE VIEW floatbitdiv_vu AS SELECT CAST(1234.03456 as float) / CAST(1 AS sys.BIT) AS result; +GO + +CREATE VIEW floatbitdivfail_vu AS SELECT CAST(1234.03456 as float) / CAST(0 AS sys.BIT) AS result; +GO + +CREATE VIEW bitbigintpl_vu AS SELECT CAST(1 AS sys.BIT) + CAST(1 as BIGINT) AS A, CAST(0 AS sys.BIT) + CAST(1 AS BIGINT) AS B, CAST(1 AS sys.BIT) + CAST(0 as BIGINT) AS C, CAST(0 AS sys.BIT) + CAST(0 as BIGINT) AS D; +GO + +CREATE VIEW bitbigintmi_vu AS SELECT CAST(1 AS sys.BIT) - CAST(1 as BIGINT) AS A, CAST(0 AS sys.BIT) - CAST(1 as BIGINT) AS B, CAST(1 AS sys.BIT) - CAST(0 as BIGINT) AS C, CAST(0 AS sys.BIT) - CAST(0 as BIGINT) AS D; +GO + +CREATE VIEW bitbigintmul_vu AS SELECT CAST(1 AS sys.BIT) * CAST(1 as BIGINT) AS A, CAST(0 AS sys.BIT) * CAST(1 AS BIGINT) AS B, CAST(1 AS sys.BIT) * CAST(0 as BIGINT) AS C, CAST(0 AS sys.BIT) * CAST(0 as BIGINT) AS D; +GO + +CREATE VIEW bitbigintdiv_vu AS SELECT CAST(1 AS sys.BIT) / CAST(1 as BIGINT) AS A, CAST(0 AS sys.BIT) / CAST(1 AS BIGINT) AS B; +GO + +CREATE VIEW bitbigintdivfail_vu AS SELECT CAST(1 AS sys.BIT) / CAST(0 as BIGINT) AS A; +GO + +CREATE VIEW bitnumericpl_vu AS SELECT CAST(1 AS sys.BIT) + CAST(1234.03456 as numeric) AS result; +GO + +CREATE VIEW bitnumericmi_vu AS SELECT CAST(1 AS sys.BIT) - CAST(1234.03456 as numeric) AS result; +GO + +CREATE VIEW bitnumericmul_vu AS SELECT CAST(1 AS sys.BIT) * CAST(1234.03456 as numeric) AS result; +GO + +CREATE VIEW bitnumericdiv_vu AS SELECT CAST(1 AS sys.BIT) / CAST(1234.03456 as numeric) AS result; +GO + +CREATE VIEW bitsmallmoneymul_vu AS SELECT CAST(1 AS sys.BIT) * CAST(1234.0356 as sys.SMALLMONEY) AS A, CAST(0 AS sys.BIT) * CAST(1234.0356 as sys.SMALLMONEY) AS B; +GO + +CREATE VIEW bitsmallmoneydiv_vu AS SELECT CAST(1 AS sys.BIT) / CAST(1234.0346 as sys.SMALLMONEY) AS A, CAST(0 AS sys.BIT) / CAST(1234.0346 as sys.SMALLMONEY) AS B; +GO + +CREATE VIEW smallmoneybitmul_vu AS SELECT CAST(1234.0346 as sys.SMALLMONEY) * CAST(1 as sys.BIT) AS A, CAST(1234.0346 as sys.SMALLMONEY) * CAST(0 as sys.BIT) AS B; +GO + +CREATE VIEW smallmoneybitdiv_vu AS SELECT CAST(1234.0456 as sys.SMALLMONEY) / CAST(1 as sys.BIT) AS result; +GO + +CREATE VIEW bitsmallmoneydivfail_vu AS SELECT CAST(1 AS sys.BIT) / CAST(0 as sys.SMALLMONEY) AS A; +GO + +CREATE VIEW smallmoneybitdivfail_vu AS SELECT CAST(123.456 as sys.SMALLMONEY) / CAST(0 as sys.BIT) AS result; +GO diff --git a/test/JDBC/expected/bit_arith-vu-verify.out b/test/JDBC/expected/bit_arith-vu-verify.out new file mode 100644 index 00000000000..1f21a2474f5 --- /dev/null +++ b/test/JDBC/expected/bit_arith-vu-verify.out @@ -0,0 +1,207 @@ +SELECT * FROM bitfloatpl_vu; +GO +~~START~~ +float +1235.03456 +~~END~~ + + +SELECT * FROM bitfloatmi_vu; +GO +~~START~~ +float +-1233.03456 +~~END~~ + + +SELECT * FROM bitfloatmul_vu; +GO +~~START~~ +float +1234.03456 +~~END~~ + + +SELECT * FROM bitfloatdiv_vu; +GO +~~START~~ +float +8.103500764192536E-4 +~~END~~ + + +SELECT * FROM floatbitpl_vu; +GO +~~START~~ +float +1235.03456 +~~END~~ + + +SELECT * FROM floatbitmul_vu; +GO +~~START~~ +float +1234.03456 +~~END~~ + + +SELECT * FROM floatbitmi_vu; +GO +~~START~~ +float +1233.03456 +~~END~~ + + +SELECT * FROM floatbitdiv_vu; +GO +~~START~~ +float +1234.03456 +~~END~~ + + +SELECT * FROM bitbigintpl_vu; +GO +~~START~~ +bigint#!#bigint#!#bigint#!#bigint +2#!#1#!#1#!#0 +~~END~~ + + +SELECT * FROM bitbigintmi_vu; +GO +~~START~~ +bigint#!#bigint#!#bigint#!#bigint +0#!#-1#!#1#!#0 +~~END~~ + + +SELECT * FROM bitbigintmul_vu; +GO +~~START~~ +bigint#!#bigint#!#bigint#!#bigint +1#!#0#!#0#!#0 +~~END~~ + + +SELECT * FROM bitbigintdiv_vu; +GO +~~START~~ +bigint#!#bigint +1#!#0 +~~END~~ + + +SELECT * FROM bitfloatdivfail_vu; +GO +~~ERROR (Code: 8134)~~ + +~~ERROR (Message: division by zero)~~ + + +SELECT * FROM bitnumericpl_vu; +GO +~~START~~ +numeric +1235 +~~END~~ + + +SELECT * FROM bitnumericmi_vu; +GO +~~START~~ +numeric +-1233 +~~END~~ + + +SELECT * FROM bitnumericmul_vu; +GO +~~START~~ +numeric +1234 +~~END~~ + + +SELECT * FROM bitnumericdiv_vu; +GO +~~START~~ +numeric +0.0008103727714748784 +~~END~~ + + +SELECT * FROM bitbigintdivfail_vu; +GO +~~ERROR (Code: 8134)~~ + +~~ERROR (Message: division by zero)~~ + + +SELECT * FROM floatbitdivfail_vu; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: division by zero)~~ + + +SELECT * FROM bitsmallmoneydiv_vu; +GO +~~START~~ +smallmoney#!#smallmoney +0.0008#!#0.0000 +~~END~~ + + +SELECT * FROM bitsmallmoneymul_vu; +GO +~~START~~ +smallmoney#!#smallmoney +1234.0356#!#0.0000 +~~END~~ + + +SELECT * FROM smallmoneybitdivfail_vu; +GO +~~START~~ +smallmoney +~~ERROR (Code: 8134)~~ + +~~ERROR (Message: division by zero)~~ + + +SELECT * FROM smallmoneybitdiv_vu; +GO +~~START~~ +smallmoney +1234.0456 +~~END~~ + + +SELECT * FROM smallmoneybitmul_vu; +GO +~~START~~ +smallmoney#!#smallmoney +1234.0346#!#0.0000 +~~END~~ + + +SELECT * FROM bitsmallmoneydivfail_vu; +GO +~~START~~ +smallmoney +~~ERROR (Code: 8134)~~ + +~~ERROR (Message: division by zero)~~ + + +-- bit arithmetic is not supported +-- this fails +SELECT CAST(1 AS sys.BIT) + CAST(1 as sys.BIT) AS A, CAST(0 AS sys.BIT) / CAST(1 AS sys.BIT) AS B, CAST(1 AS sys.BIT) * CAST(0 as sys.BIT) AS C, CAST(0 AS sys.BIT) - CAST(0 as sys.BIT) AS D; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: operator is not unique: "bit" + "bit")~~ + diff --git a/test/JDBC/expected/money_smallmoney-vu-cleanup.out b/test/JDBC/expected/money_smallmoney-vu-cleanup.out new file mode 100644 index 00000000000..0010f7f876e --- /dev/null +++ b/test/JDBC/expected/money_smallmoney-vu-cleanup.out @@ -0,0 +1,80 @@ +DROP VIEW int2smallmoneyadd_vu; +GO + +DROP VIEW int4smallmoneyadd_vu; +GO + +DROP VIEW int8smallmoneyadd_vu; +GO + +DROP VIEW smallmoneyint2add_vu; +GO + +DROP VIEW smallmoneyint4add_vu; +GO + +DROP VIEW smallmoneyint8add_vu; +GO + +DROP VIEW int2smallmoneymul_vu; +GO + +DROP VIEW int4smallmoneymul_vu; +GO + +DROP FUNCTION int2smallmoney_func() +GO + +DROP FUNCTION int8smallmoney_func() +GO + +DROP FUNCTION bitsmallmoney_func() +GO + +DROP FUNCTION bitmoney_func() +GO + +DROP FUNCTION int4smallmoney_func() +GO + +DROP FUNCTION smallintsmallmoney_func() +GO + +DROP FUNCTION principalsquared_func(sys.MONEY) +GO + +DROP TABLE money_smallmoney_vu_test; +GO + +DROP TABLE MoneyTestTable1 +GO + +DROP VIEW bitsmallmoneypl_vu; +GO + +DROP VIEW bitsmallmoneymi_vu; +GO + +DROP VIEW smallmoneybitpl_vu; +GO + +DROP VIEW smallmoneybitmi_vu; +GO + +DROP VIEW floormaxmoney_vu; +GO + +DROP VIEW ceilingminmoney_vu; +GO + +DROP VIEW powersmallmoneyfail_vu; +GO + +DROP VIEW powermoneyfail_vu; +GO + +DROP VIEW powermoney_vu; +GO + +DROP VIEW powersmallmoney_vu; +GO diff --git a/test/JDBC/expected/money_smallmoney-vu-prepare.out b/test/JDBC/expected/money_smallmoney-vu-prepare.out new file mode 100644 index 00000000000..343a3db5fd6 --- /dev/null +++ b/test/JDBC/expected/money_smallmoney-vu-prepare.out @@ -0,0 +1,200 @@ +-- tsql +CREATE VIEW int2smallmoneyadd_vu AS SELECT cast(100 AS TINYINT) + cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW int4smallmoneyadd_vu AS SELECT cast(100 AS INT) + cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW int8smallmoneyadd_vu AS SELECT cast(100 AS BIGINT) + cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW smallmoneyint2add_vu AS SELECT cast(123.45 AS SMALLMONEY) + cast(100 AS TINYINT) AS result; +GO + +CREATE VIEW smallmoneyint4add_vu AS SELECT cast(123.45 AS SMALLMONEY) + cast(100 as INT) AS result; +GO + +CREATE VIEW smallmoneyint8add_vu AS SELECT cast(123.45 AS SMALLMONEY) + cast(100 as BIGINT) AS result; +GO + +CREATE VIEW int2smallmoneymul_vu AS SELECT cast(100 AS TINYINT) * cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW int4smallmoneymul_vu AS SELECT cast(100 AS INT) * cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW bitsmallmoneypl_vu AS SELECT cast(100 AS BIT) + cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW bitsmallmoneymi_vu AS SELECT cast(100 AS BIT) - cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW smallmoneybitpl_vu AS SELECT cast(123.45 AS SMALLMONEY) + cast(100 AS BIT) AS result; +GO + +CREATE VIEW smallmoneybitmi_vu AS SELECT cast(123.45 AS SMALLMONEY) - cast(100 AS BIT) AS result; +GO + +CREATE VIEW floormaxmoney_vu AS SELECT floor(cast(922337203685477.5807 as MONEY)) AS result; +GO + +CREATE VIEW ceilingminmoney_vu AS SELECT ceiling(cast(-922337203685477.5807 as MONEY)) AS result; +GO + +CREATE VIEW powermoney_vu AS SELECT POWER(cast(-100.5807 as MONEY), 2) AS result; +GO + +CREATE VIEW powermoneyfail_vu AS SELECT POWER(cast(-92233720368.5807 as MONEY), 2) AS result; +GO + +CREATE VIEW powersmallmoney_vu AS SELECT POWER(cast(-100.5807 as SMALLMONEY), 2) AS result; +GO + +CREATE VIEW powersmallmoneyfail_vu AS SELECT POWER(cast(-92233720368.5807 as SMALLMONEY), 2) AS result; +GO + +CREATE FUNCTION principalsquared_func(@amount sys.MONEY) +RETURNS sys.MONEY +AS +BEGIN + RETURN (SELECT POWER(@amount, 2)); +END; +GO + +CREATE FUNCTION int2smallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS TINYINT) * cast(123.45 AS SMALLMONEY) + , cast(100 AS TINYINT) / cast(123.45 AS SMALLMONEY) + , cast(100 AS TINYINT) + cast(123.45 AS SMALLMONEY) + , cast(100 AS TINYINT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS TINYINT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS TINYINT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS TINYINT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS TINYINT); + RETURN 0; +END; +GO + +CREATE FUNCTION smallintsmallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS SMALLINT) * cast(123.45 AS SMALLMONEY) + , cast(100 AS SMALLINT) / cast(123.45 AS SMALLMONEY) + , cast(100 AS SMALLINT) + cast(123.45 AS SMALLMONEY) + , cast(100 AS SMALLINT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS SMALLINT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS SMALLINT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS SMALLINT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS SMALLINT); + RETURN 0; +END; +GO + + +CREATE FUNCTION int8smallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS BIGINT) * cast(123.45 AS SMALLMONEY) + , cast(100 AS BIGINT) / cast(123.45 AS SMALLMONEY) + , cast(100 AS BIGINT) + cast(123.45 AS SMALLMONEY) + , cast(100 AS BIGINT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS BIGINT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS BIGINT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS BIGINT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS BIGINT); + RETURN 0; +END; +GO + +CREATE FUNCTION bitsmallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS BIT) * cast(123.45 AS SMALLMONEY) + , cast(100 AS BIT) / cast(123.45 AS SMALLMONEY) + , cast(100 AS BIT) + cast(123.45 AS SMALLMONEY) + , cast(100 AS BIT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS BIT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS BIT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS BIT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS BIT); + RETURN 0; +END; +GO + +CREATE FUNCTION bitmoney_func() +RETURNS @test TABLE(a money, b money, c money, d money, e money, f money, g money, h money) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS BIT) * cast(123.45 AS MONEY) + , cast(100 AS BIT) / cast(123.45 AS MONEY) + , cast(100 AS BIT) + cast(123.45 AS MONEY) + , cast(100 AS BIT) - cast(123.45 AS MONEY) + , cast(123.45 AS MONEY) * cast(100 AS BIT) + , cast(123.45 AS MONEY) / cast(100 AS BIT) + , cast(123.45 AS MONEY) + cast(100 AS BIT) + , cast(123.45 AS MONEY) - cast(100 AS BIT); + RETURN 0; +END; +GO + +CREATE FUNCTION int4smallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(1000 AS INT) * cast(123.45 AS SMALLMONEY) + , cast(10000 AS INT) / cast(123.45 AS SMALLMONEY) + , cast(10000 AS INT) + cast(123.45 AS SMALLMONEY) + , cast(10000 AS INT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS INT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS INT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS INT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS INT); + RETURN; +END; +GO + +CREATE TABLE money_smallmoney_vu_test(id SERIAL, cost_sm SMALLMONEY, cost_m sys.MONEY); +GO + +CREATE INDEX idx_cost_smallmoney on money_smallmoney_vu_test(cost_sm); +GO + +CREATE INDEX idx_cost_money on money_smallmoney_vu_test(cost_m); +GO + +INSERT INTO money_smallmoney_vu_test(cost_sm, cost_m) VALUES +(100,2000), (200,40), (400,20), (300, 500), (100, 1000), +(10,100), (10,40000), (125,20), (50, 590), (300, 900), +(100,100), (10,40000), (125,20), (50, 590), (300, 900); +GO +~~ROW COUNT: 15~~ + + +-- tsql + +-- Create test tables +CREATE TABLE MoneyTestTable1 ( + ID INT IDENTITY(1,1), + MoneyVal MONEY, + SmallMoneyVal SMALLMONEY, + Description VARCHAR(100) +); +-- Test default values +INSERT INTO MoneyTestTable1 DEFAULT VALUES; +GO +~~ROW COUNT: 1~~ + + + + diff --git a/test/JDBC/expected/money_smallmoney-vu-verify.out b/test/JDBC/expected/money_smallmoney-vu-verify.out new file mode 100644 index 00000000000..441896319ea --- /dev/null +++ b/test/JDBC/expected/money_smallmoney-vu-verify.out @@ -0,0 +1,8070 @@ +-- psql +-- analyze the money_smallmoney_vu_test created +ANALYZE master_dbo.money_smallmoney_vu_test; +GO + +-- tsql +-- Display results +SELECT 'Range Test Results' AS TestName, * FROM MoneyTestTable1 where Description NOT LIKE 'Random values'; +GO +~~START~~ +varchar#!#int#!#money#!#smallmoney#!#varchar +~~END~~ + + +-- tsql +-- ============================================= +-- 1.Select from dependent objects +-- ============================================= +SELECT * FROM dbo.int2smallmoneyadd_vu; +GO +~~START~~ +smallmoney +223.4500 +~~END~~ + + +SELECT * FROM dbo.int4smallmoneyadd_vu; +GO +~~START~~ +smallmoney +223.4500 +~~END~~ + + +SELECT * FROM dbo.int8smallmoneyadd_vu; +GO +~~START~~ +smallmoney +223.4500 +~~END~~ + + +SELECT * FROM dbo.smallmoneyint2add_vu; +GO +~~START~~ +smallmoney +223.4500 +~~END~~ + + +SELECT * FROM dbo.smallmoneyint4add_vu; +GO +~~START~~ +smallmoney +223.4500 +~~END~~ + + +SELECT * FROM dbo.smallmoneyint8add_vu; +GO +~~START~~ +smallmoney +223.4500 +~~END~~ + + +SELECT * FROM dbo.int2smallmoneymul_vu; +GO +~~START~~ +smallmoney +12345.0000 +~~END~~ + + +SELECT * FROM dbo.int4smallmoneymul_vu; +GO +~~START~~ +smallmoney +12345.0000 +~~END~~ + + +SELECT * FROM dbo.bitsmallmoneypl_vu; +GO +~~START~~ +smallmoney +124.4500 +~~END~~ + + +SELECT * FROM dbo.bitsmallmoneymi_vu; +GO +~~START~~ +smallmoney +-122.4500 +~~END~~ + + +SELECT * FROM dbo.smallmoneybitpl_vu; +GO +~~START~~ +smallmoney +124.4500 +~~END~~ + + +SELECT * FROM dbo.smallmoneybitmi_vu; +GO +~~START~~ +smallmoney +122.4500 +~~END~~ + + +SELECT * FROM dbo.floormaxmoney_vu; +GO +~~START~~ +money +922337203685477.0000 +~~END~~ + + +SELECT * FROM dbo.ceilingminmoney_vu; +GO +~~START~~ +money +-922337203685477.0000 +~~END~~ + + +SELECT * FROM dbo.powersmallmoney_vu; +GO +~~START~~ +money +10116.4772 +~~END~~ + + +SELECT * FROM dbo.powermoney_vu; +GO +~~START~~ +money +10116.4772 +~~END~~ + + +SELECT * FROM dbo.powersmallmoneyfail_vu; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: FIXEDDECIMAL field overflow)~~ + + +SELECT * FROM dbo.powermoneyfail_vu; +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT * FROM dbo.int4smallmoney_func(); +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +123450.0000#!#81.0045#!#10123.4500#!#9876.5500#!#12345.0000#!#1.2345#!#223.4500#!#23.4500 +~~END~~ + + +SELECT * FROM dbo.bitsmallmoney_func(); +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +123.4500#!#0.0081#!#124.4500#!#-122.4500#!#123.4500#!#123.4500#!#124.4500#!#122.4500 +~~END~~ + + +SELECT * FROM dbo.int8smallmoney_func(); +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +12345.0000#!#0.8100#!#223.4500#!#-23.4500#!#12345.0000#!#1.2345#!#223.4500#!#23.4500 +~~END~~ + + +SELECT * FROM dbo.int2smallmoney_func(); +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +12345.0000#!#0.8100#!#223.4500#!#-23.4500#!#12345.0000#!#1.2345#!#223.4500#!#23.4500 +~~END~~ + + +SELECT * FROM dbo.smallintsmallmoney_func(); +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +12345.0000#!#0.8100#!#223.4500#!#-23.4500#!#12345.0000#!#1.2345#!#223.4500#!#23.4500 +~~END~~ + + +SELECT principalsquared_func(cast(1000.450 as money)); +GO +~~START~~ +money +1000900.2025 +~~END~~ + + +-- =============================================================== +-- 2.Check if index is picked up for all arithmetic operations +-- =============================================================== +SELECT set_config('enable_seqscan', 'off', false); +GO +~~START~~ +text +off +~~END~~ + + +SELECT set_config('babelfishpg_tsql.explain_costs', 'off', false) +GO +~~START~~ +text +off +~~END~~ + + +SET babelfish_showplan_all ON; +GO + +SELECT * FROM money_smallmoney_vu_test WHERE cost_sm BETWEEN 100 and 200; +GO +~~START~~ +text +Query Text: SELECT * FROM money_smallmoney_vu_test WHERE cost_sm BETWEEN 100 and 200 +Index Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: (((cost_sm)::fixeddecimal >= 100) AND ((cost_sm)::fixeddecimal <= 200)) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 6.340 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm > 100; +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm > 100 +Aggregate + -> Index Only Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: (cost_sm > 100) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 19.752 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm <= CAST(50 AS SMALLMONEY) + CAST(50 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm <= CAST(50 AS SMALLMONEY) + CAST(50 AS SMALLMONEY) +Aggregate + -> Index Only Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: (cost_sm <= ((('50.0000'::fixeddecimal(10,4))::smallmoney(655368) + ('50.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 3.664 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm = CAST(2 AS INT) * CAST(50 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm = CAST(2 AS INT) * CAST(50 AS SMALLMONEY) +Aggregate + -> Index Only Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: (cost_sm = ((2 * ('50.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.682 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm > CAST(200 AS INT) / CAST(2 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm > CAST(200 AS INT) / CAST(2 AS SMALLMONEY) +Aggregate + -> Index Only Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: (cost_sm > ((200 / ('2.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 2.655 ms +~~END~~ + + +SELECT cost_sm FROM money_smallmoney_vu_test WHERE cost_sm <= CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT cost_sm FROM money_smallmoney_vu_test WHERE cost_sm <= CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY) +Index Only Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: (cost_sm <= (('200'::bigint * ('2.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.241 ms +~~END~~ + + +SELECT * FROM money_smallmoney_vu_test WHERE cost_sm < CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT * FROM money_smallmoney_vu_test WHERE cost_sm < CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY) +Index Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: ((cost_sm)::fixeddecimal < (('200'::bigint * ('2.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 2.618 ms +~~END~~ + + +SELECT * FROM money_smallmoney_vu_test WHERE cost_m BETWEEN 100 and 200; +GO +~~START~~ +text +Query Text: SELECT * FROM money_smallmoney_vu_test WHERE cost_m BETWEEN 100 and 200 +Index Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: (((cost_m)::fixeddecimal >= 100) AND ((cost_m)::fixeddecimal <= 200)) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.090 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m > 100; +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m > 100 +Aggregate + -> Index Only Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: (cost_m > 100) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.096 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m >= CAST(50 AS SMALLMONEY) + CAST(50 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m >= CAST(50 AS SMALLMONEY) + CAST(50 AS SMALLMONEY) +Aggregate + -> Index Only Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: (cost_m >= ((('50.0000'::fixeddecimal(10,4))::smallmoney(655368) + ('50.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.587 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m = CAST(2 AS INT) * CAST(50 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m = CAST(2 AS INT) * CAST(50 AS SMALLMONEY) +Aggregate + -> Index Only Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: (cost_m = ((2 * ('50.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.138 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m < CAST(200 AS INT) / CAST(2 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m < CAST(200 AS INT) / CAST(2 AS SMALLMONEY) +Aggregate + -> Index Only Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: (cost_m < ((200 / ('2.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.134 ms +~~END~~ + + +SELECT cost_m FROM money_smallmoney_vu_test WHERE cost_m < CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT cost_m FROM money_smallmoney_vu_test WHERE cost_m < CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY) +Index Only Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: (cost_m < (('200'::bigint * ('2.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.131 ms +~~END~~ + + +SELECT * FROM money_smallmoney_vu_test WHERE cost_m > CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT * FROM money_smallmoney_vu_test WHERE cost_m > CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY) +Index Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: ((cost_m)::fixeddecimal > (('200'::bigint * ('2.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.125 ms +~~END~~ + + +SET babelfish_showplan_all OFF; +GO + +SELECT set_config('enable_seqscan', 'on', false); +GO +~~START~~ +text +on +~~END~~ + +-- ============================================= +-- 3.Overflow Tests +-- ============================================= +INSERT INTO MoneyTestTable1 (MoneyVal, Description) VALUES (922337203685477.5808, 'Overflow MONEY test'); -- Exceeds maximum +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value "922337203685477.5808" is out of range for type fixeddecimal)~~ + + +INSERT INTO MoneyTestTable1 (SmallMoneyVal, Description) VALUES (214748.3648, 'Overflow SMALLMONEY test'); -- Exceeds maximum +GO +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + +INSERT INTO MoneyTestTable1 (MoneyVal, Description) VALUES (-922337203685477.5809, 'Underflow MONEY test'); -- Below minimum +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value "-922337203685477.5809" is out of range for type fixeddecimal)~~ + + +INSERT INTO MoneyTestTable1 (SmallMoneyVal, Description) VALUES (-214748.3649, 'Underflow SMALLMONEY test'); -- Below minimum +GO +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + +-- Try Overflow with Arithematic Operators +-- ============================================= +-- Result Overflows +-- ============================================= +-- + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS SMALLMONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS TINYINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS SMALLINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS INT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS BIT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS MONEY) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS SMALLMONEY) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS TINYINT) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS SMALLINT) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS INT) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS BIGINT) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS BIT) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS REAL); +GO +~~START~~ +real +9.2233718E14 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS FLOAT); +GO +~~START~~ +float +9.223372036854786E14 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS MONEY); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS SMALLMONEY); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS TINYINT); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS SMALLINT); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS INT); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS BIGINT); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS BIT); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS MONEY) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS SMALLMONEY) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS TINYINT) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS SMALLINT) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS INT) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS BIGINT) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS BIT) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- - +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS SMALLMONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS TINYINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS SMALLINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS INT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS BIT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS BIGINT) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS MONEY) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS SMALLMONEY) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS TINYINT) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS SMALLINT) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS INT) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS BIGINT) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS BIT) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS REAL); +GO +~~START~~ +real +-9.2233718E14 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS FLOAT); +GO +~~START~~ +float +-9.223372036854786E14 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS SMALLMONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS TINYINT); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS SMALLINT); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS INT); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS BIT); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(0 AS BIT); +GO +~~START~~ +money +-922337203685477.5808 +~~END~~ + +SELECT CAST(1 AS BIGINT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS MONEY) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS SMALLMONEY) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS TINYINT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS SMALLINT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS INT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS BIGINT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS BIT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(0 AS BIT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685477.5808 +~~END~~ + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1.1 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1.1 AS SMALLMONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(2 AS TINYINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(2 AS SMALLINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(2 AS INT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(2 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1 AS BIT); +GO +~~START~~ +money +922337203685477.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(0 AS BIT); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1.1 AS MONEY) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1.1 AS SMALLMONEY) * CAST(922337203685477.5807 AS MONEY);; +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(2 AS TINYINT) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(2 AS SMALLINT) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(2 AS INT) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(2 AS BIGINT) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(0 AS BIT) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(1 AS BIT) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +922337203685477.5807 +~~END~~ + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1.1 AS REAL); +GO +~~START~~ +real +1.01457093E15 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1.1 AS FLOAT); +GO +~~START~~ +float +1.0145709240540255E15 +~~END~~ + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- - +SELECT CAST(-922337203685477.5808 AS MONEY) / CAST(0.9 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) / CAST(0.9 AS SMALLMONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS TINYINT); +GO +~~START~~ +money +461168601842738.7903 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS SMALLINT); +GO +~~START~~ +money +461168601842738.7903 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS INT); +GO +~~START~~ +money +461168601842738.7903 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS BIGINT); +GO +~~START~~ +money +461168601842738.7903 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +1.0000 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS BIT); +GO +~~START~~ +money +922337203685477.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(500 AS BIT); +GO +~~START~~ +money +922337203685477.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(0 AS BIT); +GO +~~START~~ +money +~~ERROR (Code: 8134)~~ + +~~ERROR (Message: division by zero)~~ + +SELECT CAST(1.1 AS MONEY) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(1.1 AS SMALLMONEY) / CAST(922337203685477.5807 AS MONEY);; +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(2 AS TINYINT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(2 AS SMALLINT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(2 AS INT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(2 AS BIGINT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(2 AS BIT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(1 AS BIT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(500 AS BIT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(0 AS BIT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(-922337203685477.5808 AS MONEY) / CAST(0.9 AS REAL); +GO +~~START~~ +real +-1.02481913E15 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) / CAST(0.9 AS FLOAT); +GO +~~START~~ +float +-1.0248191152060862E15 +~~END~~ + + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS TINYINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS SMALLINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS BIGINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS SMALLMONEY) + CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS TINYINT) + CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(1 AS SMALLINT) + CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS INT) + CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS BIGINT) + CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS MONEY); +GO +~~START~~ +money +214749.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS REAL); +GO +~~START~~ +real +214749.36 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS FLOAT); +GO +~~START~~ +float +214749.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214747.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS TINYINT); +GO +~~START~~ +smallmoney +214747.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS SMALLINT); +GO +~~START~~ +smallmoney +214747.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS INT); +GO +~~START~~ +smallmoney +214747.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS BIGINT); +GO +~~START~~ +smallmoney +214747.3647 +~~END~~ + +SELECT CAST(1 AS SMALLMONEY) - CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3647 +~~END~~ + +SELECT CAST(1 AS TINYINT) - CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3647 +~~END~~ + +SELECT CAST(1 AS SMALLINT) - CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3647 +~~END~~ + +SELECT CAST(1 AS INT) - CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3647 +~~END~~ + +SELECT CAST(1 AS BIGINT) - CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3647 +~~END~~ + + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- - +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS TINYINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS SMALLINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS BIGINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(0 AS BIT); +GO +~~START~~ +smallmoney +-214748.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS BIT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(1 AS SMALLMONEY) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS TINYINT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(1 AS SMALLINT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS INT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS BIGINT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS BIT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(0 AS BIT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS MONEY); +GO +~~START~~ +money +-214749.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS REAL); +GO +~~START~~ +real +-214749.36 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS FLOAT); +GO +~~START~~ +float +-214749.3648 +~~END~~ + +SELECT CAST(1 AS MONEY) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +money +214749.3648 +~~END~~ + +SELECT CAST(1 AS REAL) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +real +214749.36 +~~END~~ + +SELECT CAST(1 AS FLOAT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +float +214749.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS TINYINT); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS SMALLINT); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS INT); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS BIGINT); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(1 AS SMALLMONEY) + CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(1 AS TINYINT) + CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(1 AS SMALLINT) + CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(1 AS INT) + CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(1 AS BIGINT) + CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) + CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- * +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS TINYINT); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS SMALLINT); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS INT); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1.1 AS SMALLMONEY) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1.1 AS TINYINT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(1.1 AS SMALLINT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(1.1 AS INT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(1 AS BIT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(0 AS BIT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +0.0000 +~~END~~ + +SELECT CAST(500 AS BIT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS MONEY); +GO +~~START~~ +money +236223.2012 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS REAL); +GO +~~START~~ +real +236223.2 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS FLOAT); +GO +~~START~~ +float +236223.20117000001 +~~END~~ + +SELECT CAST(1.1 AS MONEY) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +money +236223.2012 +~~END~~ + +SELECT CAST(1.1 AS REAL) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +real +236223.2 +~~END~~ + +SELECT CAST(1.1 AS FLOAT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +float +236223.20117000001 +~~END~~ + +SELECT CAST(-214748.3647 AS SMALLMONEY) * CAST(1.1 AS MONEY); +GO +~~START~~ +money +-236223.2012 +~~END~~ + +SELECT CAST(-214748.3647 AS SMALLMONEY) * CAST(1.1 AS REAL); +GO +~~START~~ +real +-236223.2 +~~END~~ + +SELECT CAST(-214748.3647 AS SMALLMONEY) * CAST(1.1 AS FLOAT); +GO +~~START~~ +float +-236223.20117000001 +~~END~~ + +SELECT CAST(1.1 AS MONEY) * CAST(-214748.3647 AS SMALLMONEY); +GO +~~START~~ +money +-236223.2012 +~~END~~ + +SELECT CAST(1.1 AS REAL) * CAST(-214748.3647 AS SMALLMONEY); +GO +~~START~~ +real +-236223.2 +~~END~~ + +SELECT CAST(1.1 AS FLOAT) * CAST(-214748.3647 AS SMALLMONEY); +GO +~~START~~ +float +-236223.20117000001 +~~END~~ + + + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- / +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(0.9 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(214749 AS BIGINT); +GO +~~START~~ +smallmoney +-0.9999 +~~END~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(0.9 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(214749 AS BIGINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(0.9 AS MONEY); +GO +~~START~~ +money +-238609.2942 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(0.9 AS REAL); +GO +~~START~~ +real +-238609.3 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(0.9 AS FLOAT); +GO +~~START~~ +float +-238609.29422222223 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(2 AS BIGINT); +GO +~~START~~ +smallmoney +-107374.1824 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(1 AS TINYINT); +GO +~~START~~ +smallmoney +-214748.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(60 AS SMALLINT); +GO +~~START~~ +smallmoney +-3579.1394 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(43 AS INT); +GO +~~START~~ +smallmoney +-4994.1480 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(10000 AS BIGINT); +GO +~~START~~ +smallmoney +-21.4748 +~~END~~ + +SELECT CAST(0.9 AS SMALLMONEY) / CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +0.0000 +~~END~~ + +SELECT CAST(2 AS BIGINT) / CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +0.0000 +~~END~~ + +SELECT CAST(1 AS TINYINT) / CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +0.0000 +~~END~~ + +SELECT CAST(60 AS SMALLINT) / CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-0.0003 +~~END~~ + +SELECT CAST(43 AS INT) / CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-0.0002 +~~END~~ + +SELECT CAST(10000 AS BIGINT) / CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-0.0466 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(214748 AS BIGINT); +GO +~~START~~ +smallmoney +-1.0000 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(1 AS BIT); +GO +~~START~~ +smallmoney +-214748.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(214748 AS BIT); +GO +~~START~~ +smallmoney +-214748.3648 +~~END~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(0.9 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(0.9 AS REAL); +GO +~~START~~ +real +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(0.9 AS FLOAT); +GO +~~START~~ +float +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(2 AS BIGINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(1 AS TINYINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(60 AS SMALLINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(43 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(10000 AS BIGINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(0.9 AS SMALLMONEY) / CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(2 AS BIGINT) / CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(1 AS TINYINT) / CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(60 AS SMALLINT) / CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(43 AS INT) / CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(10000 AS BIGINT) / CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(214748 AS BIGINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(1 AS BIT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(214748 AS BIT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + + + + +-- ============================================= +-- Result Overflows +-- ============================================= +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) * CAST(1.0001 as SMALLMONEY) +END +GO +~~START~~ +numeric +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(922337203685477.5807 as MONEY) * CAST(1.0001 as MONEY) +END +GO +~~START~~ +numeric +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) + CAST(214748.3647 as SMALLMONEY) +END +GO +~~START~~ +numeric +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) / CAST(0.5 as SMALLMONEY) +END +GO +~~START~~ +numeric +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(-214748.3647 as SMALLMONEY) * CAST(1.001 as SMALLMONEY) +END +GO +~~START~~ +numeric +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as MONEY) * CAST(1.0001 as MONEY) +END +GO +~~START~~ +numeric +214769.8395 +~~END~~ + +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) + CAST(214748.3647 as MONEY) +END +GO +~~START~~ +numeric +429496.7294 +~~END~~ + +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) / CAST(0.5 as MONEY) +END +GO +~~START~~ +numeric +429496.7294 +~~END~~ + + + +------------------------------------------------------------------------ +---- 3. Arithmetic Operations Tests +------------------------------------------------------------------------ +-- Addition (+) operator tests with MONEY +-- MONEY + MONEY +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +802.3500 +~~END~~ + + +-- MONEY + SMALLMONEY +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +money +802.3500 +~~END~~ + + +-- MONEY + TINYINT +SELECT CAST(123.45 AS MONEY) + CAST(255 AS TINYINT) AS result; +GO +~~START~~ +money +378.4500 +~~END~~ + + +-- MONEY + SMALLINT +SELECT CAST(123.45 AS MONEY) + CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +money +32890.4500 +~~END~~ + + +-- MONEY + INT +SELECT CAST(123.45 AS MONEY) + CAST(2147483647 AS INT) AS result; +GO +~~START~~ +money +2147483770.4500 +~~END~~ + + +-- MONEY + BIGINT +SELECT CAST(123.45 AS MONEY) + CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +-- MONEY + REAL +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +802.35004 +~~END~~ + + +-- MONEY + FLOAT +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +802.35 +~~END~~ + + +-- MONEY + NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +802.3500 +~~END~~ + + +-- MONEY + NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) + CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +802.3512 +~~END~~ + + +-- MONEY + NUMERIC(18,6) +SELECT CAST(123.45 AS MONEY) + CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO +~~START~~ +numeric +802.351234 +~~END~~ + + +-- MONEY + BIT +SELECT CAST(123.45 AS MONEY) + CAST(1 AS BIT) AS result; +GO +~~START~~ +money +124.4500 +~~END~~ + + +-- BIT + MONEY +SELECT CAST(1 AS BIT) + CAST(123.45 AS MONEY) AS result; +GO +~~START~~ +money +124.4500 +~~END~~ + + +-- BIT + MONEY +SELECT CAST(0 AS BIT) + CAST(123.45 AS MONEY) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- BIT + MONEY +SELECT CAST(-32 AS BIT) + CAST(123.45 AS MONEY) AS result; +GO +~~START~~ +money +124.4500 +~~END~~ + + +-- BIT + MONEY +SELECT CAST(32 AS BIT) + CAST(123.45 AS MONEY) AS result; +GO +~~START~~ +money +124.4500 +~~END~~ + + +-- Subtraction (-) operator tests with MONEY +-- MONEY - MONEY +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +-555.4500 +~~END~~ + + +-- MONEY - SMALLMONEY +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +money +-555.4500 +~~END~~ + + +-- MONEY - TINYINT +SELECT CAST(123.45 AS MONEY) - CAST(255 AS TINYINT) AS result; +GO +~~START~~ +money +-131.5500 +~~END~~ + + +-- MONEY - SMALLINT +SELECT CAST(123.45 AS MONEY) - CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +money +-32643.5500 +~~END~~ + + +-- MONEY - INT +SELECT CAST(123.45 AS MONEY) - CAST(2147483647 AS INT) AS result; +GO +~~START~~ +money +-2147483523.5500 +~~END~~ + + +-- MONEY - BIGINT +SELECT CAST(123.45 AS MONEY) - CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +-- MONEY - REAL +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +-555.45 +~~END~~ + + +-- MONEY - FLOAT +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +-555.4499999999999 +~~END~~ + + +-- MONEY - NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +-555.4500 +~~END~~ + + +-- MONEY - NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) - CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +-555.4512 +~~END~~ + + +-- MONEY - NUMERIC(18,6) +SELECT CAST(123.45 AS MONEY) - CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO +~~START~~ +numeric +-555.451234 +~~END~~ + + +-- MONEY - BIT +SELECT CAST(123.45 AS MONEY) - CAST(1 AS BIT) AS result; +GO +~~START~~ +money +122.4500 +~~END~~ + + +-- MONEY * MONEY +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +83810.2050 +~~END~~ + + +-- MONEY * SMALLMONEY +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +money +83810.2050 +~~END~~ + + +-- MONEY * TINYINT +SELECT CAST(123.45 AS MONEY) * CAST(255 AS TINYINT) AS result; +GO +~~START~~ +money +31479.7500 +~~END~~ + + +-- MONEY * SMALLINT +SELECT CAST(123.45 AS MONEY) * CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +money +4045086.1500 +~~END~~ + + +-- MONEY * INT +SELECT CAST(123.45 AS MONEY) * CAST(2147483647 AS INT) AS result; +GO +~~START~~ +money +265106856222.1500 +~~END~~ + + +-- MONEY * BIGINT +SELECT CAST(123.45 AS MONEY) * CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +-- MONEY * REAL +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +83810.2 +~~END~~ + + +-- MONEY * FLOAT +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +83810.205 +~~END~~ + + +-- MONEY * NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +83810.205000 +~~END~~ + + +-- MONEY * NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) * CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +83810.35314000 +~~END~~ + + +-- MONEY * BIT +SELECT CAST(123.45 AS MONEY) * CAST(1 AS BIT) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- Division (/) operator tests with MONEY +-- MONEY / MONEY +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +0.1818 +~~END~~ + + +-- MONEY / SMALLMONEY +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +money +0.1818 +~~END~~ + + +-- MONEY / TINYINT +SELECT CAST(123.45 AS MONEY) / CAST(255 AS TINYINT) AS result; +GO +~~START~~ +money +0.4841 +~~END~~ + + +-- MONEY / SMALLINT +SELECT CAST(123.45 AS MONEY) / CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +money +0.0037 +~~END~~ + + +-- MONEY / INT +SELECT CAST(123.45 AS MONEY) / CAST(2147483647 AS INT) AS result; +GO +~~START~~ +money +0.0000 +~~END~~ + + +-- MONEY / BIGINT +SELECT CAST(123.45 AS MONEY) / CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +money +0.0000 +~~END~~ + + +-- MONEY / REAL +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +0.18183826 +~~END~~ + + +-- MONEY / FLOAT +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +0.18183826778612464 +~~END~~ + + +-- MONEY / NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +0.1818382677 +~~END~~ + + +-- MONEY / NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) / CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +0.181837946375702 +~~END~~ + + +-- MONEY / NUMERIC(18,6) +SELECT CAST(123.45 AS MONEY) / CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO +~~START~~ +numeric +0.18183793726909030 +~~END~~ + + +-- MONEY / BIT +SELECT CAST(123.45 AS MONEY) / CAST(1 AS BIT) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- Modulo (%) operator tests with MONEY +-- MONEY % MONEY +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- MONEY % SMALLMONEY +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- MONEY % TINYINT +SELECT CAST(123.45 AS MONEY) % CAST(255 AS TINYINT) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- MONEY % SMALLINT +SELECT CAST(123.45 AS MONEY) % CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- MONEY % INT +SELECT CAST(123.45 AS MONEY) % CAST(2147483647 AS INT) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- MONEY % BIGINT +SELECT CAST(123.45 AS MONEY) % CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value "9223372036854775807" is out of range for type money)~~ + + + +-- MONEY % REAL +-- FIXME: To be fixed in BABEL-5746 +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS REAL) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + + +-- MONEY % FLOAT +-- FIXME: To be fixed in BABEL-5746 +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + + +-- MONEY % NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +123.4500 +~~END~~ + + +-- MONEY % NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) % CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +123.4500 +~~END~~ + + +-- MONEY % NUMERIC(18,6) +SELECT CAST(123.45 AS MONEY) % CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO +~~START~~ +numeric +123.450000 +~~END~~ + + +-- MONEY % BIT +SELECT CAST(123.45 AS MONEY) % CAST(1 AS BIT) AS result; +GO +~~START~~ +money +0.4500 +~~END~~ + + + +-- Addition (+) operator tests with SMALLMONEY +-- SMALLMONEY + MONEY +SELECT CAST(123.45 AS SMALLMONEY) + CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +802.3500 +~~END~~ + + +-- SMALLMONEY + SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) + CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +smallmoney +802.3500 +~~END~~ + + +-- SMALLMONEY + TINYINT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(255 AS TINYINT) AS result; +GO +~~START~~ +smallmoney +378.4500 +~~END~~ + + +-- SMALLMONEY + SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +smallmoney +32890.4500 +~~END~~ + + +-- SMALLMONEY + INT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(2147483647 AS INT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +-- SMALLMONEY + BIGINT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +-- SMALLMONEY + REAL +SELECT CAST(123.45 AS SMALLMONEY) + CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +802.35004 +~~END~~ + + +-- SMALLMONEY + FLOAT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +802.35 +~~END~~ + + +-- SMALLMONEY + BIT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(1 AS BIT) AS result; +GO +~~START~~ +smallmoney +124.4500 +~~END~~ + + +-- Subtraction (-) operator tests with SMALLMONEY +-- SMALLMONEY - MONEY +SELECT CAST(123.45 AS SMALLMONEY) - CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +-555.4500 +~~END~~ + + +-- SMALLMONEY - SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) - CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +smallmoney +-555.4500 +~~END~~ + + +-- SMALLMONEY - TINYINT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(255 AS TINYINT) AS result; +GO +~~START~~ +smallmoney +-131.5500 +~~END~~ + + +-- SMALLMONEY - SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +smallmoney +-32643.5500 +~~END~~ + + + +-- SMALLMONEY - INT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(2147483647 AS INT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + + +-- SMALLMONEY - BIGINT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +-- SMALLMONEY - REAL +SELECT CAST(123.45 AS SMALLMONEY) - CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +-555.45 +~~END~~ + + +-- SMALLMONEY - FLOAT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +-555.4499999999999 +~~END~~ + + + +-- SMALLMONEY - BIT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(1 AS BIT) AS result; +GO +~~START~~ +smallmoney +122.4500 +~~END~~ + + +-- Multiplication (*) operator tests with SMALLMONEY +-- SMALLMONEY * MONEY +SELECT CAST(123.45 AS SMALLMONEY) * CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +83810.2050 +~~END~~ + + +-- SMALLMONEY * SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) * CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +smallmoney +83810.2050 +~~END~~ + + +-- SMALLMONEY * TINYINT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(255 AS TINYINT) AS result; +GO +~~START~~ +smallmoney +31479.7500 +~~END~~ + + + +-- SMALLMONEY * SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + + +-- SMALLMONEY * INT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(2147483647 AS INT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + + +-- SMALLMONEY * BIGINT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +-- SMALLMONEY * REAL +SELECT CAST(123.45 AS SMALLMONEY) * CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +83810.2 +~~END~~ + + +-- SMALLMONEY * FLOAT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +83810.205 +~~END~~ + + + +-- SMALLMONEY * BIT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(1 AS BIT) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + +-- Division (/) operator tests with SMALLMONEY +-- SMALLMONEY / MONEY +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +0.1818 +~~END~~ + + +-- SMALLMONEY / SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +smallmoney +0.1818 +~~END~~ + + +-- SMALLMONEY / TINYINT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(255 AS TINYINT) AS result; +GO +~~START~~ +smallmoney +0.4841 +~~END~~ + + +-- SMALLMONEY / SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +smallmoney +0.0037 +~~END~~ + + + +-- SMALLMONEY / INT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(2147483647 AS INT) AS result; +GO +~~START~~ +smallmoney +0.0000 +~~END~~ + + + +-- SMALLMONEY / BIGINT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +smallmoney +0.0000 +~~END~~ + + +-- SMALLMONEY / REAL +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +0.18183826 +~~END~~ + + +-- SMALLMONEY / FLOAT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +0.18183826778612464 +~~END~~ + + + +-- SMALLMONEY / NUMERIC(5,2) +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +0.1818382677 +~~END~~ + + + +-- SMALLMONEY / NUMERIC(10,4) +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +0.181837946375702 +~~END~~ + + + +-- SMALLMONEY / NUMERIC(18,6) +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO +~~START~~ +numeric +0.18183793726909030777000 +~~END~~ + + + +-- SMALLMONEY / BIT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(1 AS BIT) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + +-- Modulo (%) operator tests with SMALLMONEY +SELECT 'Modulo (%) Operator Tests with SMALLMONEY' AS test_description; +GO +~~START~~ +varchar +Modulo (%) Operator Tests with SMALLMONEY +~~END~~ + + +-- SMALLMONEY % MONEY +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- SMALLMONEY % SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + +-- SMALLMONEY % TINYINT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(255 AS TINYINT) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + +-- SMALLMONEY % SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + +-- SMALLMONEY % INT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(2147483647 AS INT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + +-- SMALLMONEY % BIGINT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value "9223372036854775807" is out of range for type smallmoney)~~ + + + +-- SMALLMONEY % REAL +-- FIXME: To be fixed in BABEL-5746 +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS REAL) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + + +-- SMALLMONEY % FLOAT +-- FIXME: To be fixed in BABEL-5746 +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + + +-- SMALLMONEY % NUMERIC(5,2) +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +123.4500 +~~END~~ + + +-- SMALLMONEY % NUMERIC(10,4) +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +123.4500 +~~END~~ + + +-- SMALLMONEY % NUMERIC(18,6) +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO +~~START~~ +numeric +123.450000 +~~END~~ + + +-- SMALLMONEY % BIT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(1 AS BIT) AS result; +GO +~~START~~ +smallmoney +0.4500 +~~END~~ + + +-- Unary minus (-) operator tests +-- Unary Minus MONEY +SELECT -CAST(123.45 AS MONEY) AS result; +GO +~~START~~ +money +-123.4500 +~~END~~ + + +-- Unary Minus SMALLMONEY +SELECT -CAST(123.45 AS SMALLMONEY) AS result; +GO +~~START~~ +smallmoney +-123.4500 +~~END~~ + + +-- Complex Arithmetic Tests for MONEY +-- Multiple operators in single expression +SELECT (CAST(1234.56 AS MONEY) + CAST(789.12 AS MONEY)) * CAST(2 AS INT) / CAST(3 AS INT) AS result; +GO +~~START~~ +money +1349.1200 +~~END~~ + + +-- Nested calculations +SELECT CAST(100.00 AS MONEY) + (CAST(200.00 AS MONEY) * CAST(3 AS INT)) + (CAST(400.00 AS MONEY) / CAST(2 AS INT)) AS result; +GO +~~START~~ +money +900.0000 +~~END~~ + + +-- Mixed money types calculations +SELECT (CAST(1000.00 AS MONEY) + CAST(500.00 AS SMALLMONEY)) * + (CAST(250.00 AS MONEY) + CAST(125.00 AS SMALLMONEY)) AS result; +GO +~~START~~ +money +562500.0000 +~~END~~ + + +-- Complex percentage calculations +SELECT CAST(1000.00 AS MONEY) + + (CAST(1000.00 AS MONEY) * CAST(0.10 AS FLOAT)) + -- Add 10% + (CAST(1000.00 AS MONEY) * CAST(0.05 AS FLOAT)) -- Add 5% +AS result; +GO +~~START~~ +float +1150.0 +~~END~~ + + +-- Mixed numeric type operations +SELECT (CAST(1000.00 AS MONEY) * CAST(1.5 AS FLOAT)) + + (CAST(500.00 AS MONEY) * CAST(2.5 AS NUMERIC(5,2))) + + (CAST(250.00 AS MONEY) / CAST(2 AS INT)) +AS result; +GO +~~START~~ +float +2875.0 +~~END~~ + + +-- Nested modulo operations +SELECT (CAST(1000.00 AS MONEY) % CAST(300 AS INT)) + + (CAST(500.00 AS MONEY) % CAST(200 AS INT)) AS result; +GO +~~START~~ +money +200.0000 +~~END~~ + + +-- Compound interest calculation +SELECT CAST(1000.00 AS MONEY) * + POWER(CAST(1.05 AS FLOAT), 3) -- 5% interest compounded for 3 periods +AS result; +GO +~~START~~ +float +1157.6250000000002 +~~END~~ + + +-- Tax calculation with multiple rates +SELECT CAST(1000.00 AS MONEY) + + (CAST(1000.00 AS MONEY) * CAST(0.05 AS FLOAT)) + -- State tax 5% + (CAST(1000.00 AS MONEY) * CAST(0.08 AS FLOAT)) + -- County tax 8% + (CAST(1000.00 AS MONEY) * CAST(0.02 AS FLOAT)) -- Special tax 2% +AS total_with_taxes; +GO +~~START~~ +float +1150.0 +~~END~~ + + +-- Complex discount calculation +SELECT CAST(1000.00 AS MONEY) - + (CAST(1000.00 AS MONEY) * CAST(0.20 AS FLOAT)) - -- 20% off + (CAST(50.00 AS MONEY)) + -- Less $50 + (CAST(1000.00 AS MONEY) * CAST(0.05 AS FLOAT)) -- Plus 5% fee +AS final_price; +GO +~~START~~ +float +800.0 +~~END~~ + + +-- Complex division and modulo +SELECT (CAST(1234.56 AS MONEY) / CAST(2 AS INT)) + + (CAST(1234.56 AS MONEY) % CAST(500 AS INT)) + + (CAST(1234.56 AS MONEY) * CAST(0.10 AS FLOAT)) +AS result; +GO +~~START~~ +float +975.296 +~~END~~ + + +-- Complex SMALLMONEY Arithmetic Tests +-- Multiple operators in single expression +SELECT (CAST(123.45 AS SMALLMONEY) + CAST(78.91 AS SMALLMONEY)) * + CAST(2 AS INT) / CAST(3 AS INT) AS result; +GO +~~START~~ +smallmoney +134.9066 +~~END~~ + + +-- Nested calculations +SELECT CAST(100.00 AS SMALLMONEY) + + (CAST(200.00 AS SMALLMONEY) * CAST(3 AS INT)) + + (CAST(400.00 AS SMALLMONEY) / CAST(2 AS INT)) AS result; +GO +~~START~~ +smallmoney +900.0000 +~~END~~ + + +-- Mixed money types calculations +SELECT (CAST(1000.00 AS SMALLMONEY) + CAST(500.00 AS SMALLMONEY)) * + (CAST(250.00 AS MONEY) + CAST(125.00 AS SMALLMONEY)) AS result; +GO +~~START~~ +money +562500.0000 +~~END~~ + + +-- Complex percentage calculations with SMALLMONEY +SELECT CAST(1000.00 AS SMALLMONEY) + + (CAST(1000.00 AS SMALLMONEY) * CAST(0.10 AS FLOAT)) + -- Add 10% + (CAST(1000.00 AS SMALLMONEY) * CAST(0.05 AS FLOAT)) -- Add 5% +AS result; +GO +~~START~~ +float +1150.0 +~~END~~ + + +-- Mixed numeric type operations +SELECT (CAST(1000.00 AS SMALLMONEY) * CAST(1.5 AS FLOAT)) + + (CAST(500.00 AS SMALLMONEY) * CAST(2.5 AS NUMERIC(5,2))) + + (CAST(250.00 AS SMALLMONEY) / CAST(2 AS INT)) +AS result; +GO +~~START~~ +float +2875.0 +~~END~~ + + +-- Price adjustment calculation +SELECT CAST(100.00 AS SMALLMONEY) + + (CAST(100.00 AS SMALLMONEY) * + CASE + WHEN CAST(100.00 AS SMALLMONEY) > CAST(50.00 AS SMALLMONEY) + THEN CAST(0.10 AS FLOAT) + ELSE CAST(0.05 AS FLOAT) + END) +AS adjusted_price; +GO +~~START~~ +float +110.0 +~~END~~ + + +-- Multi-step calculation +SELECT (CAST(100.00 AS SMALLMONEY) * + CAST(1.10 AS FLOAT) + -- Add 10% + CAST(25.00 AS SMALLMONEY)) * -- Add fixed amount + CAST(0.95 AS FLOAT) -- Apply 5% discount +AS result; +GO +~~START~~ +float +128.25 +~~END~~ + + +-- Weighted average price calculation +SELECT (CAST(100.00 AS SMALLMONEY) * CAST(0.7 AS FLOAT)) + + (CAST(200.00 AS SMALLMONEY) * CAST(0.3 AS FLOAT)) +AS weighted_average; +GO +~~START~~ +float +130.0 +~~END~~ + + +-- Complex rounding test +SELECT CAST( + (CAST(123.456 AS FLOAT) * + CAST(100.00 AS SMALLMONEY)) / + CAST(3 AS INT) +AS SMALLMONEY) AS rounded_result; +GO +~~START~~ +smallmoney +4115.2000 +~~END~~ + + +-- Mathematical formula implementation +SELECT CAST(100.00 AS SMALLMONEY) * + POWER(CAST(1 AS FLOAT) + CAST(0.05 AS FLOAT), 4) -- Compound interest +AS future_value; +GO +~~START~~ +float +121.55062500000003 +~~END~~ + + +-- Complex marginal calculation +SELECT CASE + WHEN CAST(1000.00 AS SMALLMONEY) <= CAST(500.00 AS SMALLMONEY) + THEN CAST(1000.00 AS SMALLMONEY) * CAST(1.10 AS FLOAT) + WHEN CAST(1000.00 AS SMALLMONEY) <= CAST(1000.00 AS SMALLMONEY) + THEN CAST(1000.00 AS SMALLMONEY) * CAST(1.20 AS FLOAT) + ELSE CAST(1000.00 AS SMALLMONEY) * CAST(1.30 AS FLOAT) +END AS tiered_pricing; +GO +~~START~~ +float +1200.0 +~~END~~ + + +-- Mixed arithmetic with multiple data types +SELECT (CAST(100.00 AS SMALLMONEY) * CAST(1.1 AS FLOAT)) + + (CAST(50.00 AS SMALLMONEY) / CAST(2 AS INT)) + + (CAST(25.00 AS SMALLMONEY) * CAST(0.8 AS NUMERIC(3,1))) + + CAST(10 AS TINYINT) +AS mixed_calculation; +GO +~~START~~ +float +165.0 +~~END~~ + + + +------------------------------------------------------------------------ +---- 3. Mathematical Functions Tests +------------------------------------------------------------------------ +-- ABS Function +-- MONEY tests +SELECT ABS(CAST(123.45 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +money +123.4500 +~~END~~ + +SELECT ABS(CAST(-123.45 AS MONEY)) AS result; -- Negative MONEY +GO +~~START~~ +money +123.4500 +~~END~~ + +SELECT ABS(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT ABS(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +money +922337203685477.5807 +~~END~~ + +SELECT ABS(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT ABS(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +money + +~~END~~ + +SELECT ABS(CAST(-0.0001 AS MONEY)) AS result; -- Small negative MONEY value +GO +~~START~~ +money +0.0001 +~~END~~ + +SELECT ABS(CAST(-0.00 AS MONEY)) AS result; -- Negative zero MONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +-- SMALLMONEY tests +SELECT ABS(CAST(123.45 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +money +123.4500 +~~END~~ + +SELECT ABS(CAST(-123.45 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO +~~START~~ +money +123.4500 +~~END~~ + +SELECT ABS(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT ABS(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +money +214748.3647 +~~END~~ + +SELECT ABS(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value +GO +~~START~~ +money +214748.3648 +~~END~~ + +SELECT ABS(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +money + +~~END~~ + +SELECT ABS(CAST(-0.0001 AS SMALLMONEY)) AS result; -- Small negative SMALLMONEY value +GO +~~START~~ +money +0.0001 +~~END~~ + +SELECT ABS(CAST(-0.00 AS SMALLMONEY)) AS result; -- Negative zero SMALLMONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + + +-- CEILING tests for MONEY +SELECT CEILING(CAST(123.45 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +money +124.0000 +~~END~~ + + +SELECT CEILING(CAST(-123.45 AS MONEY)) AS result; -- Negative MONEY +GO +~~START~~ +money +-123.0000 +~~END~~ + + +SELECT CEILING(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT CEILING(CAST(123.00 AS MONEY)) AS result; -- Integer value MONEY +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT CEILING(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT CEILING(CAST(999.999 AS MONEY)) AS result; -- Value close to next integer +GO +~~START~~ +money +1000.0000 +~~END~~ + + +SELECT CEILING(CAST(-999.001 AS MONEY)) AS result; -- Negative value close to integer +GO +~~START~~ +money +-999.0000 +~~END~~ + + +SELECT CEILING(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CEILING(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value +GO +~~START~~ +money +-922337203685477.0000 +~~END~~ + + +SELECT CEILING(CAST(0.0001 AS MONEY)) AS result; -- Small positive value +GO +~~START~~ +money +1.0000 +~~END~~ + + + +-- CEILING tests for SMALLMONEY +SELECT CEILING(CAST(123.45 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +money +124.0000 +~~END~~ + + +SELECT CEILING(CAST(-123.45 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO +~~START~~ +money +-123.0000 +~~END~~ + + +SELECT CEILING(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT CEILING(CAST(123.00 AS SMALLMONEY)) AS result; -- Integer value SMALLMONEY +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT CEILING(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT CEILING(CAST(999.999 AS SMALLMONEY)) AS result; -- Value close to next integer +GO +~~START~~ +money +1000.0000 +~~END~~ + + +SELECT CEILING(CAST(-999.001 AS SMALLMONEY)) AS result; -- Negative value close to integer +GO +~~START~~ +money +-999.0000 +~~END~~ + + +SELECT CEILING(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +money +214749.0000 +~~END~~ + + +SELECT CEILING(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value +GO +~~START~~ +money +-214748.0000 +~~END~~ + + +SELECT CEILING(CAST(0.0001 AS SMALLMONEY)) AS result; -- Small positive value +GO +~~START~~ +money +1.0000 +~~END~~ + + + +-- FLOOR tests for MONEY +SELECT FLOOR(CAST(123.45 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT FLOOR(CAST(-123.45 AS MONEY)) AS result; -- Negative MONEY +GO +~~START~~ +money +-124.0000 +~~END~~ + + +SELECT FLOOR(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT FLOOR(CAST(123.00 AS MONEY)) AS result; -- Integer value MONEY +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT FLOOR(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT FLOOR(CAST(999.999 AS MONEY)) AS result; -- Value close to integer +GO +~~START~~ +money +999.0000 +~~END~~ + + +SELECT FLOOR(CAST(-999.001 AS MONEY)) AS result; -- Negative value close to next integer +GO +~~START~~ +money +-1000.0000 +~~END~~ + + +SELECT FLOOR(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +money +922337203685477.0000 +~~END~~ + + +SELECT FLOOR(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT FLOOR(CAST(0.0001 AS MONEY)) AS result; -- Small positive value +GO +~~START~~ +money +0.0000 +~~END~~ + + + +-- FLOOR tests for SMALLMONEY +SELECT FLOOR(CAST(123.45 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT FLOOR(CAST(-123.45 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO +~~START~~ +money +-124.0000 +~~END~~ + + +SELECT FLOOR(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT FLOOR(CAST(123.00 AS SMALLMONEY)) AS result; -- Integer value SMALLMONEY +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT FLOOR(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT FLOOR(CAST(999.999 AS SMALLMONEY)) AS result; -- Value close to integer +GO +~~START~~ +money +999.0000 +~~END~~ + + +SELECT FLOOR(CAST(-999.001 AS SMALLMONEY)) AS result; -- Negative value close to next integer +GO +~~START~~ +money +-1000.0000 +~~END~~ + + +SELECT FLOOR(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +money +214748.0000 +~~END~~ + + +SELECT FLOOR(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value +GO +~~START~~ +money +-214749.0000 +~~END~~ + + +SELECT FLOOR(CAST(0.0001 AS SMALLMONEY)) AS result; -- Small positive value +GO +~~START~~ +money +0.0000 +~~END~~ + + + +-- ROUND tests for MONEY +SELECT ROUND(CAST(123.45 AS MONEY), 0) AS result; -- MONEY 0 decimals +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT ROUND(CAST(-123.45 AS MONEY), 0) AS result; -- Negative MONEY 0 decimals +GO +~~START~~ +money +-123.0000 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), 1) AS result; -- MONEY 1 decimal +GO +~~START~~ +money +123.5000 +~~END~~ + + +SELECT ROUND(CAST(-123.45 AS MONEY), 1) AS result; -- Negative MONEY 1 decimal +GO +~~START~~ +money +-123.5000 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), 2) AS result; -- MONEY 2 decimals +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), 3) AS result; -- MONEY 3 decimals +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), -1) AS result; -- MONEY negative digits (round to tens) +GO +~~START~~ +money +120.0000 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), -2) AS result; -- MONEY negative digits (round to hundreds) +GO +~~START~~ +money +100.0000 +~~END~~ + + +SELECT ROUND(CAST(NULL AS MONEY), 1) AS result; -- NULL MONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT ROUND(CAST(123.456 AS MONEY), 2) AS result; -- Round up +GO +~~START~~ +money +123.4600 +~~END~~ + + +SELECT ROUND(CAST(123.454 AS MONEY), 2) AS result; -- Round down +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.455 AS MONEY), 2) AS result; -- Round half (banker's rounding) +GO +~~START~~ +money +123.4600 +~~END~~ + + +SELECT ROUND(CAST(-123.456 AS MONEY), 2) AS result; -- Negative round up +GO +~~START~~ +money +-123.4600 +~~END~~ + + +SELECT ROUND(CAST(-123.454 AS MONEY), 2) AS result; -- Negative round down +GO +~~START~~ +money +-123.4500 +~~END~~ + + +SELECT ROUND(CAST(-123.455 AS MONEY), 2) AS result; -- Negative round half +GO +~~START~~ +money +-123.4600 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), 2, 0) AS result; -- Explicit round (default) +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), 2, 1) AS result; -- Explicit truncate +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(555.55 AS MONEY), -2, 1) AS result; -- Truncate to hundreds +GO +~~START~~ +money +500.0000 +~~END~~ + + + +-- ROUND tests for SMALLMONEY +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 0) AS result; -- SMALLMONEY 0 decimals +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT ROUND(CAST(-123.45 AS SMALLMONEY), 0) AS result; -- Negative SMALLMONEY 0 decimals +GO +~~START~~ +money +-123.0000 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 1) AS result; -- SMALLMONEY 1 decimal +GO +~~START~~ +money +123.5000 +~~END~~ + + +SELECT ROUND(CAST(-123.45 AS SMALLMONEY), 1) AS result; -- Negative SMALLMONEY 1 decimal +GO +~~START~~ +money +-123.5000 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 2) AS result; -- SMALLMONEY 2 decimals +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 3) AS result; -- SMALLMONEY 3 decimals +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), -1) AS result; -- SMALLMONEY negative digits (round to tens) +GO +~~START~~ +money +120.0000 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), -2) AS result; -- SMALLMONEY negative digits (round to hundreds) +GO +~~START~~ +money +100.0000 +~~END~~ + + +SELECT ROUND(CAST(NULL AS SMALLMONEY), 1) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT ROUND(CAST(123.456 AS SMALLMONEY), 2) AS result; -- Round up +GO +~~START~~ +money +123.4600 +~~END~~ + + +SELECT ROUND(CAST(123.454 AS SMALLMONEY), 2) AS result; -- Round down +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.455 AS SMALLMONEY), 2) AS result; -- Round half (banker's rounding) +GO +~~START~~ +money +123.4600 +~~END~~ + + +SELECT ROUND(CAST(-123.456 AS SMALLMONEY), 2) AS result; -- Negative round up +GO +~~START~~ +money +-123.4600 +~~END~~ + + +SELECT ROUND(CAST(-123.454 AS SMALLMONEY), 2) AS result; -- Negative round down +GO +~~START~~ +money +-123.4500 +~~END~~ + + +SELECT ROUND(CAST(-123.455 AS SMALLMONEY), 2) AS result; -- Negative round half +GO +~~START~~ +money +-123.4600 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 2, 0) AS result; -- Explicit round (default) +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 2, 1) AS result; -- Explicit truncate +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(555.55 AS SMALLMONEY), -2, 1) AS result; -- Truncate to hundreds +GO +~~START~~ +money +500.0000 +~~END~~ + + +-- SIGN tests for MONEY +SELECT SIGN(CAST(123.45 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT SIGN(CAST(-123.45 AS MONEY)) AS result; -- Negative MONEY +GO +~~START~~ +money +-1.0000 +~~END~~ + + +SELECT SIGN(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT SIGN(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT SIGN(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT SIGN(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value +GO +~~START~~ +money +-1.0000 +~~END~~ + + +SELECT SIGN(CAST(0.0001 AS MONEY)) AS result; -- Small positive value +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT SIGN(CAST(-0.0001 AS MONEY)) AS result; -- Small negative value +GO +~~START~~ +money +-1.0000 +~~END~~ + + +-- SIGN tests for SMALLMONEY +SELECT SIGN(CAST(123.45 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT SIGN(CAST(-123.45 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO +~~START~~ +money +-1.0000 +~~END~~ + + +SELECT SIGN(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT SIGN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT SIGN(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT SIGN(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value +GO +~~START~~ +money +-1.0000 +~~END~~ + + +SELECT SIGN(CAST(0.0001 AS SMALLMONEY)) AS result; -- Small positive value +GO +~~START~~ +money +1.0000 +~~END~~ + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 14) AS result; -- power which overflows +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 14) AS result; -- Negative base,power which overflows +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 9) AS result; -- big power which does not overflows +GO +~~START~~ +money +6634931404.8357 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 9) AS result; -- Negative base, big power which does not overflows +GO +~~START~~ +money +-6634931404.8357 +~~END~~ + + +SELECT SIGN(CAST(-0.0001 AS SMALLMONEY)) AS result; -- Small negative value +GO +~~START~~ +money +-1.0000 +~~END~~ + + +-- POWER tests for MONEY +SELECT POWER(CAST(12.34 AS MONEY), 2) AS result; -- Positive MONEY, Integer Power +GO +~~START~~ +money +152.2756 +~~END~~ + + +SELECT POWER(CAST(12.34 AS MONEY), 0.5) AS result; -- Positive MONEY, Decimal Power +GO +~~START~~ +money +3.5128 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS MONEY), 2) AS result; -- Negative MONEY, Even Integer Power +GO +~~START~~ +money +152.2756 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS MONEY), 3) AS result; -- Negative MONEY, Odd Integer Power +GO +~~START~~ +money +-1879.0809 +~~END~~ + + +SELECT POWER(CAST(0 AS MONEY), 2) AS result; -- Zero MONEY, Positive Power +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT POWER(CAST(12.34 AS MONEY), 0) AS result; -- MONEY, Zero Power +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT POWER(CAST(12.34 AS MONEY), -2) AS result; -- MONEY, Negative Power +GO +~~START~~ +money +0.0066 +~~END~~ + + +SELECT POWER(CAST(NULL AS MONEY), 2) AS result; -- NULL MONEY base +GO +~~START~~ +money + +~~END~~ + + +SELECT POWER(CAST(12.34 AS MONEY), NULL) AS result; -- NULL exponent +GO +~~START~~ +money + +~~END~~ + + +SELECT POWER(CAST(0 AS MONEY), 0) AS result; -- Zero raised to zero power +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT POWER(CAST(0 AS MONEY), -1) AS result; -- Zero raised to negative power +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: zero raised to a negative power is undefined)~~ + + +SELECT POWER(CAST(-12.34 AS MONEY), 0.5) AS result; -- Negative base, fractional power +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: a negative number raised to a non-integer power yields a complex result)~~ + + +SELECT POWER(CAST(12.34 AS MONEY), 14) AS result; -- power which overflows +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT POWER(CAST(-12.34 AS MONEY), 14) AS result; -- Negative base,power which overflows +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT POWER(CAST(12.34 AS MONEY), 9) AS result; -- big power which does not overflows +GO +~~START~~ +money +6634931404.8357 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS MONEY), 9) AS result; -- Negative base, big power which does not overflows +GO +~~START~~ +money +-6634931404.8357 +~~END~~ + + +-- POWER tests for SMALLMONEY +SELECT POWER(CAST(12.34 AS SMALLMONEY), 2) AS result; -- Positive SMALLMONEY, Integer Power +GO +~~START~~ +money +152.2756 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 2) AS result; -- Negative SMALLMONEY, Even Integer Power +GO +~~START~~ +money +152.2756 +~~END~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 0.5) AS result; -- Positive SMALLMONEY, Decimal Power +GO +~~START~~ +money +3.5128 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 3) AS result; -- Negative SMALLMONEY, Odd Integer Power +GO +~~START~~ +money +-1879.0809 +~~END~~ + + +SELECT POWER(CAST(0 AS SMALLMONEY), 2) AS result; -- Zero SMALLMONEY, Positive Power +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 0) AS result; -- SMALLMONEY, Zero Power +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), -2) AS result; -- SMALLMONEY, Negative Power +GO +~~START~~ +money +0.0066 +~~END~~ + + +SELECT POWER(CAST(NULL AS SMALLMONEY), 2) AS result; -- NULL SMALLMONEY base +GO +~~START~~ +money + +~~END~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), NULL) AS result; -- NULL exponent +GO +~~START~~ +money + +~~END~~ + + +SELECT POWER(CAST(0 AS SMALLMONEY), 0) AS result; -- Zero raised to zero power +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT POWER(CAST(0 AS SMALLMONEY), -1) AS result; -- Zero raised to negative power +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: zero raised to a negative power is undefined)~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 0.5) AS result; -- Negative base, fractional power +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: a negative number raised to a non-integer power yields a complex result)~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 14) AS result; -- power which overflows +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 14) AS result; -- Negative base,power which overflows +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 9) AS result; -- big power which does not overflows +GO +~~START~~ +money +6634931404.8357 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 9) AS result; -- Negative base, big power which does not overflows +GO +~~START~~ +money +-6634931404.8357 +~~END~~ + + +-- SQRT tests for MONEY +SELECT SQRT(CAST(144.00 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +float +12.0 +~~END~~ + +SELECT SQRT(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT SQRT(CAST(12.25 AS MONEY)) AS result; -- Decimal MONEY +GO +~~START~~ +float +3.5 +~~END~~ + +SELECT SQRT(CAST(-144.00 AS MONEY)) AS result; -- Negative MONEY (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: cannot take square root of a negative number)~~ + +SELECT SQRT(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT SQRT(CAST(2.00 AS MONEY)) AS result; -- Irrational result +GO +~~START~~ +float +1.4142135623730951 +~~END~~ + +SELECT SQRT(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +float +3.0370004999760497E7 +~~END~~ + +SELECT SQRT(CAST(0.0001 AS MONEY)) AS result; -- Small positive value +GO +~~START~~ +float +0.01 +~~END~~ + + +-- SQRT tests for SMALLMONEY +SELECT SQRT(CAST(144.00 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +float +12.0 +~~END~~ + +SELECT SQRT(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT SQRT(CAST(12.25 AS SMALLMONEY)) AS result; -- Decimal SMALLMONEY +GO +~~START~~ +float +3.5 +~~END~~ + +SELECT SQRT(CAST(-144.00 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: cannot take square root of a negative number)~~ + +SELECT SQRT(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT SQRT(CAST(2.00 AS SMALLMONEY)) AS result; -- Irrational result +GO +~~START~~ +float +1.4142135623730951 +~~END~~ + +SELECT SQRT(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +float +463.4095000105199 +~~END~~ + +SELECT SQRT(CAST(0.0001 AS SMALLMONEY)) AS result; -- Small positive value +GO +~~START~~ +float +0.01 +~~END~~ + + +-- LOG tests for MONEY +SELECT LOG(CAST(100.00 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +float +4.605170185988092 +~~END~~ + +SELECT LOG(CAST(0.5 AS MONEY)) AS result; -- MONEY between 0 and 1 +GO +~~START~~ +float +-0.6931471805599453 +~~END~~ + +SELECT LOG(CAST(0 AS MONEY)) AS result; -- Zero MONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: cannot take logarithm of zero)~~ + +SELECT LOG(CAST(-100.00 AS MONEY)) AS result; -- Negative MONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: cannot take logarithm of a negative number)~~ + +SELECT LOG(CAST(1.00 AS MONEY)) AS result; -- LOG of 1 (should be 0) +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT LOG(CAST(2.718281828459045 AS MONEY)) AS result; -- LOG of e (should be 1) +GO +~~START~~ +float +1.0000066849139877 +~~END~~ + +SELECT LOG(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT LOG(CAST(0.0001 AS MONEY)) AS result; -- Very small positive number +GO +~~START~~ +float +-9.210340371976182 +~~END~~ + +SELECT LOG(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +float +34.45793200330037 +~~END~~ + + +-- LOG tests for SMALLMONEY +SELECT LOG(CAST(100.00 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +float +4.605170185988092 +~~END~~ + +SELECT LOG(CAST(0.5 AS SMALLMONEY)) AS result; -- SMALLMONEY between 0 and 1 +GO +~~START~~ +float +-0.6931471805599453 +~~END~~ + +SELECT LOG(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: cannot take logarithm of zero)~~ + +SELECT LOG(CAST(-100.00 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: cannot take logarithm of a negative number)~~ + +SELECT LOG(CAST(1.00 AS SMALLMONEY)) AS result; -- LOG of 1 (should be 0) +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT LOG(CAST(2.718281828459045 AS SMALLMONEY)) AS result; -- LOG of e (should be 1) +GO +~~START~~ +float +1.0000066849139877 +~~END~~ + +SELECT LOG(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT LOG(CAST(0.0001 AS SMALLMONEY)) AS result; -- Very small positive number +GO +~~START~~ +float +-9.210340371976182 +~~END~~ + +SELECT LOG(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +float +12.27722222491646 +~~END~~ + + +-- LOG10 tests for MONEY +SELECT LOG10(CAST(100.00 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +float +2.0 +~~END~~ + +SELECT LOG10(CAST(0.5 AS MONEY)) AS result; -- MONEY between 0 and 1 +GO +~~START~~ +float +-0.3010299956639812 +~~END~~ + +SELECT LOG10(CAST(0 AS MONEY)) AS result; -- Zero MONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: cannot take logarithm of zero)~~ + +SELECT LOG10(CAST(-100.00 AS MONEY)) AS result; -- Negative MONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: cannot take logarithm of a negative number)~~ + +SELECT LOG10(CAST(1.00 AS MONEY)) AS result; -- LOG10 of 1 (should be 0) +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT LOG10(CAST(10.00 AS MONEY)) AS result; -- LOG10 of 10 (should be 1) +GO +~~START~~ +float +1.0 +~~END~~ + +SELECT LOG10(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT LOG10(CAST(0.0001 AS MONEY)) AS result; -- Very small positive number +GO +~~START~~ +float +-4.0 +~~END~~ + +SELECT LOG10(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +float +14.964889726830815 +~~END~~ + + +-- LOG10 tests for SMALLMONEY +SELECT LOG10(CAST(100.00 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +float +2.0 +~~END~~ + +SELECT LOG10(CAST(0.5 AS SMALLMONEY)) AS result; -- SMALLMONEY between 0 and 1 +GO +~~START~~ +float +-0.3010299956639812 +~~END~~ + +SELECT LOG10(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: cannot take logarithm of zero)~~ + +SELECT LOG10(CAST(-100.00 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: cannot take logarithm of a negative number)~~ + +SELECT LOG10(CAST(1.00 AS SMALLMONEY)) AS result; -- LOG10 of 1 (should be 0) +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT LOG10(CAST(10.00 AS SMALLMONEY)) AS result; -- LOG10 of 10 (should be 1) +GO +~~START~~ +float +1.0 +~~END~~ + +SELECT LOG10(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT LOG10(CAST(0.0001 AS SMALLMONEY)) AS result; -- Very small positive number +GO +~~START~~ +float +-4.0 +~~END~~ + +SELECT LOG10(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +float +5.331929865381183 +~~END~~ + + +-- EXP tests for MONEY +SELECT EXP(CAST(1.00 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +float +2.718281828459045 +~~END~~ + +SELECT EXP(CAST(-1.00 AS MONEY)) AS result; -- Negative MONEY +GO +~~START~~ +float +0.36787944117144233 +~~END~~ + +SELECT EXP(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +~~START~~ +float +1.0 +~~END~~ + +SELECT TRY_CAST(EXP(CAST(1000.00 AS MONEY)) AS FLOAT) AS result; -- Large value causing overflow +GO +~~START~~ +float +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value out of range: overflow)~~ + +SELECT EXP(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT EXP(CAST(0.5 AS MONEY)) AS result; -- Fractional value +GO +~~START~~ +float +1.6487212707001282 +~~END~~ + +SELECT EXP(CAST(-0.5 AS MONEY)) AS result; -- Negative fractional value +GO +~~START~~ +float +0.6065306597126334 +~~END~~ + +SELECT EXP(CAST(10.00 AS MONEY)) AS result; -- Larger positive value +GO +~~START~~ +float +22026.465794806718 +~~END~~ + +SELECT EXP(CAST(-10.00 AS MONEY)) AS result; -- Larger negative value +GO +~~START~~ +float +4.5399929762484854E-5 +~~END~~ + + +-- EXP tests for SMALLMONEY +SELECT EXP(CAST(1.00 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +float +2.718281828459045 +~~END~~ + +SELECT EXP(CAST(-1.00 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO +~~START~~ +float +0.36787944117144233 +~~END~~ + +SELECT EXP(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +~~START~~ +float +1.0 +~~END~~ + +SELECT TRY_CAST(EXP(CAST(1000.00 AS SMALLMONEY)) AS FLOAT) AS result; -- Large value causing overflow +GO +~~START~~ +float +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value out of range: overflow)~~ + +SELECT EXP(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT EXP(CAST(0.5 AS SMALLMONEY)) AS result; -- Fractional value +GO +~~START~~ +float +1.6487212707001282 +~~END~~ + +SELECT EXP(CAST(-0.5 AS SMALLMONEY)) AS result; -- Negative fractional value +GO +~~START~~ +float +0.6065306597126334 +~~END~~ + +SELECT EXP(CAST(10.00 AS SMALLMONEY)) AS result; -- Larger positive value +GO +~~START~~ +float +22026.465794806718 +~~END~~ + +SELECT EXP(CAST(-10.00 AS SMALLMONEY)) AS result; -- Larger negative value +GO +~~START~~ +float +4.5399929762484854E-5 +~~END~~ + + +-- SIN tests for MONEY +SELECT SIN(CAST(1.0 AS MONEY)) AS result; -- MONEY +GO +~~START~~ +float +0.8414709848078965 +~~END~~ + +SELECT SIN(CAST(0 AS MONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT SIN(CAST(PI() AS MONEY)) AS result; -- PI +GO +~~START~~ +float +-7.346410206643587E-6 +~~END~~ + +SELECT SIN(CAST(PI()/2 AS MONEY)) AS result; -- PI/2 (90 degrees) +GO +~~START~~ +float +0.9999999999932537 +~~END~~ + +SELECT SIN(CAST(PI()/6 AS MONEY)) AS result; -- PI/6 (30 degrees) +GO +~~START~~ +float +0.5000010603626028 +~~END~~ + +SELECT SIN(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT SIN(CAST(-PI()/2 AS MONEY)) AS result; -- -PI/2 (-90 degrees) +GO +~~START~~ +float +-0.9999999999932537 +~~END~~ + +SELECT SIN(CAST(2*PI() AS MONEY)) AS result; -- 2*PI (360 degrees) +GO +~~START~~ +float +1.469282041289069E-5 +~~END~~ + +SELECT SIN(CAST(100.00 AS MONEY)) AS result; -- Large value +GO +~~START~~ +float +-0.5063656411097588 +~~END~~ + + +-- SIN tests for SMALLMONEY +SELECT SIN(CAST(1.0 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +~~START~~ +float +0.8414709848078965 +~~END~~ + +SELECT SIN(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT SIN(CAST(PI() AS SMALLMONEY)) AS result; -- PI +GO +~~START~~ +float +-7.346410206643587E-6 +~~END~~ + +SELECT SIN(CAST(PI()/2 AS SMALLMONEY)) AS result; -- PI/2 (90 degrees) +GO +~~START~~ +float +0.9999999999932537 +~~END~~ + +SELECT SIN(CAST(PI()/6 AS SMALLMONEY)) AS result; -- PI/6 (30 degrees) +GO +~~START~~ +float +0.5000010603626028 +~~END~~ + +SELECT SIN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT SIN(CAST(-PI()/2 AS SMALLMONEY)) AS result; -- -PI/2 (-90 degrees) +GO +~~START~~ +float +-0.9999999999932537 +~~END~~ + +SELECT SIN(CAST(2*PI() AS SMALLMONEY)) AS result; -- 2*PI (360 degrees) +GO +~~START~~ +float +1.469282041289069E-5 +~~END~~ + +SELECT SIN(CAST(100.00 AS SMALLMONEY)) AS result; -- Large value +GO +~~START~~ +float +-0.5063656411097588 +~~END~~ + + +-- COS tests for MONEY +SELECT COS(CAST(1.0 AS MONEY)) AS result; -- MONEY +GO +~~START~~ +float +0.5403023058681398 +~~END~~ + +SELECT COS(CAST(0 AS MONEY)) AS result; -- Zero +GO +~~START~~ +float +1.0 +~~END~~ + +SELECT COS(CAST(PI() AS MONEY)) AS result; -- PI +GO +~~START~~ +float +-0.9999999999730151 +~~END~~ + +SELECT COS(CAST(PI()/2 AS MONEY)) AS result; -- PI/2 (90 degrees) +GO +~~START~~ +float +-3.673205103346574E-6 +~~END~~ + +SELECT COS(CAST(PI()/3 AS MONEY)) AS result; -- PI/3 (60 degrees) +GO +~~START~~ +float +0.4999978792725457 +~~END~~ + +SELECT COS(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT COS(CAST(-PI() AS MONEY)) AS result; -- -PI (-180 degrees) +GO +~~START~~ +float +-0.9999999999730151 +~~END~~ + +SELECT COS(CAST(2*PI() AS MONEY)) AS result; -- 2*PI (360 degrees) +GO +~~START~~ +float +0.9999999998920606 +~~END~~ + +SELECT COS(CAST(100.00 AS MONEY)) AS result; -- Large value +GO +~~START~~ +float +0.8623188722876839 +~~END~~ + + +-- COS tests for SMALLMONEY +SELECT COS(CAST(1.0 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +~~START~~ +float +0.5403023058681398 +~~END~~ + +SELECT COS(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +~~START~~ +float +1.0 +~~END~~ + +SELECT COS(CAST(PI() AS SMALLMONEY)) AS result; -- PI +GO +~~START~~ +float +-0.9999999999730151 +~~END~~ + +SELECT COS(CAST(PI()/2 AS SMALLMONEY)) AS result; -- PI/2 (90 degrees) +GO +~~START~~ +float +-3.673205103346574E-6 +~~END~~ + +SELECT COS(CAST(PI()/3 AS SMALLMONEY)) AS result; -- PI/3 (60 degrees) +GO +~~START~~ +float +0.4999978792725457 +~~END~~ + +SELECT COS(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT COS(CAST(-PI() AS SMALLMONEY)) AS result; -- -PI (-180 degrees) +GO +~~START~~ +float +-0.9999999999730151 +~~END~~ + +SELECT COS(CAST(2*PI() AS SMALLMONEY)) AS result; -- 2*PI (360 degrees) +GO +~~START~~ +float +0.9999999998920606 +~~END~~ + +SELECT COS(CAST(100.00 AS SMALLMONEY)) AS result; -- Large value +GO +~~START~~ +float +0.8623188722876839 +~~END~~ + + +-- TAN tests for MONEY +SELECT TAN(CAST(1.0 AS MONEY)) AS result; -- MONEY +GO +~~START~~ +float +1.5574077246549023 +~~END~~ + +SELECT TAN(CAST(0 AS MONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT TAN(CAST(PI()/4 AS MONEY)) AS result; -- PI/4 (45 degrees) +GO +~~START~~ +float +1.0000036732118496 +~~END~~ + +SELECT TAN(CAST(PI() AS MONEY)) AS result; -- PI (180 degrees) +GO +~~START~~ +float +7.346410206841829E-6 +~~END~~ + +SELECT TAN(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT TAN(CAST(-PI()/4 AS MONEY)) AS result; -- -PI/4 (-45 degrees) +GO +~~START~~ +float +-1.0000036732118496 +~~END~~ + +SELECT TAN(CAST(PI()/2 - 0.000001 AS MONEY)) AS result; -- Near PI/2 (near 90 degrees) +GO +~~START~~ +float +-272241.80840927624 +~~END~~ + +SELECT TAN(CAST(3*PI()/2 - 0.000001 AS MONEY)) AS result; -- Near 3*PI/2 (near 270 degrees) +GO +~~START~~ +float +-90747.26946832224 +~~END~~ + + +-- TAN tests for SMALLMONEY +SELECT TAN(CAST(1.0 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +~~START~~ +float +1.5574077246549023 +~~END~~ + +SELECT TAN(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT TAN(CAST(PI()/4 AS SMALLMONEY)) AS result; -- PI/4 (45 degrees) +GO +~~START~~ +float +1.0000036732118496 +~~END~~ + +SELECT TAN(CAST(PI() AS SMALLMONEY)) AS result; -- PI (180 degrees) +GO +~~START~~ +float +7.346410206841829E-6 +~~END~~ + +SELECT TAN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT TAN(CAST(-PI()/4 AS SMALLMONEY)) AS result; -- -PI/4 (-45 degrees) +GO +~~START~~ +float +-1.0000036732118496 +~~END~~ + +SELECT TAN(CAST(PI()/2 - 0.000001 AS SMALLMONEY)) AS result; -- Near PI/2 (near 90 degrees) +GO +~~START~~ +float +-272241.80840927624 +~~END~~ + +SELECT TAN(CAST(3*PI()/2 - 0.000001 AS SMALLMONEY)) AS result; -- Near 3*PI/2 (near 270 degrees) +GO +~~START~~ +float +-90747.26946832224 +~~END~~ + + +-- ASIN tests for MONEY +SELECT ASIN(CAST(0.5 AS MONEY)) AS result; -- MONEY +GO +~~START~~ +float +0.5235987755982989 +~~END~~ + +SELECT ASIN(CAST(0 AS MONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT ASIN(CAST(1 AS MONEY)) AS result; -- One +GO +~~START~~ +float +1.5707963267948966 +~~END~~ + +SELECT ASIN(CAST(-1 AS MONEY)) AS result; -- Negative one +GO +~~START~~ +float +-1.5707963267948966 +~~END~~ + +SELECT ASIN(CAST(2 AS MONEY)) AS result; -- Out of range (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ASIN(CAST(-2 AS MONEY)) AS result; -- Out of range negative (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ASIN(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT ASIN(CAST(0.7071067811865475 AS MONEY)) AS result; -- sin(PI/4) +GO +~~START~~ +float +0.7853885733974476 +~~END~~ + +SELECT ASIN(CAST(0.8660254037844386 AS MONEY)) AS result; -- sin(PI/3) +GO +~~START~~ +float +1.0471467458630677 +~~END~~ + + +-- ASIN tests for SMALLMONEY +SELECT ASIN(CAST(0.5 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +~~START~~ +float +0.5235987755982989 +~~END~~ + +SELECT ASIN(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT ASIN(CAST(1 AS SMALLMONEY)) AS result; -- One +GO +~~START~~ +float +1.5707963267948966 +~~END~~ + +SELECT ASIN(CAST(-1 AS SMALLMONEY)) AS result; -- Negative one +GO +~~START~~ +float +-1.5707963267948966 +~~END~~ + +SELECT ASIN(CAST(2 AS SMALLMONEY)) AS result; -- Out of range (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ASIN(CAST(-2 AS SMALLMONEY)) AS result; -- Out of range negative (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ASIN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT ASIN(CAST(0.7071067811865475 AS SMALLMONEY)) AS result; -- sin(PI/4) +GO +~~START~~ +float +0.7853885733974476 +~~END~~ + +SELECT ASIN(CAST(0.8660254037844386 AS SMALLMONEY)) AS result; -- sin(PI/3) +GO +~~START~~ +float +1.0471467458630677 +~~END~~ + + +-- ACOS tests for MONEY +SELECT ACOS(CAST(0.5 AS MONEY)) AS result; -- MONEY +GO +~~START~~ +float +1.0471975511965979 +~~END~~ + +SELECT ACOS(CAST(0 AS MONEY)) AS result; -- Zero +GO +~~START~~ +float +1.5707963267948966 +~~END~~ + +SELECT ACOS(CAST(1 AS MONEY)) AS result; -- One +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT ACOS(CAST(-1 AS MONEY)) AS result; -- Negative one +GO +~~START~~ +float +3.141592653589793 +~~END~~ + +SELECT ACOS(CAST(2 AS MONEY)) AS result; -- Out of range (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ACOS(CAST(-2 AS MONEY)) AS result; -- Out of range negative (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ACOS(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT ACOS(CAST(0.7071067811865475 AS MONEY)) AS result; -- cos(PI/4) +GO +~~START~~ +float +0.785407753397449 +~~END~~ + +SELECT ACOS(CAST(0.5 AS MONEY)) AS result; -- cos(PI/3) +GO +~~START~~ +float +1.0471975511965979 +~~END~~ + + +-- ACOS tests for SMALLMONEY +SELECT ACOS(CAST(0.5 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +~~START~~ +float +1.0471975511965979 +~~END~~ + +SELECT ACOS(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +~~START~~ +float +1.5707963267948966 +~~END~~ + +SELECT ACOS(CAST(1 AS SMALLMONEY)) AS result; -- One +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT ACOS(CAST(-1 AS SMALLMONEY)) AS result; -- Negative one +GO +~~START~~ +float +3.141592653589793 +~~END~~ + +SELECT ACOS(CAST(2 AS SMALLMONEY)) AS result; -- Out of range (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ACOS(CAST(-2 AS SMALLMONEY)) AS result; -- Out of range negative (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ACOS(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT ACOS(CAST(0.7071067811865475 AS SMALLMONEY)) AS result; -- cos(PI/4) +GO +~~START~~ +float +0.785407753397449 +~~END~~ + +SELECT ACOS(CAST(0.5 AS SMALLMONEY)) AS result; -- cos(PI/3) +GO +~~START~~ +float +1.0471975511965979 +~~END~~ + + +-- ATAN tests for MONEY +SELECT ATAN(CAST(1.0 AS MONEY)) AS result; -- MONEY +GO +~~START~~ +float +0.7853981633974483 +~~END~~ + +SELECT ATAN(CAST(0 AS MONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT ATAN(CAST(1000000 AS MONEY)) AS result; -- Large value +GO +~~START~~ +float +1.5707953267948966 +~~END~~ + +SELECT ATAN(CAST(-1.0 AS MONEY)) AS result; -- Negative value +GO +~~START~~ +float +-0.7853981633974483 +~~END~~ + +SELECT ATAN(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT ATAN(CAST(1.7320508075688772 AS MONEY)) AS result; -- tan(PI/3) +GO +~~START~~ +float +1.047209849042422 +~~END~~ + +SELECT ATAN(CAST(-1.7320508075688772 AS MONEY)) AS result; -- tan(-PI/3) +GO +~~START~~ +float +-1.047209849042422 +~~END~~ + +SELECT ATAN(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value (approaches PI/2) +GO +~~START~~ +float +1.5707963267948954 +~~END~~ + +SELECT ATAN(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value (approaches -PI/2) +GO +~~START~~ +float +-1.5707963267948954 +~~END~~ + + +-- ATAN tests for SMALLMONEY +SELECT ATAN(CAST(1.0 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +~~START~~ +float +0.7853981633974483 +~~END~~ + +SELECT ATAN(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT ATAN(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Large value +GO +~~START~~ +float +1.5707916701820215 +~~END~~ + +SELECT ATAN(CAST(-1.0 AS SMALLMONEY)) AS result; -- Negative value +GO +~~START~~ +float +-0.7853981633974483 +~~END~~ + +SELECT ATAN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT ATAN(CAST(1.7320508075688772 AS SMALLMONEY)) AS result; -- tan(PI/3) +GO +~~START~~ +float +1.047209849042422 +~~END~~ + +SELECT ATAN(CAST(-1.7320508075688772 AS SMALLMONEY)) AS result; -- tan(-PI/3) +GO +~~START~~ +float +-1.047209849042422 +~~END~~ + +SELECT ATAN(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value (approaches PI/2) +GO +~~START~~ +float +1.5707916701820215 +~~END~~ + +SELECT ATAN(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value (approaches -PI/2) +GO +~~START~~ +float +-1.5707916701820235 +~~END~~ + + +------------------------------------------------------------------------ +---- 4. Comparison Operators +------------------------------------------------------------------------ +-- Equality (=) operator tests +-- MONEY = MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = MONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) = CAST(922337203685477.5807 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MAX MONEY = MAX MONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) = CAST(-922337203685477.5808 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MIN MONEY = MIN MONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(0.0000 AS MONEY) = CAST(0.0000 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [ZERO MONEY = ZERO MONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(-123.45 AS MONEY) = CAST(-123.45 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [NEG MONEY = NEG MONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + + +-- SMALLMONEY = SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) = CAST(123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY = SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) = CAST(214748.3647 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MAX SMALLMONEY = MAX SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) = CAST(-214748.3648 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MIN SMALLMONEY = MIN SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(0.0000 AS SMALLMONEY) = CAST(0.0000 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [ZERO SMALLMONEY = ZERO SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(-123.45 AS SMALLMONEY) = CAST(-123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [NEG SMALLMONEY = NEG SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + + + + +-- Cross money-type comparisons +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + + +-- Money types with other numeric types +SELECT CASE WHEN CAST(123.45 AS MONEY) = 123.45 THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = Literal]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS FLOAT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = FLOAT]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS REAL) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = REAL]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS NUMERIC(5,2)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = NUMERIC]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123 AS INT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = INT]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123 AS BIGINT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = BIGINT]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123 AS SMALLINT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = SMALLINT]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123 AS TINYINT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = TINYINT]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + + +-- Money types with string types +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST('123.45' AS VARCHAR(20)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = VARCHAR]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST('123.45' AS CHAR(20)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = CHAR]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST('123.45' AS NVARCHAR(20)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = NVARCHAR]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST('123.45' AS NCHAR(20)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = NCHAR]; +GO +~~START~~ +varchar +Equal +~~END~~ + + +-- Money types with SQL_VARIANT +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(CAST(123.45 AS MONEY) AS SQL_VARIANT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = SQL_VARIANT]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) = CAST(CAST(123.45 AS SMALLMONEY) AS SQL_VARIANT) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY = SQL_VARIANT]; +GO +~~START~~ +varchar +Equal +~~END~~ + + +-- Inequality (<>) operator tests +-- MONEY <> MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) <> CAST(123.46 AS MONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MONEY <> MONEY]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) <> CAST(922337203685477.5806 AS MONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MAX MONEY <> NEAR MAX]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) <> CAST(-922337203685477.5807 AS MONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MIN MONEY <> NEAR MIN]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + + +-- SMALLMONEY <> SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) <> CAST(123.46 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [SMALLMONEY <> SMALLMONEY]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) <> CAST(214748.3646 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MAX SMALLMONEY <> NEAR MAX]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) <> CAST(-214748.3647 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MIN SMALLMONEY <> NEAR MIN]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + + +-- Cross money-type inequalities +SELECT CASE WHEN CAST(123.45 AS MONEY) <> CAST(123.46 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MONEY <> SMALLMONEY]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + + + +-- Greater than (>) operator tests +-- MONEY > MONEY +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS MONEY) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > MONEY]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) > CAST(922337203685477.5806 AS MONEY) THEN 'Greater' ELSE 'Not Greater' END AS [MAX MONEY > NEAR MAX]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(-922337203685477.5807 AS MONEY) > CAST(-922337203685477.5808 AS MONEY) THEN 'Greater' ELSE 'Not Greater' END AS [NEAR MIN > MIN MONEY]; +GO +~~START~~ +varchar +Greater +~~END~~ + + +-- SMALLMONEY > SMALLMONEY +SELECT CASE WHEN CAST(123.46 AS SMALLMONEY) > CAST(123.45 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [SMALLMONEY > SMALLMONEY]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) > CAST(214748.3646 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [MAX SMALLMONEY > NEAR MAX]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(-214748.3647 AS SMALLMONEY) > CAST(-214748.3648 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [NEAR MIN > MIN SMALLMONEY]; +GO +~~START~~ +varchar +Greater +~~END~~ + + +-- Cross money-type greater than +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > SMALLMONEY]; +GO +~~START~~ +varchar +Greater +~~END~~ + + +-- Money types greater than other numeric types +SELECT CASE WHEN CAST(123.46 AS MONEY) > 123.45 THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > Literal]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS FLOAT) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > FLOAT]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS REAL) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > REAL]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS NUMERIC(5,2)) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > NUMERIC]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123 AS INT) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > INT]; +GO +~~START~~ +varchar +Greater +~~END~~ + + +-- Less than (<) operator tests +SELECT 'Less Than (<) Operator Tests' AS test_description; +GO +~~START~~ +varchar +Less Than (<) Operator Tests +~~END~~ + + +-- MONEY < MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS MONEY) THEN 'Less' ELSE 'Not Less' END AS [MONEY < MONEY]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5806 AS MONEY) < CAST(922337203685477.5807 AS MONEY) THEN 'Less' ELSE 'Not Less' END AS [NEAR MAX < MAX MONEY]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) < CAST(-922337203685477.5807 AS MONEY) THEN 'Less' ELSE 'Not Less' END AS [MIN MONEY < NEAR MIN]; +GO +~~START~~ +varchar +Less +~~END~~ + + +-- SMALLMONEY < SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) < CAST(123.46 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [SMALLMONEY < SMALLMONEY]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(214748.3646 AS SMALLMONEY) < CAST(214748.3647 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [NEAR MAX < MAX SMALLMONEY]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) < CAST(-214748.3647 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [MIN SMALLMONEY < NEAR MIN]; +GO +~~START~~ +varchar +Less +~~END~~ + + +-- Cross money-type less than +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [MONEY < SMALLMONEY]; +GO +~~START~~ +varchar +Less +~~END~~ + + +-- Money types less than other numeric types +SELECT CASE WHEN CAST(123.45 AS MONEY) < 123.46 THEN 'Less' ELSE 'Not Less' END AS [MONEY < Literal]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS FLOAT) THEN 'Less' ELSE 'Not Less' END AS [MONEY < FLOAT]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS REAL) THEN 'Less' ELSE 'Not Less' END AS [MONEY < REAL]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS NUMERIC(5,2)) THEN 'Less' ELSE 'Not Less' END AS [MONEY < NUMERIC]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(124 AS INT) THEN 'Less' ELSE 'Not Less' END AS [MONEY < INT]; +GO +~~START~~ +varchar +Less +~~END~~ + + +-- Greater than or equal to (>=) operator tests +-- MONEY >= MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) >= CAST(123.45 AS MONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MONEY >= MONEY (Equal)]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS MONEY) >= CAST(123.45 AS MONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MONEY >= MONEY (Greater)]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) >= CAST(922337203685477.5807 AS MONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MAX MONEY >= MAX MONEY]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + + +-- SMALLMONEY >= SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) >= CAST(123.45 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [SMALLMONEY >= SMALLMONEY (Equal)]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS SMALLMONEY) >= CAST(123.45 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [SMALLMONEY >= SMALLMONEY (Greater)]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) >= CAST(214748.3647 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MAX SMALLMONEY >= MAX SMALLMONEY]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + + +-- Cross money-type greater than or equal +SELECT CASE WHEN CAST(123.45 AS MONEY) >= CAST(123.45 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MONEY >= SMALLMONEY (Equal)]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS MONEY) >= CAST(123.45 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MONEY >= SMALLMONEY (Greater)]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + + +-- Less than or equal to (<=) operator tests +-- MONEY <= MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) <= CAST(123.45 AS MONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MONEY <= MONEY (Equal)]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) <= CAST(123.46 AS MONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MONEY <= MONEY (Less)]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) <= CAST(922337203685477.5807 AS MONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MAX MONEY <= MAX MONEY]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) <= CAST(-922337203685477.5808 AS MONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MIN MONEY <= MIN MONEY]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + + +-- SMALLMONEY <= SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) <= CAST(123.45 AS SMALLMONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [SMALLMONEY <= SMALLMONEY (Equal)]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) <= CAST(123.46 AS SMALLMONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [SMALLMONEY <= SMALLMONEY (Less)]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) <= CAST(214748.3647 AS SMALLMONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MAX SMALLMONEY <= MAX SMALLMONEY]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) <= CAST(-214748.3648 AS SMALLMONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MIN SMALLMONEY <= MIN SMALLMONEY]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + + +-- BETWEEN operator tests +-- MONEY BETWEEN +SELECT CASE WHEN CAST(123.45 AS MONEY) BETWEEN CAST(123.44 AS MONEY) AND CAST(123.46 AS MONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [MONEY BETWEEN]; +GO +~~START~~ +varchar +In Range +~~END~~ + +SELECT CASE WHEN CAST(0.00 AS MONEY) BETWEEN CAST(-1.00 AS MONEY) AND CAST(1.00 AS MONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [MONEY BETWEEN (Zero)]; +GO +~~START~~ +varchar +In Range +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) BETWEEN CAST(922337203685477.5806 AS MONEY) AND CAST(922337203685477.5807 AS MONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [MONEY BETWEEN (Max)]; +GO +~~START~~ +varchar +In Range +~~END~~ + + +-- SMALLMONEY BETWEEN +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) BETWEEN CAST(123.44 AS SMALLMONEY) AND CAST(123.46 AS SMALLMONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [SMALLMONEY BETWEEN]; +GO +~~START~~ +varchar +In Range +~~END~~ + +SELECT CASE WHEN CAST(0.00 AS SMALLMONEY) BETWEEN CAST(-1.00 AS SMALLMONEY) AND CAST(1.00 AS SMALLMONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [SMALLMONEY BETWEEN (Zero)]; +GO +~~START~~ +varchar +In Range +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) BETWEEN CAST(214748.3646 AS SMALLMONEY) AND CAST(214748.3647 AS SMALLMONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [SMALLMONEY BETWEEN (Max)]; +GO +~~START~~ +varchar +In Range +~~END~~ + + +-- Cross type BETWEEN +SELECT CASE WHEN CAST(123.45 AS MONEY) BETWEEN CAST(123.44 AS SMALLMONEY) AND CAST(123.46 AS SMALLMONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [MONEY BETWEEN SMALLMONEY]; +GO +~~START~~ +varchar +In Range +~~END~~ + + +-- IN operator tests +-- MONEY IN +SELECT CASE WHEN CAST(123.45 AS MONEY) IN (CAST(123.44 AS MONEY), CAST(123.45 AS MONEY), CAST(123.46 AS MONEY)) + THEN 'In List' ELSE 'Not In List' END AS [MONEY IN]; +GO +~~START~~ +varchar +In List +~~END~~ + +SELECT CASE WHEN CAST(0.00 AS MONEY) IN (CAST(-1.00 AS MONEY), CAST(0.00 AS MONEY), CAST(1.00 AS MONEY)) + THEN 'In List' ELSE 'Not In List' END AS [MONEY IN (Zero)]; +GO +~~START~~ +varchar +In List +~~END~~ + + +-- SMALLMONEY IN +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) IN (CAST(123.44 AS SMALLMONEY), CAST(123.45 AS SMALLMONEY), CAST(123.46 AS SMALLMONEY)) + THEN 'In List' ELSE 'Not In List' END AS [SMALLMONEY IN]; +GO +~~START~~ +varchar +In List +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) IN (CAST(214748.3646 AS SMALLMONEY), CAST(214748.3647 AS SMALLMONEY)) + THEN 'In List' ELSE 'Not In List' END AS [SMALLMONEY IN (Max)]; +GO +~~START~~ +varchar +In List +~~END~~ + + +-- Cross type IN +SELECT CASE WHEN CAST(123.45 AS MONEY) IN (CAST(123.44 AS SMALLMONEY), CAST(123.45 AS SMALLMONEY), CAST(123.46 AS SMALLMONEY)) + THEN 'In List' ELSE 'Not In List' END AS [MONEY IN SMALLMONEY]; +GO +~~START~~ +varchar +In List +~~END~~ + + +-- NULL comparison tests +-- MONEY NULL comparisons +SELECT CASE WHEN CAST(NULL AS MONEY) = CAST(123.45 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [NULL MONEY = MONEY]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(NULL AS MONEY) <> CAST(123.45 AS MONEY) THEN 'Not Equal' ELSE 'Equal' END AS [NULL MONEY <> MONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(NULL AS MONEY) > CAST(123.45 AS MONEY) THEN 'Greater' ELSE 'Not Greater' END AS [NULL MONEY > MONEY]; +GO +~~START~~ +varchar +Not Greater +~~END~~ + +SELECT CASE WHEN CAST(NULL AS MONEY) < CAST(123.45 AS MONEY) THEN 'Less' ELSE 'Not Less' END AS [NULL MONEY < MONEY]; +GO +~~START~~ +varchar +Not Less +~~END~~ + +SELECT CASE WHEN CAST(NULL AS MONEY) IS NULL THEN 'Is NULL' ELSE 'Is Not NULL' END AS [MONEY IS NULL]; +GO +~~START~~ +varchar +Is NULL +~~END~~ + +SELECT CASE WHEN CAST(NULL AS MONEY) IS NOT NULL THEN 'Is Not NULL' ELSE 'Is NULL' END AS [MONEY IS NOT NULL]; +GO +~~START~~ +varchar +Is NULL +~~END~~ + + +-- SMALLMONEY NULL comparisons +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) = CAST(123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [NULL SMALLMONEY = SMALLMONEY]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) <> CAST(123.45 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [NULL SMALLMONEY <> SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) > CAST(123.45 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [NULL SMALLMONEY > SMALLMONEY]; +GO +~~START~~ +varchar +Not Greater +~~END~~ + +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) < CAST(123.45 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [NULL SMALLMONEY < SMALLMONEY]; +GO +~~START~~ +varchar +Not Less +~~END~~ + +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) IS NULL THEN 'Is NULL' ELSE 'Is Not NULL' END AS [SMALLMONEY IS NULL]; +GO +~~START~~ +varchar +Is NULL +~~END~~ + +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) IS NOT NULL THEN 'Is Not NULL' ELSE 'Is NULL' END AS [SMALLMONEY IS NOT NULL]; +GO +~~START~~ +varchar +Is NULL +~~END~~ + + +-- Edge cases and special values +-- Zero comparisons +SELECT CASE WHEN CAST(0 AS MONEY) = CAST(0.0000 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY Zero = Zero]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(0 AS MONEY) = CAST(-0.0000 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY Zero = Negative Zero]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(0 AS SMALLMONEY) = CAST(0.0000 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY Zero = Zero]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(0 AS SMALLMONEY) = CAST(-0.0000 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY Zero = Negative Zero]; +GO +~~START~~ +varchar +Equal +~~END~~ + + +-- Maximum and minimum value comparisons +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) > CAST(922337203685477.5806 AS MONEY) THEN 'True' ELSE 'False' END AS [MAX MONEY > NEAR MAX]; +GO +~~START~~ +varchar +True +~~END~~ + +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) < CAST(-922337203685477.5807 AS MONEY) THEN 'True' ELSE 'False' END AS [MIN MONEY < NEAR MIN]; +GO +~~START~~ +varchar +True +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) > CAST(214748.3646 AS SMALLMONEY) THEN 'True' ELSE 'False' END AS [MAX SMALLMONEY > NEAR MAX]; +GO +~~START~~ +varchar +True +~~END~~ + +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) < CAST(-214748.3647 AS SMALLMONEY) THEN 'True' ELSE 'False' END AS [MIN SMALLMONEY < NEAR MIN]; +GO +~~START~~ +varchar +True +~~END~~ + + +-- Precision comparison tests +SELECT CASE WHEN CAST(123.4500 AS MONEY) = CAST(123.45 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY Precision Test]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.4500 AS SMALLMONEY) = CAST(123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY Precision Test]; +GO +~~START~~ +varchar +Equal +~~END~~ + + +-- Create test table +CREATE TABLE MoneyComparisonTest +( + ID INT PRIMARY KEY, + MoneyVal MONEY, + SmallMoneyVal SMALLMONEY, + MoneyNull MONEY NULL, + SmallMoneyNull SMALLMONEY NULL +); +GO + +-- Insert test data +INSERT INTO MoneyComparisonTest (ID, MoneyVal, SmallMoneyVal, MoneyNull, SmallMoneyNull) +VALUES +(1, 100.00, 100.00, NULL, NULL), +(2, 200.00, 200.00, 200.00, 200.00), +(3, -100.00, -100.00, -100.00, -100.00), +(4, 922337203685477.5807, 214748.3647, NULL, NULL), +(5, -922337203685477.5808, -214748.3648, NULL, NULL), +(6, 0.00, 0.00, 0.00, 0.00), +(7, 123.45, 123.45, 123.45, 123.45); +GO +~~ROW COUNT: 7~~ + + +-- WHERE clause tests +-- Equality tests +SELECT ID, MoneyVal FROM MoneyComparisonTest WHERE MoneyVal = CAST(100.00 AS MONEY); +GO +~~START~~ +int#!#money +1#!#100.0000 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest WHERE SmallMoneyVal = CAST(100.00 AS SMALLMONEY); +GO +~~START~~ +int#!#smallmoney +1#!#100.0000 +~~END~~ + + +-- Inequality tests +SELECT ID, MoneyVal FROM MoneyComparisonTest WHERE MoneyVal <> CAST(100.00 AS MONEY); +GO +~~START~~ +int#!#money +2#!#200.0000 +3#!#-100.0000 +4#!#922337203685477.5807 +5#!#-922337203685477.5808 +6#!#0.0000 +7#!#123.4500 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest WHERE SmallMoneyVal <> CAST(100.00 AS SMALLMONEY); +GO +~~START~~ +int#!#smallmoney +2#!#200.0000 +3#!#-100.0000 +4#!#214748.3647 +5#!#-214748.3648 +6#!#0.0000 +7#!#123.4500 +~~END~~ + + +-- Greater than tests +SELECT ID, MoneyVal FROM MoneyComparisonTest WHERE MoneyVal > CAST(100.00 AS MONEY); +GO +~~START~~ +int#!#money +2#!#200.0000 +4#!#922337203685477.5807 +7#!#123.4500 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest WHERE SmallMoneyVal > CAST(100.00 AS SMALLMONEY); +GO +~~START~~ +int#!#smallmoney +2#!#200.0000 +4#!#214748.3647 +7#!#123.4500 +~~END~~ + + +-- Less than tests +SELECT ID, MoneyVal FROM MoneyComparisonTest WHERE MoneyVal < CAST(100.00 AS MONEY); +GO +~~START~~ +int#!#money +3#!#-100.0000 +5#!#-922337203685477.5808 +6#!#0.0000 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest WHERE SmallMoneyVal < CAST(100.00 AS SMALLMONEY); +GO +~~START~~ +int#!#smallmoney +3#!#-100.0000 +5#!#-214748.3648 +6#!#0.0000 +~~END~~ + + +-- BETWEEN tests +SELECT ID, MoneyVal FROM MoneyComparisonTest +WHERE MoneyVal BETWEEN CAST(100.00 AS MONEY) AND CAST(200.00 AS MONEY); +GO +~~START~~ +int#!#money +1#!#100.0000 +2#!#200.0000 +7#!#123.4500 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest +WHERE SmallMoneyVal BETWEEN CAST(100.00 AS SMALLMONEY) AND CAST(200.00 AS SMALLMONEY); +GO +~~START~~ +int#!#smallmoney +1#!#100.0000 +2#!#200.0000 +7#!#123.4500 +~~END~~ + + +-- IN tests +SELECT ID, MoneyVal FROM MoneyComparisonTest +WHERE MoneyVal IN (CAST(100.00 AS MONEY), CAST(200.00 AS MONEY)); +GO +~~START~~ +int#!#money +1#!#100.0000 +2#!#200.0000 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest +WHERE SmallMoneyVal IN (CAST(100.00 AS SMALLMONEY), CAST(200.00 AS SMALLMONEY)); +GO +~~START~~ +int#!#smallmoney +1#!#100.0000 +2#!#200.0000 +~~END~~ + + +-- NULL tests +SELECT ID, MoneyNull FROM MoneyComparisonTest WHERE MoneyNull IS NULL; +GO +~~START~~ +int#!#money +1#!# +4#!# +5#!# +~~END~~ + +SELECT ID, SmallMoneyNull FROM MoneyComparisonTest WHERE SmallMoneyNull IS NULL; +GO +~~START~~ +int#!#smallmoney +1#!# +4#!# +5#!# +~~END~~ + +SELECT ID, MoneyNull FROM MoneyComparisonTest WHERE MoneyNull IS NOT NULL; +GO +~~START~~ +int#!#money +2#!#200.0000 +3#!#-100.0000 +6#!#0.0000 +7#!#123.4500 +~~END~~ + +SELECT ID, SmallMoneyNull FROM MoneyComparisonTest WHERE SmallMoneyNull IS NOT NULL; +GO +~~START~~ +int#!#smallmoney +2#!#200.0000 +3#!#-100.0000 +6#!#0.0000 +7#!#123.4500 +~~END~~ + + +-- JOIN tests +-- Create second test table +CREATE TABLE MoneyComparisonTest2 +( + ID INT PRIMARY KEY, + MoneyVal MONEY, + SmallMoneyVal SMALLMONEY +); +GO + +-- Insert test data +INSERT INTO MoneyComparisonTest2 (ID, MoneyVal, SmallMoneyVal) +VALUES +(1, 100.00, 100.00), +(2, 200.00, 200.00), +(3, 300.00, 300.00); +GO +~~ROW COUNT: 3~~ + + +-- INNER JOIN tests +SELECT t1.ID, t1.MoneyVal, t2.MoneyVal AS MoneyVal2 +FROM MoneyComparisonTest t1 +INNER JOIN MoneyComparisonTest2 t2 ON t1.MoneyVal = t2.MoneyVal; +GO +~~START~~ +int#!#money#!#money +1#!#100.0000#!#100.0000 +2#!#200.0000#!#200.0000 +~~END~~ + + +SELECT t1.ID, t1.SmallMoneyVal, t2.SmallMoneyVal AS SmallMoneyVal2 +FROM MoneyComparisonTest t1 +INNER JOIN MoneyComparisonTest2 t2 ON t1.SmallMoneyVal = t2.SmallMoneyVal; +GO +~~START~~ +int#!#smallmoney#!#smallmoney +1#!#100.0000#!#100.0000 +2#!#200.0000#!#200.0000 +~~END~~ + + +-- LEFT JOIN tests +SELECT t1.ID, t1.MoneyVal, t2.MoneyVal AS MoneyVal2 +FROM MoneyComparisonTest t1 +LEFT JOIN MoneyComparisonTest2 t2 ON t1.MoneyVal = t2.MoneyVal; +GO +~~START~~ +int#!#money#!#money +5#!#-922337203685477.5808#!# +3#!#-100.0000#!# +6#!#0.0000#!# +1#!#100.0000#!#100.0000 +7#!#123.4500#!# +2#!#200.0000#!#200.0000 +4#!#922337203685477.5807#!# +~~END~~ + + +SELECT t1.ID, t1.SmallMoneyVal, t2.SmallMoneyVal AS SmallMoneyVal2 +FROM MoneyComparisonTest t1 +LEFT JOIN MoneyComparisonTest2 t2 ON t1.SmallMoneyVal = t2.SmallMoneyVal; +GO +~~START~~ +int#!#smallmoney#!#smallmoney +5#!#-214748.3648#!# +3#!#-100.0000#!# +6#!#0.0000#!# +1#!#100.0000#!#100.0000 +7#!#123.4500#!# +2#!#200.0000#!#200.0000 +4#!#214748.3647#!# +~~END~~ + + +-- ORDER BY tests +-- Basic ORDER BY +SELECT ID, MoneyVal FROM MoneyComparisonTest ORDER BY MoneyVal; +GO +~~START~~ +int#!#money +5#!#-922337203685477.5808 +3#!#-100.0000 +6#!#0.0000 +1#!#100.0000 +7#!#123.4500 +2#!#200.0000 +4#!#922337203685477.5807 +~~END~~ + +SELECT ID, MoneyVal FROM MoneyComparisonTest ORDER BY MoneyVal DESC; +GO +~~START~~ +int#!#money +4#!#922337203685477.5807 +2#!#200.0000 +7#!#123.4500 +1#!#100.0000 +6#!#0.0000 +3#!#-100.0000 +5#!#-922337203685477.5808 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest ORDER BY SmallMoneyVal; +GO +~~START~~ +int#!#smallmoney +5#!#-214748.3648 +3#!#-100.0000 +6#!#0.0000 +1#!#100.0000 +7#!#123.4500 +2#!#200.0000 +4#!#214748.3647 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest ORDER BY SmallMoneyVal DESC; +GO +~~START~~ +int#!#smallmoney +4#!#214748.3647 +2#!#200.0000 +7#!#123.4500 +1#!#100.0000 +6#!#0.0000 +3#!#-100.0000 +5#!#-214748.3648 +~~END~~ + + +-- Multiple column ORDER BY +SELECT ID, MoneyVal, SmallMoneyVal +FROM MoneyComparisonTest +ORDER BY MoneyVal, SmallMoneyVal; +GO +~~START~~ +int#!#money#!#smallmoney +5#!#-922337203685477.5808#!#-214748.3648 +3#!#-100.0000#!#-100.0000 +6#!#0.0000#!#0.0000 +1#!#100.0000#!#100.0000 +7#!#123.4500#!#123.4500 +2#!#200.0000#!#200.0000 +4#!#922337203685477.5807#!#214748.3647 +~~END~~ + + +SELECT ID, MoneyVal, SmallMoneyVal +FROM MoneyComparisonTest +ORDER BY MoneyVal DESC, SmallMoneyVal ASC; +GO +~~START~~ +int#!#money#!#smallmoney +4#!#922337203685477.5807#!#214748.3647 +2#!#200.0000#!#200.0000 +7#!#123.4500#!#123.4500 +1#!#100.0000#!#100.0000 +6#!#0.0000#!#0.0000 +3#!#-100.0000#!#-100.0000 +5#!#-922337203685477.5808#!#-214748.3648 +~~END~~ + + +-- ORDER BY with NULL values +SELECT ID, MoneyNull +FROM MoneyComparisonTest +ORDER BY MoneyNull; +GO +~~START~~ +int#!#money +4#!# +1#!# +5#!# +3#!#-100.0000 +6#!#0.0000 +7#!#123.4500 +2#!#200.0000 +~~END~~ + + +SELECT ID, SmallMoneyNull +FROM MoneyComparisonTest +ORDER BY SmallMoneyNull DESC; +GO +~~START~~ +int#!#smallmoney +2#!#200.0000 +7#!#123.4500 +6#!#0.0000 +3#!#-100.0000 +4#!# +1#!# +5#!# +~~END~~ + + +-- GROUP BY tests +-- Basic GROUP BY +SELECT MoneyVal, COUNT(*) as Count +FROM MoneyComparisonTest +GROUP BY MoneyVal; +GO +~~START~~ +money#!#int +-100.0000#!#1 +-922337203685477.5808#!#1 +123.4500#!#1 +200.0000#!#1 +0.0000#!#1 +922337203685477.5807#!#1 +100.0000#!#1 +~~END~~ + + +SELECT SmallMoneyVal, COUNT(*) as Count +FROM MoneyComparisonTest +GROUP BY SmallMoneyVal; +GO +~~START~~ +smallmoney#!#int +214748.3647#!#1 +-100.0000#!#1 +123.4500#!#1 +200.0000#!#1 +0.0000#!#1 +-214748.3648#!#1 +100.0000#!#1 +~~END~~ + + +-- GROUP BY with aggregates +SELECT + CASE + WHEN MoneyVal >= 0 THEN 'Positive' + ELSE 'Negative' + END AS ValueType, + COUNT(*) as Count, + MIN(MoneyVal) as MinValue, + MAX(MoneyVal) as MaxValue, + AVG(CAST(MoneyVal AS FLOAT)) as AvgValue +FROM MoneyComparisonTest +GROUP BY CASE + WHEN MoneyVal >= 0 THEN 'Positive' + ELSE 'Negative' +END +ORDER BY ValueType; +GO +~~START~~ +varchar#!#int#!#money#!#money#!#float +Negative#!#2#!#-922337203685477.5808#!#-100.0000#!#-4.611686018427888E14 +Positive#!#5#!#0.0000#!#922337203685477.5807#!#1.8446744073718022E14 +~~END~~ + + +-- HAVING clause tests +SELECT MoneyVal, COUNT(*) as Count +FROM MoneyComparisonTest +GROUP BY MoneyVal +HAVING MoneyVal > 0; +GO +~~START~~ +money#!#int +123.4500#!#1 +200.0000#!#1 +922337203685477.5807#!#1 +100.0000#!#1 +~~END~~ + + +SELECT SmallMoneyVal, COUNT(*) as Count +FROM MoneyComparisonTest +GROUP BY SmallMoneyVal +HAVING SmallMoneyVal < 0; +GO +~~START~~ +smallmoney#!#int +-100.0000#!#1 +-214748.3648#!#1 +~~END~~ + + +-- Complex comparison scenarios +-- Case expression comparisons +SELECT ID, + CASE + WHEN MoneyVal > 0 THEN 'Positive' + WHEN MoneyVal < 0 THEN 'Negative' + ELSE 'Zero' + END AS MoneyCategory, + CASE + WHEN SmallMoneyVal > 0 THEN 'Positive' + WHEN SmallMoneyVal < 0 THEN 'Negative' + ELSE 'Zero' + END AS SmallMoneyCategory +FROM MoneyComparisonTest; +GO +~~START~~ +int#!#varchar#!#varchar +1#!#Positive#!#Positive +2#!#Positive#!#Positive +3#!#Negative#!#Negative +4#!#Positive#!#Positive +5#!#Negative#!#Negative +6#!#Zero#!#Zero +7#!#Positive#!#Positive +~~END~~ + + +-- Nested comparisons +SELECT ID, MoneyVal +FROM MoneyComparisonTest +WHERE MoneyVal > ( + SELECT AVG(CAST(MoneyVal AS FLOAT)) + FROM MoneyComparisonTest + WHERE MoneyVal > 0 +); +GO +~~START~~ +int#!#money +4#!#922337203685477.5807 +~~END~~ + + +-- Multiple conditions +SELECT ID, MoneyVal, SmallMoneyVal +FROM MoneyComparisonTest +WHERE MoneyVal > 0 +AND SmallMoneyVal > 0 +AND MoneyVal = SmallMoneyVal; +GO +~~START~~ +int#!#money#!#smallmoney +1#!#100.0000#!#100.0000 +2#!#200.0000#!#200.0000 +7#!#123.4500#!#123.4500 +~~END~~ + + +-- Exists with comparison +SELECT ID, MoneyVal +FROM MoneyComparisonTest t1 +WHERE EXISTS ( + SELECT 1 + FROM MoneyComparisonTest2 t2 + WHERE t2.MoneyVal = t1.MoneyVal +); +GO +~~START~~ +int#!#money +1#!#100.0000 +2#!#200.0000 +~~END~~ + + +-- Union with comparisons +SELECT ID, MoneyVal, 'MONEY' as Type +FROM MoneyComparisonTest +WHERE MoneyVal > 0 +UNION ALL +SELECT ID, SmallMoneyVal, 'SMALLMONEY' as Type +FROM MoneyComparisonTest +WHERE SmallMoneyVal > 0 +ORDER BY MoneyVal, ID, Type; +GO +~~START~~ +int#!#money#!#varchar +1#!#100.0000#!#MONEY +1#!#100.0000#!#SMALLMONEY +7#!#123.4500#!#MONEY +7#!#123.4500#!#SMALLMONEY +2#!#200.0000#!#MONEY +2#!#200.0000#!#SMALLMONEY +4#!#214748.3647#!#SMALLMONEY +4#!#922337203685477.5807#!#MONEY +~~END~~ + + +-- Intersection test +SELECT MoneyVal +FROM MoneyComparisonTest +WHERE MoneyVal > 0 +INTERSECT +SELECT MoneyVal +FROM MoneyComparisonTest2 +WHERE MoneyVal > 0; +GO +~~START~~ +money +200.0000 +100.0000 +~~END~~ + + +-- Except test +SELECT MoneyVal +FROM MoneyComparisonTest +WHERE MoneyVal > 0 +EXCEPT +SELECT MoneyVal +FROM MoneyComparisonTest2 +WHERE MoneyVal > 0; +GO +~~START~~ +money +123.4500 +922337203685477.5807 +~~END~~ + + +-- Additional complex scenarios +-- Subquery comparisons +SELECT ID, MoneyVal +FROM MoneyComparisonTest t1 +WHERE MoneyVal = ( + SELECT MAX(MoneyVal) + FROM MoneyComparisonTest + WHERE ID < t1.ID +); +GO +~~START~~ +int#!#money +~~END~~ + + +-- Correlated subqueries +SELECT ID, MoneyVal +FROM MoneyComparisonTest t1 +WHERE MoneyVal > ( + SELECT AVG(CAST(t2.MoneyVal AS FLOAT)) + FROM MoneyComparisonTest t2 + WHERE t2.ID < t1.ID +); +GO +~~START~~ +int#!#money +2#!#200.0000 +4#!#922337203685477.5807 +7#!#123.4500 +~~END~~ + + +-- Window functions with comparisons +SELECT + ID, + MoneyVal, + LAG(MoneyVal) OVER (ORDER BY ID) as PrevValue, + CASE + WHEN MoneyVal > LAG(MoneyVal) OVER (ORDER BY ID) THEN 'Increased' + WHEN MoneyVal < LAG(MoneyVal) OVER (ORDER BY ID) THEN 'Decreased' + WHEN MoneyVal = LAG(MoneyVal) OVER (ORDER BY ID) THEN 'No Change' + ELSE 'First Row' + END as ValueChange +FROM MoneyComparisonTest; +GO +~~START~~ +int#!#money#!#money#!#varchar +1#!#100.0000#!##!#First Row +2#!#200.0000#!#100.0000#!#Increased +3#!#-100.0000#!#200.0000#!#Decreased +4#!#922337203685477.5807#!#-100.0000#!#Increased +5#!#-922337203685477.5808#!#922337203685477.5807#!#Decreased +6#!#0.0000#!#-922337203685477.5808#!#Increased +7#!#123.4500#!#0.0000#!#Increased +~~END~~ + + +-- Running totals with comparisons +SELECT + ID, + MoneyVal, + SUM(MoneyVal) OVER (ORDER BY ID) as RunningTotal, + CASE + WHEN SUM(MoneyVal) OVER (ORDER BY ID) > 0 THEN 'Positive Balance' + ELSE 'Negative Balance' + END as BalanceStatus +FROM MoneyComparisonTest; +GO +~~START~~ +int#!#money#!#money#!#varchar +1#!#100.0000#!#100.0000#!#Positive Balance +2#!#200.0000#!#300.0000#!#Positive Balance +3#!#-100.0000#!#200.0000#!#Positive Balance +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +-- Pivot operations +-- Create sample data for pivot +CREATE TABLE MoneyPivotTest ( + ID INT, + Category VARCHAR(10), + Amount MONEY +); +GO + +INSERT INTO MoneyPivotTest (ID, Category, Amount) +VALUES +(1, 'A', 100.00), +(1, 'B', 200.00), +(2, 'A', 300.00), +(2, 'B', 400.00); +GO +~~ROW COUNT: 4~~ + + +-- Pivot query +SELECT * +FROM ( + SELECT ID, Category, Amount + FROM MoneyPivotTest +) AS SourceTable +PIVOT ( + SUM(Amount) + FOR Category IN ([A], [B]) +) AS PivotTable; +GO +~~START~~ +int#!#money#!#money +1#!#100.0000#!#200.0000 +2#!#300.0000#!#400.0000 +~~END~~ + + +-- Complex conditional aggregation +SELECT + CASE + WHEN MoneyVal BETWEEN -1000 AND 1000 THEN 'Normal Range' + WHEN MoneyVal > 1000 THEN 'High Range' + ELSE 'Low Range' + END AS ValueRange, + COUNT(*) AS Count, + MIN(MoneyVal) AS MinValue, + MAX(MoneyVal) AS MaxValue, + SUM(CASE WHEN MoneyVal > 0 THEN 1 ELSE 0 END) AS PositiveCount, + SUM(CASE WHEN MoneyVal < 0 THEN 1 ELSE 0 END) AS NegativeCount +FROM MoneyComparisonTest +GROUP BY + CASE + WHEN MoneyVal BETWEEN -1000 AND 1000 THEN 'Normal Range' + WHEN MoneyVal > 1000 THEN 'High Range' + ELSE 'Low Range' + END +ORDER BY ValueRange; +GO +~~START~~ +varchar#!#int#!#money#!#money#!#int#!#int +High Range#!#1#!#922337203685477.5807#!#922337203685477.5807#!#1#!#0 +Low Range#!#1#!#-922337203685477.5808#!#-922337203685477.5808#!#0#!#1 +Normal Range#!#5#!#-100.0000#!#200.0000#!#3#!#1 +~~END~~ + + +-- String formatting and comparison tests +SELECT + ID, + MoneyVal, + CAST(MoneyVal AS VARCHAR(20)) AS StringValue, + CASE + WHEN CAST(MoneyVal AS VARCHAR(20)) LIKE '%-%.%' THEN 'Negative Decimal' + WHEN CAST(MoneyVal AS VARCHAR(20)) LIKE '%.%' THEN 'Positive Decimal' + ELSE 'Whole Number' + END AS FormatType +FROM MoneyComparisonTest; +GO +~~START~~ +int#!#money#!#varchar#!#varchar +1#!#100.0000#!#100.00#!#Positive Decimal +2#!#200.0000#!#200.00#!#Positive Decimal +3#!#-100.0000#!#-100.00#!#Negative Decimal +4#!#922337203685477.5807#!#922337203685477.58#!#Positive Decimal +5#!#-922337203685477.5808#!#-922337203685477.58#!#Negative Decimal +6#!#0.0000#!#0.00#!#Positive Decimal +7#!#123.4500#!#123.45#!#Positive Decimal +~~END~~ + + +-- Rounding comparison tests +SELECT + ID, + MoneyVal, + ROUND(MoneyVal, 0) AS RoundedToInteger, + CASE + WHEN MoneyVal = ROUND(MoneyVal, 0) THEN 'Whole Number' + ELSE 'Decimal Number' + END AS NumberType +FROM MoneyComparisonTest; +GO +~~START~~ +int#!#money#!#money#!#varchar +1#!#100.0000#!#100.0000#!#Whole Number +2#!#200.0000#!#200.0000#!#Whole Number +3#!#-100.0000#!#-100.0000#!#Whole Number +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value "922337203685478" is out of range for type fixeddecimal)~~ + + +-- Boundary value analysis +-- Test near-boundary values for MONEY +SELECT + CASE WHEN CAST(922337203685477.5807 AS MONEY) = CAST(922337203685477.5807 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [Max_Money_Equal], + CASE WHEN CAST(-922337203685477.5808 AS MONEY) = CAST(-922337203685477.5808 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [Min_Money_Equal]; +GO +~~START~~ +varchar#!#varchar +Equal#!#Equal +~~END~~ + + +-- Test near-boundary values for SMALLMONEY +SELECT + CASE WHEN CAST(214748.3647 AS SMALLMONEY) = CAST(214748.3647 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [Max_SmallMoney_Equal], + CASE WHEN CAST(-214748.3648 AS SMALLMONEY) = CAST(-214748.3648 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [Min_SmallMoney_Equal]; +GO +~~START~~ +varchar#!#varchar +Equal#!#Equal +~~END~~ + + +-- Cleanup +DROP TABLE MoneyComparisonTest; +DROP TABLE MoneyComparisonTest2; +DROP TABLE MoneyPivotTest; +GO + + + +------------------------------------------------------------------------ +---- 6. Datatype Conversion +------------------------------------------------------------------------ +---- Conversion using CAST() +-- BIT to Money types +SELECT 'BIT to Money Types Conversion' AS test_description; +GO +~~START~~ +varchar +BIT to Money Types Conversion +~~END~~ + + +-- BIT -> MONEY +SELECT CAST(0 AS MONEY) AS [BIT_0_TO_MONEY], CAST(1 AS MONEY) AS [BIT_1_TO_MONEY]; +GO +~~START~~ +money#!#money +0.0000#!#1.0000 +~~END~~ + + +-- BIT -> SMALLMONEY +SELECT CAST(0 AS SMALLMONEY) AS [BIT_0_TO_SMALLMONEY], CAST(1 AS SMALLMONEY) AS [BIT_1_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney +0.0000#!#1.0000 +~~END~~ + + +-- Integer types to Money types +SELECT 'Integer Types to Money Types Conversion' AS test_description; +GO +~~START~~ +varchar +Integer Types to Money Types Conversion +~~END~~ + + +-- TINYINT -> MONEY +SELECT CAST(CAST(0 AS TINYINT) AS MONEY) AS [TINYINT_MIN_TO_MONEY], + CAST(CAST(255 AS TINYINT) AS MONEY) AS [TINYINT_MAX_TO_MONEY], + CAST(CAST(128 AS TINYINT) AS MONEY) AS [TINYINT_MID_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money +0.0000#!#255.0000#!#128.0000 +~~END~~ + + +-- TINYINT -> SMALLMONEY +SELECT CAST(CAST(0 AS TINYINT) AS SMALLMONEY) AS [TINYINT_MIN_TO_SMALLMONEY], + CAST(CAST(255 AS TINYINT) AS SMALLMONEY) AS [TINYINT_MAX_TO_SMALLMONEY], + CAST(CAST(128 AS TINYINT) AS SMALLMONEY) AS [TINYINT_MID_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney +0.0000#!#255.0000#!#128.0000 +~~END~~ + + +-- SMALLINT -> MONEY +SELECT CAST(CAST(-32768 AS SMALLINT) AS MONEY) AS [SMALLINT_MIN_TO_MONEY], + CAST(CAST(32767 AS SMALLINT) AS MONEY) AS [SMALLINT_MAX_TO_MONEY], + CAST(CAST(0 AS SMALLINT) AS MONEY) AS [SMALLINT_ZERO_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money +-32768.0000#!#32767.0000#!#0.0000 +~~END~~ + + +-- SMALLINT -> SMALLMONEY +SELECT CAST(CAST(-32768 AS SMALLINT) AS SMALLMONEY) AS [SMALLINT_MIN_TO_SMALLMONEY], + CAST(CAST(32767 AS SMALLINT) AS SMALLMONEY) AS [SMALLINT_MAX_TO_SMALLMONEY], + CAST(CAST(0 AS SMALLINT) AS SMALLMONEY) AS [SMALLINT_ZERO_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney +-32768.0000#!#32767.0000#!#0.0000 +~~END~~ + + +-- INT -> MONEY +SELECT CAST(CAST(-2147483648 AS INT) AS MONEY) AS [INT_MIN_TO_MONEY], + CAST(CAST(2147483647 AS INT) AS MONEY) AS [INT_MAX_TO_MONEY], + CAST(CAST(0 AS INT) AS MONEY) AS [INT_ZERO_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money +-2147483648.0000#!#2147483647.0000#!#0.0000 +~~END~~ + + +-- INT -> SMALLMONEY +SELECT TRY_CAST(CAST(-2147483648 AS INT) AS SMALLMONEY) AS [INT_MIN_TO_SMALLMONEY], + TRY_CAST(CAST(2147483647 AS INT) AS SMALLMONEY) AS [INT_MAX_TO_SMALLMONEY], + CAST(CAST(0 AS INT) AS SMALLMONEY) AS [INT_ZERO_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney +#!##!#0.0000 +~~END~~ + + +-- BIGINT -> MONEY +SELECT CAST(CAST(-9223372036854775808 AS BIGINT) AS MONEY) AS [BIGINT_MIN_TO_MONEY], + CAST(CAST(9223372036854775807 AS BIGINT) AS MONEY) AS [BIGINT_MAX_TO_MONEY], + CAST(CAST(0 AS BIGINT) AS MONEY) AS [BIGINT_ZERO_TO_MONEY]; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value "-9223372036854775808" is out of range for type money)~~ + + +-- BIGINT -> SMALLMONEY +SELECT TRY_CAST(CAST(-9223372036854775808 AS BIGINT) AS SMALLMONEY) AS [BIGINT_MIN_TO_SMALLMONEY], + TRY_CAST(CAST(9223372036854775807 AS BIGINT) AS SMALLMONEY) AS [BIGINT_MAX_TO_SMALLMONEY], + CAST(CAST(0 AS BIGINT) AS SMALLMONEY) AS [BIGINT_ZERO_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney +#!##!#0.0000 +~~END~~ + + +-- Floating point types to Money types +-- FLOAT -> MONEY +SELECT CAST(CAST(-1234.56789 AS FLOAT) AS MONEY) AS [FLOAT_NEG_TO_MONEY], + CAST(CAST(1234.56789 AS FLOAT) AS MONEY) AS [FLOAT_POS_TO_MONEY], + CAST(CAST(0.0 AS FLOAT) AS MONEY) AS [FLOAT_ZERO_TO_MONEY], + CAST(CAST(922337203685477.5807 AS FLOAT) AS MONEY) AS [FLOAT_MAX_TO_MONEY], + CAST(CAST(-922337203685477.5808 AS FLOAT) AS MONEY) AS [FLOAT_MIN_TO_MONEY]; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +-- FLOAT -> SMALLMONEY +SELECT CAST(CAST(-214748.3648 AS FLOAT) AS SMALLMONEY) AS [FLOAT_NEG_TO_SMALLMONEY], + CAST(CAST(214748.3647 AS FLOAT) AS SMALLMONEY) AS [FLOAT_POS_TO_SMALLMONEY], + CAST(CAST(0.0 AS FLOAT) AS SMALLMONEY) AS [FLOAT_ZERO_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney +-214748.3648#!#214748.3647#!#0.0000 +~~END~~ + + +-- String types to Money types +-- CHAR -> MONEY +SELECT CAST(CAST('123.45' AS CHAR(40)) AS MONEY) AS [CHAR_POS_TO_MONEY], + CAST(CAST('-123.45' AS CHAR(40)) AS MONEY) AS [CHAR_NEG_TO_MONEY], + CAST(CAST('0' AS CHAR(40)) AS MONEY) AS [CHAR_ZERO_TO_MONEY], + CAST(CAST('922337203685477.5807' AS CHAR(40)) AS MONEY) AS [CHAR_MAX_TO_MONEY], + CAST(CAST('-922337203685477.5808' AS CHAR(40)) AS MONEY) AS [CHAR_MIN_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money#!#money#!#money +123.4500#!#-123.4500#!#0.0000#!#922337203685477.5807#!#-922337203685477.5808 +~~END~~ + + +-- CHAR -> SMALLMONEY +SELECT CAST(CAST('214748.3647' AS CHAR(40)) AS SMALLMONEY) AS [CHAR_POS_TO_SMALLMONEY], + CAST(CAST('-214748.3648' AS CHAR(40)) AS SMALLMONEY) AS [CHAR_NEG_TO_SMALLMONEY], + CAST(CAST('0' AS CHAR(40)) AS SMALLMONEY) AS [CHAR_ZERO_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney +214748.3647#!#-214748.3648#!#0.0000 +~~END~~ + + +-- VARCHAR -> MONEY +SELECT CAST(CAST('123.45' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_POS_TO_MONEY], + CAST(CAST('-123.45' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_NEG_TO_MONEY], + CAST(CAST('0' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_ZERO_TO_MONEY], + CAST(CAST('922337203685477.5807' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_MAX_TO_MONEY], + CAST(CAST('-922337203685477.5808' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_MIN_TO_MONEY], + CAST(CAST('$123.45' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_CURRENCY_TO_MONEY], + CAST(CAST('1,234.56' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_COMMA_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money#!#money#!#money#!#money#!#money +123.4500#!#-123.4500#!#0.0000#!#922337203685477.5807#!#-922337203685477.5808#!#123.4500#!#1234.5600 +~~END~~ + + +-- VARCHAR -> SMALLMONEY +SELECT CAST(CAST('214748.3647' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_POS_TO_SMALLMONEY], + CAST(CAST('-214748.3648' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_NEG_TO_SMALLMONEY], + CAST(CAST('0' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_ZERO_TO_SMALLMONEY], + CAST(CAST('$123.45' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_CURRENCY_TO_SMALLMONEY], + CAST(CAST('1,234.56' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_COMMA_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +214748.3647#!#-214748.3648#!#0.0000#!#123.4500#!#1234.5600 +~~END~~ + + +-- NCHAR -> MONEY +SELECT CAST(CAST(N'123.45' AS NCHAR(40)) AS MONEY) AS [NCHAR_POS_TO_MONEY], + CAST(CAST(N'-123.45' AS NCHAR(40)) AS MONEY) AS [NCHAR_NEG_TO_MONEY], + CAST(CAST(N'0' AS NCHAR(40)) AS MONEY) AS [NCHAR_ZERO_TO_MONEY], + CAST(CAST(N'922337203685477.5807' AS NCHAR(40)) AS MONEY) AS [NCHAR_MAX_TO_MONEY], + CAST(CAST(N'-922337203685477.5808' AS NCHAR(40)) AS MONEY) AS [NCHAR_MIN_TO_MONEY], + CAST(CAST(N'$123.45' AS NCHAR(40)) AS MONEY) AS [NCHAR_CURRENCY_TO_MONEY], + CAST(CAST(N'1,234.56' AS NCHAR(40)) AS MONEY) AS [NCHAR_COMMA_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money#!#money#!#money#!#money#!#money +123.4500#!#-123.4500#!#0.0000#!#922337203685477.5807#!#-922337203685477.5808#!#123.4500#!#1234.5600 +~~END~~ + + +-- NCHAR -> SMALLMONEY +SELECT CAST(CAST(N'214748.3647' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_POS_TO_SMALLMONEY], + CAST(CAST(N'-214748.3648' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_NEG_TO_SMALLMONEY], + CAST(CAST(N'0' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_ZERO_TO_SMALLMONEY], + CAST(CAST(N'$123.45' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_CURRENCY_TO_SMALLMONEY], + CAST(CAST(N'1,234.56' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_COMMA_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +214748.3647#!#-214748.3648#!#0.0000#!#123.4500#!#1234.5600 +~~END~~ + + +-- NVARCHAR -> MONEY +SELECT CAST(CAST(N'123.45' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_POS_TO_MONEY], + CAST(CAST(N'-123.45' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_NEG_TO_MONEY], + CAST(CAST(N'0' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_ZERO_TO_MONEY], + CAST(CAST(N'922337203685477.5807' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_MAX_TO_MONEY], + CAST(CAST(N'-922337203685477.5808' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_MIN_TO_MONEY], + CAST(CAST(N'$123.45' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_CURRENCY_TO_MONEY], + CAST(CAST(N'1,234.56' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_COMMA_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money#!#money#!#money#!#money#!#money +123.4500#!#-123.4500#!#0.0000#!#922337203685477.5807#!#-922337203685477.5808#!#123.4500#!#1234.5600 +~~END~~ + + +-- NVARCHAR -> SMALLMONEY +SELECT CAST(CAST(N'214748.3647' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_POS_TO_SMALLMONEY], + CAST(CAST(N'-214748.3648' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_NEG_TO_SMALLMONEY], + CAST(CAST(N'0' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_ZERO_TO_SMALLMONEY], + CAST(CAST(N'$123.45' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_CURRENCY_TO_SMALLMONEY], + CAST(CAST(N'1,234.56' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_COMMA_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +214748.3647#!#-214748.3648#!#0.0000#!#123.4500#!#1234.5600 +~~END~~ + diff --git a/test/JDBC/expected/money_smallmoney_arith_edge.out b/test/JDBC/expected/money_smallmoney_arith_edge.out new file mode 100644 index 00000000000..702afdc28ff --- /dev/null +++ b/test/JDBC/expected/money_smallmoney_arith_edge.out @@ -0,0 +1,1751 @@ +SELECT CAST(214748 AS INT) * CAST(0.5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +107374.0000 +~~END~~ + + +SELECT CAST(214748 AS INT) / CAST(0.5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214748 AS INT) * CAST(-0.05 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-10737.4000 +~~END~~ + + +SELECT CAST(214748 AS INT) / CAST(-0.05 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-214748 AS INT) * CAST(0.5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-107374.0000 +~~END~~ + + +SELECT CAST(-214748 AS INT) / CAST(0.5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-214748 AS INT) * CAST(-0.05 AS SMALLMONEY); +GO +~~START~~ +smallmoney +10737.4000 +~~END~~ + + +SELECT CAST(-214748 AS INT) / CAST(-0.05 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214749 AS INT) * CAST(0.5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +107374.5000 +~~END~~ + + +SELECT CAST(214749 AS INT) / CAST(0.5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214749 AS INT) * CAST(-0.05 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-10737.4500 +~~END~~ + + +SELECT CAST(214749 AS INT) / CAST(-0.05 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214747 AS INT) * CAST(0.5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +107373.5000 +~~END~~ + + +SELECT CAST(214747 AS INT) / CAST(0.5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214747 AS INT) * CAST(-0.05 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-10737.3500 +~~END~~ + + +SELECT CAST(214747 AS INT) / CAST(-0.05 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(922337203685476 AS BIGINT) * CAST(0.05 AS MONEY); +GO +~~START~~ +money +46116860184273.8000 +~~END~~ + + +SELECT CAST(922337203685476 AS BIGINT) / CAST(0.05 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685476 AS BIGINT) * CAST(-0.5 AS MONEY); +GO +~~START~~ +money +-461168601842738.0000 +~~END~~ + + +SELECT CAST(922337203685476 AS BIGINT) / CAST(-0.5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685476 AS BIGINT) * CAST(0.05 AS MONEY); +GO +~~START~~ +money +-46116860184273.8000 +~~END~~ + + +SELECT CAST(-922337203685476 AS BIGINT) / CAST(0.05 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685476 AS BIGINT) * CAST(-0.5 AS MONEY); +GO +~~START~~ +money +461168601842738.0000 +~~END~~ + + +SELECT CAST(-922337203685476 AS BIGINT) / CAST(-0.5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685478 AS BIGINT) * CAST(0.05 AS MONEY); +GO +~~START~~ +money +46116860184273.9000 +~~END~~ + + +SELECT CAST(922337203685478 AS BIGINT) / CAST(0.05 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685478 AS BIGINT) * CAST(-0.5 AS MONEY); +GO +~~START~~ +money +-461168601842739.0000 +~~END~~ + + +SELECT CAST(922337203685478 AS BIGINT) / CAST(-0.5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685478 AS BIGINT) * CAST(0.05 AS MONEY); +GO +~~START~~ +money +-46116860184273.9000 +~~END~~ + + +SELECT CAST(-922337203685478 AS BIGINT) / CAST(0.05 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685478 AS BIGINT) * CAST(-0.5 AS MONEY); +GO +~~START~~ +money +461168601842739.0000 +~~END~~ + + +SELECT CAST(-922337203685478 AS BIGINT) / CAST(-0.5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685477 AS BIGINT) * CAST(0.05 AS MONEY); +GO +~~START~~ +money +46116860184273.8500 +~~END~~ + + +SELECT CAST(922337203685477 AS BIGINT) / CAST(0.05 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685477 AS BIGINT) * CAST(-0.5 AS MONEY); +GO +~~START~~ +money +-461168601842738.5000 +~~END~~ + + +SELECT CAST(922337203685477 AS BIGINT) / CAST(-0.5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685477 AS BIGINT) * CAST(0.05 AS MONEY); +GO +~~START~~ +money +-46116860184273.8500 +~~END~~ + + +SELECT CAST(-922337203685477 AS BIGINT) / CAST(0.05 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685477 AS BIGINT) * CAST(-0.5 AS MONEY); +GO +~~START~~ +money +461168601842738.5000 +~~END~~ + + +SELECT CAST(-922337203685477 AS BIGINT) / CAST(-0.5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(214748 AS INT) + CAST(-5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214743.0000 +~~END~~ + + +SELECT CAST(214748 AS INT) - CAST(-5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214748 AS INT) + CAST(-50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214698.0000 +~~END~~ + + +SELECT CAST(214748 AS INT) - CAST(-50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-214748 AS INT) + CAST(5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214743.0000 +~~END~~ + + +SELECT CAST(-214748 AS INT) - CAST(5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214749 AS INT) + CAST(5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214749 AS INT) - CAST(5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214749 AS INT) + CAST(-5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214749 AS INT) - CAST(-5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214749 AS INT) + CAST(50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214749 AS INT) - CAST(50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214749 AS INT) + CAST(-50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214749 AS INT) - CAST(-50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214747 AS INT) + CAST(5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(214747 AS INT) - CAST(5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214742.0000 +~~END~~ + + +SELECT CAST(214747 AS INT) + CAST(-5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214742.0000 +~~END~~ + + +SELECT CAST(214747 AS INT) - CAST(-5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-214749 AS INT) + CAST(50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-214749 AS INT) - CAST(50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-214749 AS INT) + CAST(-50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-214749 AS INT) - CAST(-50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-214747 AS INT) + CAST(5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214742.0000 +~~END~~ + + +SELECT CAST(-214747 AS INT) - CAST(5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-214747 AS INT) + CAST(-5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-214747 AS INT) - CAST(-5 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214742.0000 +~~END~~ + + +SELECT CAST(-214747 AS INT) + CAST(50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214697.0000 +~~END~~ + + +SELECT CAST(-214747 AS INT) - CAST(50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-214747 AS INT) + CAST(-50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-214747 AS INT) - CAST(-50 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214697.0000 +~~END~~ + + +SELECT CAST(922337203685476 AS BIGINT) + CAST(5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685476 AS BIGINT) - CAST(5 AS MONEY); +GO +~~START~~ +money +922337203685471.0000 +~~END~~ + + +SELECT CAST(922337203685476 AS BIGINT) + CAST(-50 AS MONEY); +GO +~~START~~ +money +922337203685426.0000 +~~END~~ + + +SELECT CAST(922337203685476 AS BIGINT) - CAST(-50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685476 AS BIGINT) + CAST(50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685476 AS BIGINT) - CAST(50 AS MONEY); +GO +~~START~~ +money +922337203685426.0000 +~~END~~ + + +SELECT CAST(922337203685476 AS BIGINT) + CAST(-5 AS MONEY); +GO +~~START~~ +money +922337203685471.0000 +~~END~~ + + +SELECT CAST(922337203685476 AS BIGINT) - CAST(-5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685476 AS BIGINT) + CAST(5 AS MONEY); +GO +~~START~~ +money +-922337203685471.0000 +~~END~~ + + +SELECT CAST(-922337203685476 AS BIGINT) - CAST(5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685476 AS BIGINT) + CAST(-50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685476 AS BIGINT) - CAST(-50 AS MONEY); +GO +~~START~~ +money +-922337203685426.0000 +~~END~~ + + +SELECT CAST(-922337203685476 AS BIGINT) + CAST(50 AS MONEY); +GO +~~START~~ +money +-922337203685426.0000 +~~END~~ + + +SELECT CAST(-922337203685476 AS BIGINT) - CAST(50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685476 AS BIGINT) + CAST(-5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685476 AS BIGINT) - CAST(-5 AS MONEY); +GO +~~START~~ +money +-922337203685471.0000 +~~END~~ + + +SELECT CAST(922337203685478 AS BIGINT) + CAST(5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685478 AS BIGINT) - CAST(5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685478 AS BIGINT) + CAST(-50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685478 AS BIGINT) - CAST(-50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685478 AS BIGINT) + CAST(50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685478 AS BIGINT) - CAST(50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685478 AS BIGINT) + CAST(-5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685478 AS BIGINT) - CAST(-5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685478 AS BIGINT) + CAST(5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685478 AS BIGINT) - CAST(5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685478 AS BIGINT) + CAST(-50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685478 AS BIGINT) - CAST(-50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685478 AS BIGINT) + CAST(50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685478 AS BIGINT) - CAST(50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685478 AS BIGINT) + CAST(-5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685478 AS BIGINT) - CAST(-5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685477 AS BIGINT) + CAST(5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685477 AS BIGINT) - CAST(5 AS MONEY); +GO +~~START~~ +money +922337203685472.0000 +~~END~~ + + +SELECT CAST(922337203685477 AS BIGINT) + CAST(-50 AS MONEY); +GO +~~START~~ +money +922337203685427.0000 +~~END~~ + + +SELECT CAST(922337203685477 AS BIGINT) - CAST(-50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685477 AS BIGINT) + CAST(50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(922337203685477 AS BIGINT) - CAST(50 AS MONEY); +GO +~~START~~ +money +922337203685427.0000 +~~END~~ + + +SELECT CAST(922337203685477 AS BIGINT) + CAST(-5 AS MONEY); +GO +~~START~~ +money +922337203685472.0000 +~~END~~ + + +SELECT CAST(922337203685477 AS BIGINT) - CAST(-5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685477 AS BIGINT) + CAST(5 AS MONEY); +GO +~~START~~ +money +-922337203685472.0000 +~~END~~ + + +SELECT CAST(-922337203685477 AS BIGINT) - CAST(5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685477 AS BIGINT) + CAST(-50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685477 AS BIGINT) - CAST(-50 AS MONEY); +GO +~~START~~ +money +-922337203685427.0000 +~~END~~ + + +SELECT CAST(-922337203685477 AS BIGINT) + CAST(50 AS MONEY); +GO +~~START~~ +money +-922337203685427.0000 +~~END~~ + + +SELECT CAST(-922337203685477 AS BIGINT) - CAST(50 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685477 AS BIGINT) + CAST(-5 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-922337203685477 AS BIGINT) - CAST(-5 AS MONEY); +GO +~~START~~ +money +-922337203685472.0000 +~~END~~ + + +SELECT CAST(5 AS MONEY) - CAST(922337203685478 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(5 AS MONEY) + CAST(-922337203685478 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(5 AS MONEY) - CAST(-922337203685478 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(5 AS MONEY) + CAST(922337203685477 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(5 AS MONEY) - CAST(922337203685477 AS BIGINT); +GO +~~START~~ +money +-922337203685472.0000 +~~END~~ + + +SELECT CAST(5 AS MONEY) + CAST(-922337203685477 AS BIGINT); +GO +~~START~~ +money +-922337203685472.0000 +~~END~~ + + +SELECT CAST(5 AS MONEY) - CAST(-922337203685477 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-50 AS MONEY) + CAST(922337203685476 AS BIGINT); +GO +~~START~~ +money +922337203685426.0000 +~~END~~ + + +SELECT CAST(-50 AS MONEY) - CAST(922337203685476 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-50 AS MONEY) + CAST(-922337203685476 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-50 AS MONEY) - CAST(-922337203685476 AS BIGINT); +GO +~~START~~ +money +922337203685426.0000 +~~END~~ + + +SELECT CAST(-50 AS MONEY) + CAST(922337203685478 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-50 AS MONEY) - CAST(922337203685478 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-50 AS MONEY) + CAST(-922337203685478 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-50 AS MONEY) - CAST(-922337203685478 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-50 AS MONEY) + CAST(922337203685477 AS BIGINT); +GO +~~START~~ +money +922337203685427.0000 +~~END~~ + + +SELECT CAST(-50 AS MONEY) - CAST(922337203685477 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-50 AS MONEY) + CAST(-922337203685477 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-50 AS MONEY) - CAST(-922337203685477 AS BIGINT); +GO +~~START~~ +money +922337203685427.0000 +~~END~~ + + +SELECT CAST(50 AS MONEY) + CAST(922337203685476 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(50 AS MONEY) - CAST(922337203685476 AS BIGINT); +GO +~~START~~ +money +-922337203685426.0000 +~~END~~ + + +SELECT CAST(50 AS MONEY) + CAST(-922337203685476 AS BIGINT); +GO +~~START~~ +money +-922337203685426.0000 +~~END~~ + + +SELECT CAST(50 AS MONEY) - CAST(922337203685477 AS BIGINT); +GO +~~START~~ +money +-922337203685427.0000 +~~END~~ + + +SELECT CAST(50 AS MONEY) + CAST(-922337203685477 AS BIGINT); +GO +~~START~~ +money +-922337203685427.0000 +~~END~~ + + +SELECT CAST(50 AS MONEY) - CAST(-922337203685477 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-5 AS MONEY) + CAST(922337203685476 AS BIGINT); +GO +~~START~~ +money +922337203685471.0000 +~~END~~ + + +SELECT CAST(-5 AS MONEY) - CAST(922337203685476 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-5 AS MONEY) + CAST(-922337203685476 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-5 AS MONEY) - CAST(-922337203685476 AS BIGINT); +GO +~~START~~ +money +922337203685471.0000 +~~END~~ + + +SELECT CAST(-5 AS MONEY) + CAST(922337203685478 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-5 AS MONEY) - CAST(922337203685478 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-5 AS MONEY) + CAST(-922337203685478 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-5 AS MONEY) - CAST(-922337203685478 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-5 AS MONEY) + CAST(922337203685477 AS BIGINT); +GO +~~START~~ +money +922337203685472.0000 +~~END~~ + + +SELECT CAST(-5 AS MONEY) - CAST(922337203685477 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-5 AS MONEY) + CAST(-922337203685477 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CAST(-5 AS MONEY) - CAST(-922337203685477 AS BIGINT); +GO +~~START~~ +money +922337203685472.0000 +~~END~~ + + +SELECT CAST(5 AS SMALLMONEY) + CAST(214748 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(5 AS SMALLMONEY) - CAST(214748 AS INT); +GO +~~START~~ +smallmoney +-214743.0000 +~~END~~ + + +SELECT CAST(5 AS SMALLMONEY) + CAST(-214748 AS INT); +GO +~~START~~ +smallmoney +-214743.0000 +~~END~~ + + +SELECT CAST(5 AS SMALLMONEY) - CAST(-214748 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(5 AS SMALLMONEY) + CAST(214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(5 AS SMALLMONEY) - CAST(214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(5 AS SMALLMONEY) + CAST(214747 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(5 AS SMALLMONEY) - CAST(214747 AS INT); +GO +~~START~~ +smallmoney +-214742.0000 +~~END~~ + + +SELECT CAST(5 AS SMALLMONEY) + CAST(-214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(5 AS SMALLMONEY) - CAST(-214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(5 AS SMALLMONEY) + CAST(-214747 AS INT); +GO +~~START~~ +smallmoney +-214742.0000 +~~END~~ + + +SELECT CAST(5 AS SMALLMONEY) - CAST(-214747 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-5 AS SMALLMONEY) + CAST(214748 AS INT); +GO +~~START~~ +smallmoney +214743.0000 +~~END~~ + + +SELECT CAST(-5 AS SMALLMONEY) - CAST(214748 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-5 AS SMALLMONEY) + CAST(-214748 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-5 AS SMALLMONEY) - CAST(-214748 AS INT); +GO +~~START~~ +smallmoney +214743.0000 +~~END~~ + + +SELECT CAST(-5 AS SMALLMONEY) + CAST(214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-5 AS SMALLMONEY) - CAST(214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-5 AS SMALLMONEY) + CAST(214747 AS INT); +GO +~~START~~ +smallmoney +214742.0000 +~~END~~ + + +SELECT CAST(-5 AS SMALLMONEY) - CAST(214747 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-5 AS SMALLMONEY) + CAST(-214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-5 AS SMALLMONEY) - CAST(-214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-5 AS SMALLMONEY) + CAST(-214747 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-5 AS SMALLMONEY) - CAST(-214747 AS INT); +GO +~~START~~ +smallmoney +214742.0000 +~~END~~ + + +SELECT CAST(50 AS SMALLMONEY) + CAST(214748 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(50 AS SMALLMONEY) - CAST(214748 AS INT); +GO +~~START~~ +smallmoney +-214698.0000 +~~END~~ + + +SELECT CAST(50 AS SMALLMONEY) + CAST(-214748 AS INT); +GO +~~START~~ +smallmoney +-214698.0000 +~~END~~ + + +SELECT CAST(50 AS SMALLMONEY) - CAST(-214748 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(50 AS SMALLMONEY) + CAST(214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(50 AS SMALLMONEY) - CAST(214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(50 AS SMALLMONEY) + CAST(214747 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(50 AS SMALLMONEY) - CAST(214747 AS INT); +GO +~~START~~ +smallmoney +-214697.0000 +~~END~~ + + +SELECT CAST(50 AS SMALLMONEY) + CAST(-214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(50 AS SMALLMONEY) - CAST(-214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(50 AS SMALLMONEY) + CAST(-214747 AS INT); +GO +~~START~~ +smallmoney +-214697.0000 +~~END~~ + + +SELECT CAST(50 AS SMALLMONEY) - CAST(-214747 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-50 AS SMALLMONEY) + CAST(214748 AS INT); +GO +~~START~~ +smallmoney +214698.0000 +~~END~~ + + +SELECT CAST(-50 AS SMALLMONEY) - CAST(214748 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-50 AS SMALLMONEY) + CAST(-214748 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-50 AS SMALLMONEY) - CAST(-214748 AS INT); +GO +~~START~~ +smallmoney +214698.0000 +~~END~~ + + +SELECT CAST(-50 AS SMALLMONEY) + CAST(214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-50 AS SMALLMONEY) - CAST(214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-50 AS SMALLMONEY) + CAST(214747 AS INT); +GO +~~START~~ +smallmoney +214697.0000 +~~END~~ + + +SELECT CAST(-50 AS SMALLMONEY) - CAST(214747 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-50 AS SMALLMONEY) + CAST(-214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-50 AS SMALLMONEY) - CAST(-214749 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-50 AS SMALLMONEY) + CAST(-214747 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +SELECT CAST(-50 AS SMALLMONEY) - CAST(-214747 AS INT); +GO +~~START~~ +smallmoney +214697.0000 +~~END~~ + diff --git a/test/JDBC/expected/non_default_server_collation/chinese_prc_ci_as/TestStrings.out b/test/JDBC/expected/non_default_server_collation/chinese_prc_ci_as/TestStrings.out index ae6894db611..b34ca8ff099 100644 --- a/test/JDBC/expected/non_default_server_collation/chinese_prc_ci_as/TestStrings.out +++ b/test/JDBC/expected/non_default_server_collation/chinese_prc_ci_as/TestStrings.out @@ -4261,15 +4261,9 @@ GO SELECT 'Prefix_' + BitCol AS BitConcat FROM ImplicitToStringTest; SELECT N'Prefix_' + BitCol AS BitConcatN FROM ImplicitToStringTest; GO -~~START~~ -varchar -Prefix_1 -~~END~~ +~~ERROR (Code: 33557097)~~ -~~START~~ -nvarchar -Prefix_1 -~~END~~ +~~ERROR (Message: invalid input syntax for type double precision: "Prefix_")~~ -- DECIMAL diff --git a/test/JDBC/expected/non_default_server_collation/japanese_ci_as/TestStrings.out b/test/JDBC/expected/non_default_server_collation/japanese_ci_as/TestStrings.out index 8fdb31b650e..dce1ef12121 100644 --- a/test/JDBC/expected/non_default_server_collation/japanese_ci_as/TestStrings.out +++ b/test/JDBC/expected/non_default_server_collation/japanese_ci_as/TestStrings.out @@ -4261,15 +4261,9 @@ GO SELECT 'Prefix_' + BitCol AS BitConcat FROM ImplicitToStringTest; SELECT N'Prefix_' + BitCol AS BitConcatN FROM ImplicitToStringTest; GO -~~START~~ -varchar -Prefix_1 -~~END~~ +~~ERROR (Code: 33557097)~~ -~~START~~ -nvarchar -Prefix_1 -~~END~~ +~~ERROR (Message: invalid input syntax for type double precision: "Prefix_")~~ -- DECIMAL diff --git a/test/JDBC/expected/numeric_money-vu-verify.out b/test/JDBC/expected/numeric_money-vu-verify.out index c7c1c360e36..64b36dae0eb 100644 --- a/test/JDBC/expected/numeric_money-vu-verify.out +++ b/test/JDBC/expected/numeric_money-vu-verify.out @@ -1058,7 +1058,7 @@ GO smallmoney ~~ERROR (Code: 33557097)~~ -~~ERROR (Message: fixeddecimal out of range)~~ +~~ERROR (Message: smallmoney out of range)~~ SELECT CAST(9223372036854775807 AS BIGINT) * CAST(1.0001 AS MONEY) GO @@ -1074,7 +1074,7 @@ GO smallmoney ~~ERROR (Code: 33557097)~~ -~~ERROR (Message: fixeddecimal out of range)~~ +~~ERROR (Message: smallmoney out of range)~~ SELECT CAST(-9223372036854775808 AS BIGINT) * CAST(1.0001 AS MONEY) GO diff --git a/test/JDBC/expected/operator_expr_fixedlen.out b/test/JDBC/expected/operator_expr_fixedlen.out index 92c8b59527e..c1a019c0d8e 100644 --- a/test/JDBC/expected/operator_expr_fixedlen.out +++ b/test/JDBC/expected/operator_expr_fixedlen.out @@ -1135,11 +1135,9 @@ SELECT (money_col + bigint_col) * 1.13 FROM babel_5899_t1; GO ~~START~~ numeric -1042241040164588.536191 --1042241040164589.666304 -1.141300 - -~~END~~ +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ SELECT (money_col - int_col) * 2.5 FROM babel_5899_t1; GO @@ -1182,11 +1180,9 @@ SELECT (smallmoney_col + bigint_col) * 1.13 FROM babel_5899_t1; GO ~~START~~ numeric -242664.522111 --242665.652224 -1.141300 - -~~END~~ +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ SELECT (smallmoney_col - int_col) * 2.5 FROM babel_5899_t1; GO @@ -1194,7 +1190,7 @@ GO numeric ~~ERROR (Code: 33557097)~~ -~~ERROR (Message: Arithmetic overflow error for data type numeric.)~~ +~~ERROR (Message: smallmoney out of range)~~ SELECT (smallmoney_col * smallint_col) * 0.5 FROM babel_5899_t1; GO @@ -1202,7 +1198,7 @@ GO numeric ~~ERROR (Code: 33557097)~~ -~~ERROR (Message: Arithmetic overflow error for data type numeric.)~~ +~~ERROR (Message: smallmoney out of range)~~ SELECT (smallmoney_col / tinyint_col) * 1.13 FROM babel_5899_t1; GO @@ -1266,11 +1262,9 @@ SELECT (money_udt + bigint_col) * 1.13 FROM babel_5899_t1; GO ~~START~~ numeric -1042241040164588.536191 --1042241040164589.666304 -1.141300 - -~~END~~ +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ SELECT (money_udt - int_col) * 2.5 FROM babel_5899_t1; GO @@ -1356,7 +1350,7 @@ GO numeric ~~ERROR (Code: 33557097)~~ -~~ERROR (Message: fixeddecimal out of range)~~ +~~ERROR (Message: smallmoney out of range)~~ SELECT ( @@ -1561,11 +1555,9 @@ SELECT ( GO ~~START~~ numeric --2426656536.1762900 -0E-7 -0E-7 -0E-7 -~~END~~ +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ SELECT ( @@ -1597,10 +1589,9 @@ GO ~~START~~ numeric 0.000000 -1073741830.166500 -0.000000 -0.000000 -~~END~~ +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ SELECT ( diff --git a/test/JDBC/expected/parallel_query/babel_varbinary-vu-verify.out b/test/JDBC/expected/parallel_query/babel_varbinary-vu-verify.out index 447d8fd728f..dec0cffcba6 100644 --- a/test/JDBC/expected/parallel_query/babel_varbinary-vu-verify.out +++ b/test/JDBC/expected/parallel_query/babel_varbinary-vu-verify.out @@ -715,7 +715,7 @@ Gather ~~START~~ text -Babelfish T-SQL Batch Parsing Time: 7.781 ms +Babelfish T-SQL Batch Parsing Time: 3.848 ms ~~END~~ @@ -732,7 +732,7 @@ Gather ~~START~~ text -Babelfish T-SQL Batch Parsing Time: 0.217 ms +Babelfish T-SQL Batch Parsing Time: 0.236 ms ~~END~~ @@ -749,7 +749,7 @@ Gather ~~START~~ text -Babelfish T-SQL Batch Parsing Time: 7.684 ms +Babelfish T-SQL Batch Parsing Time: 3.615 ms ~~END~~ @@ -768,7 +768,7 @@ Finalize Aggregate ~~START~~ text -Babelfish T-SQL Batch Parsing Time: 33.697 ms +Babelfish T-SQL Batch Parsing Time: 17.170 ms ~~END~~ @@ -787,7 +787,7 @@ Finalize Aggregate ~~START~~ text -Babelfish T-SQL Batch Parsing Time: 0.216 ms +Babelfish T-SQL Batch Parsing Time: 0.203 ms ~~END~~ @@ -923,8 +923,8 @@ ORDER BY float_binary_add; GO ~~START~~ -float#!#float#!#float#!#float#!#float#!#float#!#float#!#datetime#!#float#!#varchar#!#datetime#!#bigint -201.0#!#201.0#!#1100.5#!#200.5#!#110.5#!#101.5#!#201.0#!#1900-04-11 12:00:00.0#!#201.0#!#100.5A1A2A3A4-B1B2-C1C2-D1D2-E1E2E3E4E5E6#!##!#100 +float#!#float#!#float#!#float#!#float#!#float#!#float#!#float#!#float#!#varchar#!#datetime#!#bigint +201.0#!#201.0#!#1100.5#!#200.5#!#110.5#!#101.5#!#201.0#!#100.5#!#201.0#!#100.5A1A2A3A4-B1B2-C1C2-D1D2-E1E2E3E4E5E6#!##!#100 ~~END~~ @@ -958,8 +958,8 @@ ORDER BY real_binary_add; GO ~~START~~ -real#!#float#!#real#!#real#!#real#!#real#!#real#!#datetime#!#real#!#varchar#!#datetime#!#bigint -201.0#!#201.0#!#1100.5#!#200.5#!#110.5#!#101.5#!#201.0#!#1900-04-11 12:00:00.0#!#201.0#!#100.5A1A2A3A4-B1B2-C1C2-D1D2-E1E2E3E4E5E6#!##!#100 +real#!#float#!#real#!#real#!#real#!#real#!#real#!#float#!#real#!#varchar#!#datetime#!#bigint +201.0#!#201.0#!#1100.5#!#200.5#!#110.5#!#101.5#!#201.0#!#100.5#!#201.0#!#100.5A1A2A3A4-B1B2-C1C2-D1D2-E1E2E3E4E5E6#!##!#100 ~~END~~ @@ -1148,7 +1148,6 @@ SELECT bit_col + smallint_col as bit_smallint_add, bit_col + tinyint_col as bit_tinyint_add, bit_col + money_col as bit_money_add, - bit_col + bit_col as bit_bit_add, bit_col + guid_col as bit_guid_add, bit_col + image_col as bit_image_add, bit_col + binary_col as bit_binary_add @@ -1162,14 +1161,13 @@ ORDER BY bit_smallint_add, bit_tinyint_add, bit_money_add, - bit_bit_add, bit_guid_add, bit_image_add, bit_binary_add; GO ~~START~~ -numeric#!#datetime#!#datetime#!#bigint#!#int#!#smallint#!#smallint#!#money#!#datetime#!#varchar#!#datetime#!#bigint -100.50#!#1900-04-11 12:00:00.0#!#1900-04-11 12:00:00.0#!#1000#!#100#!#10#!#1#!#100.5000#!#1900-01-01 00:00:00.0#!#0A1A2A3A4-B1B2-C1C2-D1D2-E1E2E3E4E5E6#!##!#0 +numeric#!#float#!#float#!#bigint#!#int#!#smallint#!#smallint#!#money#!#varchar#!#datetime#!#bigint +100.50#!#100.5#!#100.5#!#1000#!#100#!#10#!#1#!#100.5000#!#0A1A2A3A4-B1B2-C1C2-D1D2-E1E2E3E4E5E6#!##!#0 ~~END~~ diff --git a/test/JDBC/expected/parallel_query/money_smallmoney-vu-cleanup.out b/test/JDBC/expected/parallel_query/money_smallmoney-vu-cleanup.out new file mode 100644 index 00000000000..0010f7f876e --- /dev/null +++ b/test/JDBC/expected/parallel_query/money_smallmoney-vu-cleanup.out @@ -0,0 +1,80 @@ +DROP VIEW int2smallmoneyadd_vu; +GO + +DROP VIEW int4smallmoneyadd_vu; +GO + +DROP VIEW int8smallmoneyadd_vu; +GO + +DROP VIEW smallmoneyint2add_vu; +GO + +DROP VIEW smallmoneyint4add_vu; +GO + +DROP VIEW smallmoneyint8add_vu; +GO + +DROP VIEW int2smallmoneymul_vu; +GO + +DROP VIEW int4smallmoneymul_vu; +GO + +DROP FUNCTION int2smallmoney_func() +GO + +DROP FUNCTION int8smallmoney_func() +GO + +DROP FUNCTION bitsmallmoney_func() +GO + +DROP FUNCTION bitmoney_func() +GO + +DROP FUNCTION int4smallmoney_func() +GO + +DROP FUNCTION smallintsmallmoney_func() +GO + +DROP FUNCTION principalsquared_func(sys.MONEY) +GO + +DROP TABLE money_smallmoney_vu_test; +GO + +DROP TABLE MoneyTestTable1 +GO + +DROP VIEW bitsmallmoneypl_vu; +GO + +DROP VIEW bitsmallmoneymi_vu; +GO + +DROP VIEW smallmoneybitpl_vu; +GO + +DROP VIEW smallmoneybitmi_vu; +GO + +DROP VIEW floormaxmoney_vu; +GO + +DROP VIEW ceilingminmoney_vu; +GO + +DROP VIEW powersmallmoneyfail_vu; +GO + +DROP VIEW powermoneyfail_vu; +GO + +DROP VIEW powermoney_vu; +GO + +DROP VIEW powersmallmoney_vu; +GO diff --git a/test/JDBC/expected/parallel_query/money_smallmoney-vu-prepare.out b/test/JDBC/expected/parallel_query/money_smallmoney-vu-prepare.out new file mode 100644 index 00000000000..343a3db5fd6 --- /dev/null +++ b/test/JDBC/expected/parallel_query/money_smallmoney-vu-prepare.out @@ -0,0 +1,200 @@ +-- tsql +CREATE VIEW int2smallmoneyadd_vu AS SELECT cast(100 AS TINYINT) + cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW int4smallmoneyadd_vu AS SELECT cast(100 AS INT) + cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW int8smallmoneyadd_vu AS SELECT cast(100 AS BIGINT) + cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW smallmoneyint2add_vu AS SELECT cast(123.45 AS SMALLMONEY) + cast(100 AS TINYINT) AS result; +GO + +CREATE VIEW smallmoneyint4add_vu AS SELECT cast(123.45 AS SMALLMONEY) + cast(100 as INT) AS result; +GO + +CREATE VIEW smallmoneyint8add_vu AS SELECT cast(123.45 AS SMALLMONEY) + cast(100 as BIGINT) AS result; +GO + +CREATE VIEW int2smallmoneymul_vu AS SELECT cast(100 AS TINYINT) * cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW int4smallmoneymul_vu AS SELECT cast(100 AS INT) * cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW bitsmallmoneypl_vu AS SELECT cast(100 AS BIT) + cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW bitsmallmoneymi_vu AS SELECT cast(100 AS BIT) - cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW smallmoneybitpl_vu AS SELECT cast(123.45 AS SMALLMONEY) + cast(100 AS BIT) AS result; +GO + +CREATE VIEW smallmoneybitmi_vu AS SELECT cast(123.45 AS SMALLMONEY) - cast(100 AS BIT) AS result; +GO + +CREATE VIEW floormaxmoney_vu AS SELECT floor(cast(922337203685477.5807 as MONEY)) AS result; +GO + +CREATE VIEW ceilingminmoney_vu AS SELECT ceiling(cast(-922337203685477.5807 as MONEY)) AS result; +GO + +CREATE VIEW powermoney_vu AS SELECT POWER(cast(-100.5807 as MONEY), 2) AS result; +GO + +CREATE VIEW powermoneyfail_vu AS SELECT POWER(cast(-92233720368.5807 as MONEY), 2) AS result; +GO + +CREATE VIEW powersmallmoney_vu AS SELECT POWER(cast(-100.5807 as SMALLMONEY), 2) AS result; +GO + +CREATE VIEW powersmallmoneyfail_vu AS SELECT POWER(cast(-92233720368.5807 as SMALLMONEY), 2) AS result; +GO + +CREATE FUNCTION principalsquared_func(@amount sys.MONEY) +RETURNS sys.MONEY +AS +BEGIN + RETURN (SELECT POWER(@amount, 2)); +END; +GO + +CREATE FUNCTION int2smallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS TINYINT) * cast(123.45 AS SMALLMONEY) + , cast(100 AS TINYINT) / cast(123.45 AS SMALLMONEY) + , cast(100 AS TINYINT) + cast(123.45 AS SMALLMONEY) + , cast(100 AS TINYINT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS TINYINT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS TINYINT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS TINYINT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS TINYINT); + RETURN 0; +END; +GO + +CREATE FUNCTION smallintsmallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS SMALLINT) * cast(123.45 AS SMALLMONEY) + , cast(100 AS SMALLINT) / cast(123.45 AS SMALLMONEY) + , cast(100 AS SMALLINT) + cast(123.45 AS SMALLMONEY) + , cast(100 AS SMALLINT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS SMALLINT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS SMALLINT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS SMALLINT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS SMALLINT); + RETURN 0; +END; +GO + + +CREATE FUNCTION int8smallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS BIGINT) * cast(123.45 AS SMALLMONEY) + , cast(100 AS BIGINT) / cast(123.45 AS SMALLMONEY) + , cast(100 AS BIGINT) + cast(123.45 AS SMALLMONEY) + , cast(100 AS BIGINT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS BIGINT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS BIGINT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS BIGINT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS BIGINT); + RETURN 0; +END; +GO + +CREATE FUNCTION bitsmallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS BIT) * cast(123.45 AS SMALLMONEY) + , cast(100 AS BIT) / cast(123.45 AS SMALLMONEY) + , cast(100 AS BIT) + cast(123.45 AS SMALLMONEY) + , cast(100 AS BIT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS BIT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS BIT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS BIT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS BIT); + RETURN 0; +END; +GO + +CREATE FUNCTION bitmoney_func() +RETURNS @test TABLE(a money, b money, c money, d money, e money, f money, g money, h money) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS BIT) * cast(123.45 AS MONEY) + , cast(100 AS BIT) / cast(123.45 AS MONEY) + , cast(100 AS BIT) + cast(123.45 AS MONEY) + , cast(100 AS BIT) - cast(123.45 AS MONEY) + , cast(123.45 AS MONEY) * cast(100 AS BIT) + , cast(123.45 AS MONEY) / cast(100 AS BIT) + , cast(123.45 AS MONEY) + cast(100 AS BIT) + , cast(123.45 AS MONEY) - cast(100 AS BIT); + RETURN 0; +END; +GO + +CREATE FUNCTION int4smallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(1000 AS INT) * cast(123.45 AS SMALLMONEY) + , cast(10000 AS INT) / cast(123.45 AS SMALLMONEY) + , cast(10000 AS INT) + cast(123.45 AS SMALLMONEY) + , cast(10000 AS INT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS INT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS INT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS INT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS INT); + RETURN; +END; +GO + +CREATE TABLE money_smallmoney_vu_test(id SERIAL, cost_sm SMALLMONEY, cost_m sys.MONEY); +GO + +CREATE INDEX idx_cost_smallmoney on money_smallmoney_vu_test(cost_sm); +GO + +CREATE INDEX idx_cost_money on money_smallmoney_vu_test(cost_m); +GO + +INSERT INTO money_smallmoney_vu_test(cost_sm, cost_m) VALUES +(100,2000), (200,40), (400,20), (300, 500), (100, 1000), +(10,100), (10,40000), (125,20), (50, 590), (300, 900), +(100,100), (10,40000), (125,20), (50, 590), (300, 900); +GO +~~ROW COUNT: 15~~ + + +-- tsql + +-- Create test tables +CREATE TABLE MoneyTestTable1 ( + ID INT IDENTITY(1,1), + MoneyVal MONEY, + SmallMoneyVal SMALLMONEY, + Description VARCHAR(100) +); +-- Test default values +INSERT INTO MoneyTestTable1 DEFAULT VALUES; +GO +~~ROW COUNT: 1~~ + + + + diff --git a/test/JDBC/expected/parallel_query/money_smallmoney-vu-verify.out b/test/JDBC/expected/parallel_query/money_smallmoney-vu-verify.out new file mode 100644 index 00000000000..51aaf52fbb6 --- /dev/null +++ b/test/JDBC/expected/parallel_query/money_smallmoney-vu-verify.out @@ -0,0 +1,8082 @@ +-- psql +-- analyze the money_smallmoney_vu_test created +ANALYZE master_dbo.money_smallmoney_vu_test; +GO + +-- tsql +-- Display results +SELECT 'Range Test Results' AS TestName, * FROM MoneyTestTable1 where Description NOT LIKE 'Random values'; +GO +~~START~~ +varchar#!#int#!#money#!#smallmoney#!#varchar +~~END~~ + + +-- tsql +-- ============================================= +-- 1.Select from dependent objects +-- ============================================= +SELECT * FROM dbo.int2smallmoneyadd_vu; +GO +~~START~~ +smallmoney +223.4500 +~~END~~ + + +SELECT * FROM dbo.int4smallmoneyadd_vu; +GO +~~START~~ +smallmoney +223.4500 +~~END~~ + + +SELECT * FROM dbo.int8smallmoneyadd_vu; +GO +~~START~~ +smallmoney +223.4500 +~~END~~ + + +SELECT * FROM dbo.smallmoneyint2add_vu; +GO +~~START~~ +smallmoney +223.4500 +~~END~~ + + +SELECT * FROM dbo.smallmoneyint4add_vu; +GO +~~START~~ +smallmoney +223.4500 +~~END~~ + + +SELECT * FROM dbo.smallmoneyint8add_vu; +GO +~~START~~ +smallmoney +223.4500 +~~END~~ + + +SELECT * FROM dbo.int2smallmoneymul_vu; +GO +~~START~~ +smallmoney +12345.0000 +~~END~~ + + +SELECT * FROM dbo.int4smallmoneymul_vu; +GO +~~START~~ +smallmoney +12345.0000 +~~END~~ + + +SELECT * FROM dbo.bitsmallmoneypl_vu; +GO +~~START~~ +smallmoney +124.4500 +~~END~~ + + +SELECT * FROM dbo.bitsmallmoneymi_vu; +GO +~~START~~ +smallmoney +-122.4500 +~~END~~ + + +SELECT * FROM dbo.smallmoneybitpl_vu; +GO +~~START~~ +smallmoney +124.4500 +~~END~~ + + +SELECT * FROM dbo.smallmoneybitmi_vu; +GO +~~START~~ +smallmoney +122.4500 +~~END~~ + + +SELECT * FROM dbo.floormaxmoney_vu; +GO +~~START~~ +money +922337203685477.0000 +~~END~~ + + +SELECT * FROM dbo.ceilingminmoney_vu; +GO +~~START~~ +money +-922337203685477.0000 +~~END~~ + + +SELECT * FROM dbo.powersmallmoney_vu; +GO +~~START~~ +money +10116.4772 +~~END~~ + + +SELECT * FROM dbo.powermoney_vu; +GO +~~START~~ +money +10116.4772 +~~END~~ + + +SELECT * FROM dbo.powersmallmoneyfail_vu; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: FIXEDDECIMAL field overflow)~~ + + +SELECT * FROM dbo.powermoneyfail_vu; +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT * FROM dbo.int4smallmoney_func(); +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +123450.0000#!#81.0045#!#10123.4500#!#9876.5500#!#12345.0000#!#1.2345#!#223.4500#!#23.4500 +~~END~~ + + +SELECT * FROM dbo.bitsmallmoney_func(); +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +123.4500#!#0.0081#!#124.4500#!#-122.4500#!#123.4500#!#123.4500#!#124.4500#!#122.4500 +~~END~~ + + +SELECT * FROM dbo.int8smallmoney_func(); +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +12345.0000#!#0.8100#!#223.4500#!#-23.4500#!#12345.0000#!#1.2345#!#223.4500#!#23.4500 +~~END~~ + + +SELECT * FROM dbo.int2smallmoney_func(); +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +12345.0000#!#0.8100#!#223.4500#!#-23.4500#!#12345.0000#!#1.2345#!#223.4500#!#23.4500 +~~END~~ + + +SELECT * FROM dbo.smallintsmallmoney_func(); +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +12345.0000#!#0.8100#!#223.4500#!#-23.4500#!#12345.0000#!#1.2345#!#223.4500#!#23.4500 +~~END~~ + + +SELECT principalsquared_func(cast(1000.450 as money)); +GO +~~START~~ +money +1000900.2025 +~~END~~ + + +-- =============================================================== +-- 2.Check if index is picked up for all arithmetic operations +-- =============================================================== +SELECT set_config('enable_seqscan', 'off', false); +GO +~~START~~ +text +off +~~END~~ + + +SELECT set_config('babelfishpg_tsql.explain_costs', 'off', false) +GO +~~START~~ +text +off +~~END~~ + + +SET babelfish_showplan_all ON; +GO + +SELECT * FROM money_smallmoney_vu_test WHERE cost_sm BETWEEN 100 and 200; +GO +~~START~~ +text +Query Text: SELECT * FROM money_smallmoney_vu_test WHERE cost_sm BETWEEN 100 and 200 +Gather + Workers Planned: 1 + Single Copy: true + -> Index Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: (((cost_sm)::fixeddecimal >= 100) AND ((cost_sm)::fixeddecimal <= 200)) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 6.122 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm > 100; +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm > 100 +Gather + Workers Planned: 1 + Single Copy: true + -> Aggregate + -> Index Only Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: (cost_sm > 100) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 19.380 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm <= CAST(50 AS SMALLMONEY) + CAST(50 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm <= CAST(50 AS SMALLMONEY) + CAST(50 AS SMALLMONEY) +Aggregate + -> Index Only Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: (cost_sm <= ((('50.0000'::fixeddecimal(10,4))::smallmoney(655368) + ('50.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 3.632 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm = CAST(2 AS INT) * CAST(50 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm = CAST(2 AS INT) * CAST(50 AS SMALLMONEY) +Aggregate + -> Index Only Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: (cost_sm = ((2 * ('50.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.735 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm > CAST(200 AS INT) / CAST(2 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm > CAST(200 AS INT) / CAST(2 AS SMALLMONEY) +Aggregate + -> Index Only Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: (cost_sm > ((200 / ('2.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 2.625 ms +~~END~~ + + +SELECT cost_sm FROM money_smallmoney_vu_test WHERE cost_sm <= CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT cost_sm FROM money_smallmoney_vu_test WHERE cost_sm <= CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY) +Index Only Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: (cost_sm <= (('200'::bigint * ('2.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.269 ms +~~END~~ + + +SELECT * FROM money_smallmoney_vu_test WHERE cost_sm < CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT * FROM money_smallmoney_vu_test WHERE cost_sm < CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY) +Index Scan using idx_cost_smallmoneymoney_smallm763569c9206bb1e36c4670199725a26c on money_smallmoney_vu_test + Index Cond: ((cost_sm)::fixeddecimal < (('200'::bigint * ('2.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 2.823 ms +~~END~~ + + +SELECT * FROM money_smallmoney_vu_test WHERE cost_m BETWEEN 100 and 200; +GO +~~START~~ +text +Query Text: SELECT * FROM money_smallmoney_vu_test WHERE cost_m BETWEEN 100 and 200 +Gather + Workers Planned: 1 + Single Copy: true + -> Index Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: (((cost_m)::fixeddecimal >= 100) AND ((cost_m)::fixeddecimal <= 200)) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.089 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m > 100; +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m > 100 +Gather + Workers Planned: 1 + Single Copy: true + -> Aggregate + -> Index Only Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: (cost_m > 100) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.099 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m >= CAST(50 AS SMALLMONEY) + CAST(50 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m >= CAST(50 AS SMALLMONEY) + CAST(50 AS SMALLMONEY) +Aggregate + -> Index Only Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: (cost_m >= ((('50.0000'::fixeddecimal(10,4))::smallmoney(655368) + ('50.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.593 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m = CAST(2 AS INT) * CAST(50 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m = CAST(2 AS INT) * CAST(50 AS SMALLMONEY) +Aggregate + -> Index Only Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: (cost_m = ((2 * ('50.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.141 ms +~~END~~ + + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m < CAST(200 AS INT) / CAST(2 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m < CAST(200 AS INT) / CAST(2 AS SMALLMONEY) +Aggregate + -> Index Only Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: (cost_m < ((200 / ('2.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.145 ms +~~END~~ + + +SELECT cost_m FROM money_smallmoney_vu_test WHERE cost_m < CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT cost_m FROM money_smallmoney_vu_test WHERE cost_m < CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY) +Index Only Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: (cost_m < (('200'::bigint * ('2.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.185 ms +~~END~~ + + +SELECT * FROM money_smallmoney_vu_test WHERE cost_m > CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY); +GO +~~START~~ +text +Query Text: SELECT * FROM money_smallmoney_vu_test WHERE cost_m > CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY) +Index Scan using idx_cost_moneymoney_smallmoney_561673fc5dd7f27d48118a464f7209db on money_smallmoney_vu_test + Index Cond: ((cost_m)::fixeddecimal > (('200'::bigint * ('2.0000'::fixeddecimal(10,4))::smallmoney(655368)))::fixeddecimal) +~~END~~ + +~~START~~ +text +Babelfish T-SQL Batch Parsing Time: 0.172 ms +~~END~~ + + +SET babelfish_showplan_all OFF; +GO + +SELECT set_config('enable_seqscan', 'on', false); +GO +~~START~~ +text +on +~~END~~ + +-- ============================================= +-- 3.Overflow Tests +-- ============================================= +INSERT INTO MoneyTestTable1 (MoneyVal, Description) VALUES (922337203685477.5808, 'Overflow MONEY test'); -- Exceeds maximum +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value "922337203685477.5808" is out of range for type fixeddecimal)~~ + + +INSERT INTO MoneyTestTable1 (SmallMoneyVal, Description) VALUES (214748.3648, 'Overflow SMALLMONEY test'); -- Exceeds maximum +GO +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + +INSERT INTO MoneyTestTable1 (MoneyVal, Description) VALUES (-922337203685477.5809, 'Underflow MONEY test'); -- Below minimum +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value "-922337203685477.5809" is out of range for type fixeddecimal)~~ + + +INSERT INTO MoneyTestTable1 (SmallMoneyVal, Description) VALUES (-214748.3649, 'Underflow SMALLMONEY test'); -- Below minimum +GO +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + +-- Try Overflow with Arithematic Operators +-- ============================================= +-- Result Overflows +-- ============================================= +-- + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS SMALLMONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS TINYINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS SMALLINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS INT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS BIT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS MONEY) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS SMALLMONEY) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS TINYINT) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS SMALLINT) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS INT) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS BIGINT) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS BIT) + CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS REAL); +GO +~~START~~ +real +9.2233718E14 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS FLOAT); +GO +~~START~~ +float +9.223372036854786E14 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS MONEY); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS SMALLMONEY); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS TINYINT); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS SMALLINT); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS INT); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS BIGINT); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS BIT); +GO +~~START~~ +money +922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS MONEY) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS SMALLMONEY) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS TINYINT) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS SMALLINT) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS INT) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS BIGINT) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + +SELECT CAST(1 AS BIT) - CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +-922337203685476.5807 +~~END~~ + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- - +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS SMALLMONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS TINYINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS SMALLINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS INT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS BIT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS BIGINT) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS MONEY) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS SMALLMONEY) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS TINYINT) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS SMALLINT) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS INT) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS BIGINT) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1 AS BIT) - CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS REAL); +GO +~~START~~ +real +-9.2233718E14 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS FLOAT); +GO +~~START~~ +float +-9.223372036854786E14 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS SMALLMONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS TINYINT); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS SMALLINT); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS INT); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS BIT); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(0 AS BIT); +GO +~~START~~ +money +-922337203685477.5808 +~~END~~ + +SELECT CAST(1 AS BIGINT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS MONEY) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS SMALLMONEY) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS TINYINT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS SMALLINT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS INT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS BIGINT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(1 AS BIT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685476.5808 +~~END~~ + +SELECT CAST(0 AS BIT) + CAST(-922337203685477.5808 AS MONEY); +GO +~~START~~ +money +-922337203685477.5808 +~~END~~ + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1.1 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1.1 AS SMALLMONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(2 AS TINYINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(2 AS SMALLINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(2 AS INT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(2 AS BIGINT); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1 AS BIT); +GO +~~START~~ +money +922337203685477.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(0 AS BIT); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1.1 AS MONEY) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(1.1 AS SMALLMONEY) * CAST(922337203685477.5807 AS MONEY);; +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(2 AS TINYINT) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(2 AS SMALLINT) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(2 AS INT) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(2 AS BIGINT) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(0 AS BIT) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(1 AS BIT) * CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +922337203685477.5807 +~~END~~ + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1.1 AS REAL); +GO +~~START~~ +real +1.01457093E15 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1.1 AS FLOAT); +GO +~~START~~ +float +1.0145709240540255E15 +~~END~~ + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- - +SELECT CAST(-922337203685477.5808 AS MONEY) / CAST(0.9 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) / CAST(0.9 AS SMALLMONEY); +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS TINYINT); +GO +~~START~~ +money +461168601842738.7903 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS SMALLINT); +GO +~~START~~ +money +461168601842738.7903 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS INT); +GO +~~START~~ +money +461168601842738.7903 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS BIGINT); +GO +~~START~~ +money +461168601842738.7903 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +1.0000 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS BIT); +GO +~~START~~ +money +922337203685477.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(500 AS BIT); +GO +~~START~~ +money +922337203685477.5807 +~~END~~ + +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(0 AS BIT); +GO +~~START~~ +money +~~ERROR (Code: 8134)~~ + +~~ERROR (Message: division by zero)~~ + +SELECT CAST(1.1 AS MONEY) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(1.1 AS SMALLMONEY) / CAST(922337203685477.5807 AS MONEY);; +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(2 AS TINYINT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(2 AS SMALLINT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(2 AS INT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(2 AS BIGINT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(2 AS BIT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(1 AS BIT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(500 AS BIT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT CAST(0 AS BIT) / CAST(922337203685477.5807 AS MONEY); +GO +~~START~~ +money +0.0000 +~~END~~ + + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(-922337203685477.5808 AS MONEY) / CAST(0.9 AS REAL); +GO +~~START~~ +real +-1.02481913E15 +~~END~~ + +SELECT CAST(-922337203685477.5808 AS MONEY) / CAST(0.9 AS FLOAT); +GO +~~START~~ +float +-1.0248191152060862E15 +~~END~~ + + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS TINYINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS SMALLINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS BIGINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS SMALLMONEY) + CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS TINYINT) + CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(1 AS SMALLINT) + CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS INT) + CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS BIGINT) + CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS MONEY); +GO +~~START~~ +money +214749.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS REAL); +GO +~~START~~ +real +214749.36 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS FLOAT); +GO +~~START~~ +float +214749.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214747.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS TINYINT); +GO +~~START~~ +smallmoney +214747.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS SMALLINT); +GO +~~START~~ +smallmoney +214747.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS INT); +GO +~~START~~ +smallmoney +214747.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS BIGINT); +GO +~~START~~ +smallmoney +214747.3647 +~~END~~ + +SELECT CAST(1 AS SMALLMONEY) - CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3647 +~~END~~ + +SELECT CAST(1 AS TINYINT) - CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3647 +~~END~~ + +SELECT CAST(1 AS SMALLINT) - CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3647 +~~END~~ + +SELECT CAST(1 AS INT) - CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3647 +~~END~~ + +SELECT CAST(1 AS BIGINT) - CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3647 +~~END~~ + + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- - +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS TINYINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS SMALLINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS BIGINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(0 AS BIT); +GO +~~START~~ +smallmoney +-214748.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS BIT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(1 AS SMALLMONEY) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS TINYINT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(1 AS SMALLINT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS INT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS BIGINT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1 AS BIT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(0 AS BIT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS MONEY); +GO +~~START~~ +money +-214749.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS REAL); +GO +~~START~~ +real +-214749.36 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS FLOAT); +GO +~~START~~ +float +-214749.3648 +~~END~~ + +SELECT CAST(1 AS MONEY) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +money +214749.3648 +~~END~~ + +SELECT CAST(1 AS REAL) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +real +214749.36 +~~END~~ + +SELECT CAST(1 AS FLOAT) - CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +float +214749.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS TINYINT); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS SMALLINT); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS INT); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS BIGINT); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(1 AS SMALLMONEY) + CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(1 AS TINYINT) + CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(1 AS SMALLINT) + CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(1 AS INT) + CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(1 AS BIGINT) + CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-214747.3648 +~~END~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) + CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- * +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS TINYINT); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS SMALLINT); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS INT); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1.1 AS SMALLMONEY) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(1.1 AS TINYINT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(1.1 AS SMALLINT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(1.1 AS INT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(1 AS BIT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + +SELECT CAST(0 AS BIT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +0.0000 +~~END~~ + +SELECT CAST(500 AS BIT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +smallmoney +214748.3647 +~~END~~ + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS MONEY); +GO +~~START~~ +money +236223.2012 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS REAL); +GO +~~START~~ +real +236223.2 +~~END~~ + +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS FLOAT); +GO +~~START~~ +float +236223.20117000001 +~~END~~ + +SELECT CAST(1.1 AS MONEY) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +money +236223.2012 +~~END~~ + +SELECT CAST(1.1 AS REAL) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +real +236223.2 +~~END~~ + +SELECT CAST(1.1 AS FLOAT) * CAST(214748.3647 AS SMALLMONEY); +GO +~~START~~ +float +236223.20117000001 +~~END~~ + +SELECT CAST(-214748.3647 AS SMALLMONEY) * CAST(1.1 AS MONEY); +GO +~~START~~ +money +-236223.2012 +~~END~~ + +SELECT CAST(-214748.3647 AS SMALLMONEY) * CAST(1.1 AS REAL); +GO +~~START~~ +real +-236223.2 +~~END~~ + +SELECT CAST(-214748.3647 AS SMALLMONEY) * CAST(1.1 AS FLOAT); +GO +~~START~~ +float +-236223.20117000001 +~~END~~ + +SELECT CAST(1.1 AS MONEY) * CAST(-214748.3647 AS SMALLMONEY); +GO +~~START~~ +money +-236223.2012 +~~END~~ + +SELECT CAST(1.1 AS REAL) * CAST(-214748.3647 AS SMALLMONEY); +GO +~~START~~ +real +-236223.2 +~~END~~ + +SELECT CAST(1.1 AS FLOAT) * CAST(-214748.3647 AS SMALLMONEY); +GO +~~START~~ +float +-236223.20117000001 +~~END~~ + + + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- / +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(0.9 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(214749 AS BIGINT); +GO +~~START~~ +smallmoney +-0.9999 +~~END~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(0.9 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(214749 AS BIGINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(0.9 AS MONEY); +GO +~~START~~ +money +-238609.2942 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(0.9 AS REAL); +GO +~~START~~ +real +-238609.3 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(0.9 AS FLOAT); +GO +~~START~~ +float +-238609.29422222223 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(2 AS BIGINT); +GO +~~START~~ +smallmoney +-107374.1824 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(1 AS TINYINT); +GO +~~START~~ +smallmoney +-214748.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(60 AS SMALLINT); +GO +~~START~~ +smallmoney +-3579.1394 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(43 AS INT); +GO +~~START~~ +smallmoney +-4994.1480 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(10000 AS BIGINT); +GO +~~START~~ +smallmoney +-21.4748 +~~END~~ + +SELECT CAST(0.9 AS SMALLMONEY) / CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +0.0000 +~~END~~ + +SELECT CAST(2 AS BIGINT) / CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +0.0000 +~~END~~ + +SELECT CAST(1 AS TINYINT) / CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +0.0000 +~~END~~ + +SELECT CAST(60 AS SMALLINT) / CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-0.0003 +~~END~~ + +SELECT CAST(43 AS INT) / CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-0.0002 +~~END~~ + +SELECT CAST(10000 AS BIGINT) / CAST(-214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +-0.0466 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(214748 AS BIGINT); +GO +~~START~~ +smallmoney +-1.0000 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(1 AS BIT); +GO +~~START~~ +smallmoney +-214748.3648 +~~END~~ + +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(214748 AS BIT); +GO +~~START~~ +smallmoney +-214748.3648 +~~END~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(0.9 AS MONEY); +GO +~~START~~ +money +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(0.9 AS REAL); +GO +~~START~~ +real +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(0.9 AS FLOAT); +GO +~~START~~ +float +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(2 AS BIGINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(1 AS TINYINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(60 AS SMALLINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(43 AS INT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(10000 AS BIGINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(0.9 AS SMALLMONEY) / CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(2 AS BIGINT) / CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(1 AS TINYINT) / CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(60 AS SMALLINT) / CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(43 AS INT) / CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(10000 AS BIGINT) / CAST(214748.3648 AS SMALLMONEY); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(214748 AS BIGINT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(1 AS BIT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(214748 AS BIT); +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + + + + +-- ============================================= +-- Result Overflows +-- ============================================= +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) * CAST(1.0001 as SMALLMONEY) +END +GO +~~START~~ +numeric +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(922337203685477.5807 as MONEY) * CAST(1.0001 as MONEY) +END +GO +~~START~~ +numeric +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) + CAST(214748.3647 as SMALLMONEY) +END +GO +~~START~~ +numeric +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) / CAST(0.5 as SMALLMONEY) +END +GO +~~START~~ +numeric +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(-214748.3647 as SMALLMONEY) * CAST(1.001 as SMALLMONEY) +END +GO +~~START~~ +numeric +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as MONEY) * CAST(1.0001 as MONEY) +END +GO +~~START~~ +numeric +214769.8395 +~~END~~ + +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) + CAST(214748.3647 as MONEY) +END +GO +~~START~~ +numeric +429496.7294 +~~END~~ + +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) / CAST(0.5 as MONEY) +END +GO +~~START~~ +numeric +429496.7294 +~~END~~ + + + +------------------------------------------------------------------------ +---- 3. Arithmetic Operations Tests +------------------------------------------------------------------------ +-- Addition (+) operator tests with MONEY +-- MONEY + MONEY +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +802.3500 +~~END~~ + + +-- MONEY + SMALLMONEY +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +money +802.3500 +~~END~~ + + +-- MONEY + TINYINT +SELECT CAST(123.45 AS MONEY) + CAST(255 AS TINYINT) AS result; +GO +~~START~~ +money +378.4500 +~~END~~ + + +-- MONEY + SMALLINT +SELECT CAST(123.45 AS MONEY) + CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +money +32890.4500 +~~END~~ + + +-- MONEY + INT +SELECT CAST(123.45 AS MONEY) + CAST(2147483647 AS INT) AS result; +GO +~~START~~ +money +2147483770.4500 +~~END~~ + + +-- MONEY + BIGINT +SELECT CAST(123.45 AS MONEY) + CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +-- MONEY + REAL +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +802.35004 +~~END~~ + + +-- MONEY + FLOAT +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +802.35 +~~END~~ + + +-- MONEY + NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +802.3500 +~~END~~ + + +-- MONEY + NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) + CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +802.3512 +~~END~~ + + +-- MONEY + NUMERIC(18,6) +SELECT CAST(123.45 AS MONEY) + CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO +~~START~~ +numeric +802.351234 +~~END~~ + + +-- MONEY + BIT +SELECT CAST(123.45 AS MONEY) + CAST(1 AS BIT) AS result; +GO +~~START~~ +money +124.4500 +~~END~~ + + +-- BIT + MONEY +SELECT CAST(1 AS BIT) + CAST(123.45 AS MONEY) AS result; +GO +~~START~~ +money +124.4500 +~~END~~ + + +-- BIT + MONEY +SELECT CAST(0 AS BIT) + CAST(123.45 AS MONEY) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- BIT + MONEY +SELECT CAST(-32 AS BIT) + CAST(123.45 AS MONEY) AS result; +GO +~~START~~ +money +124.4500 +~~END~~ + + +-- BIT + MONEY +SELECT CAST(32 AS BIT) + CAST(123.45 AS MONEY) AS result; +GO +~~START~~ +money +124.4500 +~~END~~ + + +-- Subtraction (-) operator tests with MONEY +-- MONEY - MONEY +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +-555.4500 +~~END~~ + + +-- MONEY - SMALLMONEY +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +money +-555.4500 +~~END~~ + + +-- MONEY - TINYINT +SELECT CAST(123.45 AS MONEY) - CAST(255 AS TINYINT) AS result; +GO +~~START~~ +money +-131.5500 +~~END~~ + + +-- MONEY - SMALLINT +SELECT CAST(123.45 AS MONEY) - CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +money +-32643.5500 +~~END~~ + + +-- MONEY - INT +SELECT CAST(123.45 AS MONEY) - CAST(2147483647 AS INT) AS result; +GO +~~START~~ +money +-2147483523.5500 +~~END~~ + + +-- MONEY - BIGINT +SELECT CAST(123.45 AS MONEY) - CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +-- MONEY - REAL +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +-555.45 +~~END~~ + + +-- MONEY - FLOAT +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +-555.4499999999999 +~~END~~ + + +-- MONEY - NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +-555.4500 +~~END~~ + + +-- MONEY - NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) - CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +-555.4512 +~~END~~ + + +-- MONEY - NUMERIC(18,6) +SELECT CAST(123.45 AS MONEY) - CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO +~~START~~ +numeric +-555.451234 +~~END~~ + + +-- MONEY - BIT +SELECT CAST(123.45 AS MONEY) - CAST(1 AS BIT) AS result; +GO +~~START~~ +money +122.4500 +~~END~~ + + +-- MONEY * MONEY +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +83810.2050 +~~END~~ + + +-- MONEY * SMALLMONEY +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +money +83810.2050 +~~END~~ + + +-- MONEY * TINYINT +SELECT CAST(123.45 AS MONEY) * CAST(255 AS TINYINT) AS result; +GO +~~START~~ +money +31479.7500 +~~END~~ + + +-- MONEY * SMALLINT +SELECT CAST(123.45 AS MONEY) * CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +money +4045086.1500 +~~END~~ + + +-- MONEY * INT +SELECT CAST(123.45 AS MONEY) * CAST(2147483647 AS INT) AS result; +GO +~~START~~ +money +265106856222.1500 +~~END~~ + + +-- MONEY * BIGINT +SELECT CAST(123.45 AS MONEY) * CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +-- MONEY * REAL +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +83810.2 +~~END~~ + + +-- MONEY * FLOAT +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +83810.205 +~~END~~ + + +-- MONEY * NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +83810.205000 +~~END~~ + + +-- MONEY * NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) * CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +83810.35314000 +~~END~~ + + +-- MONEY * BIT +SELECT CAST(123.45 AS MONEY) * CAST(1 AS BIT) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- Division (/) operator tests with MONEY +-- MONEY / MONEY +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +0.1818 +~~END~~ + + +-- MONEY / SMALLMONEY +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +money +0.1818 +~~END~~ + + +-- MONEY / TINYINT +SELECT CAST(123.45 AS MONEY) / CAST(255 AS TINYINT) AS result; +GO +~~START~~ +money +0.4841 +~~END~~ + + +-- MONEY / SMALLINT +SELECT CAST(123.45 AS MONEY) / CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +money +0.0037 +~~END~~ + + +-- MONEY / INT +SELECT CAST(123.45 AS MONEY) / CAST(2147483647 AS INT) AS result; +GO +~~START~~ +money +0.0000 +~~END~~ + + +-- MONEY / BIGINT +SELECT CAST(123.45 AS MONEY) / CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +money +0.0000 +~~END~~ + + +-- MONEY / REAL +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +0.18183826 +~~END~~ + + +-- MONEY / FLOAT +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +0.18183826778612464 +~~END~~ + + +-- MONEY / NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +0.1818382677 +~~END~~ + + +-- MONEY / NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) / CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +0.181837946375702 +~~END~~ + + +-- MONEY / NUMERIC(18,6) +SELECT CAST(123.45 AS MONEY) / CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO +~~START~~ +numeric +0.18183793726909030 +~~END~~ + + +-- MONEY / BIT +SELECT CAST(123.45 AS MONEY) / CAST(1 AS BIT) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- Modulo (%) operator tests with MONEY +-- MONEY % MONEY +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- MONEY % SMALLMONEY +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- MONEY % TINYINT +SELECT CAST(123.45 AS MONEY) % CAST(255 AS TINYINT) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- MONEY % SMALLINT +SELECT CAST(123.45 AS MONEY) % CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- MONEY % INT +SELECT CAST(123.45 AS MONEY) % CAST(2147483647 AS INT) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- MONEY % BIGINT +SELECT CAST(123.45 AS MONEY) % CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value "9223372036854775807" is out of range for type money)~~ + + + +-- MONEY % REAL +-- FIXME: To be fixed in BABEL-5746 +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS REAL) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + + +-- MONEY % FLOAT +-- FIXME: To be fixed in BABEL-5746 +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + + +-- MONEY % NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +123.4500 +~~END~~ + + +-- MONEY % NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) % CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +123.4500 +~~END~~ + + +-- MONEY % NUMERIC(18,6) +SELECT CAST(123.45 AS MONEY) % CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO +~~START~~ +numeric +123.450000 +~~END~~ + + +-- MONEY % BIT +SELECT CAST(123.45 AS MONEY) % CAST(1 AS BIT) AS result; +GO +~~START~~ +money +0.4500 +~~END~~ + + + +-- Addition (+) operator tests with SMALLMONEY +-- SMALLMONEY + MONEY +SELECT CAST(123.45 AS SMALLMONEY) + CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +802.3500 +~~END~~ + + +-- SMALLMONEY + SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) + CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +smallmoney +802.3500 +~~END~~ + + +-- SMALLMONEY + TINYINT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(255 AS TINYINT) AS result; +GO +~~START~~ +smallmoney +378.4500 +~~END~~ + + +-- SMALLMONEY + SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +smallmoney +32890.4500 +~~END~~ + + +-- SMALLMONEY + INT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(2147483647 AS INT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +-- SMALLMONEY + BIGINT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +-- SMALLMONEY + REAL +SELECT CAST(123.45 AS SMALLMONEY) + CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +802.35004 +~~END~~ + + +-- SMALLMONEY + FLOAT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +802.35 +~~END~~ + + +-- SMALLMONEY + BIT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(1 AS BIT) AS result; +GO +~~START~~ +smallmoney +124.4500 +~~END~~ + + +-- Subtraction (-) operator tests with SMALLMONEY +-- SMALLMONEY - MONEY +SELECT CAST(123.45 AS SMALLMONEY) - CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +-555.4500 +~~END~~ + + +-- SMALLMONEY - SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) - CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +smallmoney +-555.4500 +~~END~~ + + +-- SMALLMONEY - TINYINT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(255 AS TINYINT) AS result; +GO +~~START~~ +smallmoney +-131.5500 +~~END~~ + + +-- SMALLMONEY - SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +smallmoney +-32643.5500 +~~END~~ + + + +-- SMALLMONEY - INT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(2147483647 AS INT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + + +-- SMALLMONEY - BIGINT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +-- SMALLMONEY - REAL +SELECT CAST(123.45 AS SMALLMONEY) - CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +-555.45 +~~END~~ + + +-- SMALLMONEY - FLOAT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +-555.4499999999999 +~~END~~ + + + +-- SMALLMONEY - BIT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(1 AS BIT) AS result; +GO +~~START~~ +smallmoney +122.4500 +~~END~~ + + +-- Multiplication (*) operator tests with SMALLMONEY +-- SMALLMONEY * MONEY +SELECT CAST(123.45 AS SMALLMONEY) * CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +83810.2050 +~~END~~ + + +-- SMALLMONEY * SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) * CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +smallmoney +83810.2050 +~~END~~ + + +-- SMALLMONEY * TINYINT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(255 AS TINYINT) AS result; +GO +~~START~~ +smallmoney +31479.7500 +~~END~~ + + + +-- SMALLMONEY * SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + + +-- SMALLMONEY * INT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(2147483647 AS INT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + + +-- SMALLMONEY * BIGINT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: smallmoney out of range)~~ + + +-- SMALLMONEY * REAL +SELECT CAST(123.45 AS SMALLMONEY) * CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +83810.2 +~~END~~ + + +-- SMALLMONEY * FLOAT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +83810.205 +~~END~~ + + + +-- SMALLMONEY * BIT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(1 AS BIT) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + +-- Division (/) operator tests with SMALLMONEY +-- SMALLMONEY / MONEY +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +0.1818 +~~END~~ + + +-- SMALLMONEY / SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +smallmoney +0.1818 +~~END~~ + + +-- SMALLMONEY / TINYINT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(255 AS TINYINT) AS result; +GO +~~START~~ +smallmoney +0.4841 +~~END~~ + + +-- SMALLMONEY / SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +smallmoney +0.0037 +~~END~~ + + + +-- SMALLMONEY / INT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(2147483647 AS INT) AS result; +GO +~~START~~ +smallmoney +0.0000 +~~END~~ + + + +-- SMALLMONEY / BIGINT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~START~~ +smallmoney +0.0000 +~~END~~ + + +-- SMALLMONEY / REAL +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS REAL) AS result; +GO +~~START~~ +real +0.18183826 +~~END~~ + + +-- SMALLMONEY / FLOAT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +float +0.18183826778612464 +~~END~~ + + + +-- SMALLMONEY / NUMERIC(5,2) +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +0.1818382677 +~~END~~ + + + +-- SMALLMONEY / NUMERIC(10,4) +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +0.181837946375702 +~~END~~ + + + +-- SMALLMONEY / NUMERIC(18,6) +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO +~~START~~ +numeric +0.18183793726909030777000 +~~END~~ + + + +-- SMALLMONEY / BIT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(1 AS BIT) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + +-- Modulo (%) operator tests with SMALLMONEY +SELECT 'Modulo (%) Operator Tests with SMALLMONEY' AS test_description; +GO +~~START~~ +varchar +Modulo (%) Operator Tests with SMALLMONEY +~~END~~ + + +-- SMALLMONEY % MONEY +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS MONEY) AS result; +GO +~~START~~ +money +123.4500 +~~END~~ + + +-- SMALLMONEY % SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS SMALLMONEY) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + +-- SMALLMONEY % TINYINT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(255 AS TINYINT) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + +-- SMALLMONEY % SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(32767 AS SMALLINT) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + +-- SMALLMONEY % INT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(2147483647 AS INT) AS result; +GO +~~START~~ +smallmoney +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain smallmoney violates check constraint "smallmoney_check")~~ + + +-- SMALLMONEY % BIGINT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(9223372036854775807 AS BIGINT) AS result; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value "9223372036854775807" is out of range for type smallmoney)~~ + + + +-- SMALLMONEY % REAL +-- FIXME: To be fixed in BABEL-5746 +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS REAL) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + + +-- SMALLMONEY % FLOAT +-- FIXME: To be fixed in BABEL-5746 +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS FLOAT) AS result; +GO +~~START~~ +smallmoney +123.4500 +~~END~~ + + + +-- SMALLMONEY % NUMERIC(5,2) +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS NUMERIC(5,2)) AS result; +GO +~~START~~ +numeric +123.4500 +~~END~~ + + +-- SMALLMONEY % NUMERIC(10,4) +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO +~~START~~ +numeric +123.4500 +~~END~~ + + +-- SMALLMONEY % NUMERIC(18,6) +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO +~~START~~ +numeric +123.450000 +~~END~~ + + +-- SMALLMONEY % BIT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(1 AS BIT) AS result; +GO +~~START~~ +smallmoney +0.4500 +~~END~~ + + +-- Unary minus (-) operator tests +-- Unary Minus MONEY +SELECT -CAST(123.45 AS MONEY) AS result; +GO +~~START~~ +money +-123.4500 +~~END~~ + + +-- Unary Minus SMALLMONEY +SELECT -CAST(123.45 AS SMALLMONEY) AS result; +GO +~~START~~ +smallmoney +-123.4500 +~~END~~ + + +-- Complex Arithmetic Tests for MONEY +-- Multiple operators in single expression +SELECT (CAST(1234.56 AS MONEY) + CAST(789.12 AS MONEY)) * CAST(2 AS INT) / CAST(3 AS INT) AS result; +GO +~~START~~ +money +1349.1200 +~~END~~ + + +-- Nested calculations +SELECT CAST(100.00 AS MONEY) + (CAST(200.00 AS MONEY) * CAST(3 AS INT)) + (CAST(400.00 AS MONEY) / CAST(2 AS INT)) AS result; +GO +~~START~~ +money +900.0000 +~~END~~ + + +-- Mixed money types calculations +SELECT (CAST(1000.00 AS MONEY) + CAST(500.00 AS SMALLMONEY)) * + (CAST(250.00 AS MONEY) + CAST(125.00 AS SMALLMONEY)) AS result; +GO +~~START~~ +money +562500.0000 +~~END~~ + + +-- Complex percentage calculations +SELECT CAST(1000.00 AS MONEY) + + (CAST(1000.00 AS MONEY) * CAST(0.10 AS FLOAT)) + -- Add 10% + (CAST(1000.00 AS MONEY) * CAST(0.05 AS FLOAT)) -- Add 5% +AS result; +GO +~~START~~ +float +1150.0 +~~END~~ + + +-- Mixed numeric type operations +SELECT (CAST(1000.00 AS MONEY) * CAST(1.5 AS FLOAT)) + + (CAST(500.00 AS MONEY) * CAST(2.5 AS NUMERIC(5,2))) + + (CAST(250.00 AS MONEY) / CAST(2 AS INT)) +AS result; +GO +~~START~~ +float +2875.0 +~~END~~ + + +-- Nested modulo operations +SELECT (CAST(1000.00 AS MONEY) % CAST(300 AS INT)) + + (CAST(500.00 AS MONEY) % CAST(200 AS INT)) AS result; +GO +~~START~~ +money +200.0000 +~~END~~ + + +-- Compound interest calculation +SELECT CAST(1000.00 AS MONEY) * + POWER(CAST(1.05 AS FLOAT), 3) -- 5% interest compounded for 3 periods +AS result; +GO +~~START~~ +float +1157.6250000000002 +~~END~~ + + +-- Tax calculation with multiple rates +SELECT CAST(1000.00 AS MONEY) + + (CAST(1000.00 AS MONEY) * CAST(0.05 AS FLOAT)) + -- State tax 5% + (CAST(1000.00 AS MONEY) * CAST(0.08 AS FLOAT)) + -- County tax 8% + (CAST(1000.00 AS MONEY) * CAST(0.02 AS FLOAT)) -- Special tax 2% +AS total_with_taxes; +GO +~~START~~ +float +1150.0 +~~END~~ + + +-- Complex discount calculation +SELECT CAST(1000.00 AS MONEY) - + (CAST(1000.00 AS MONEY) * CAST(0.20 AS FLOAT)) - -- 20% off + (CAST(50.00 AS MONEY)) + -- Less $50 + (CAST(1000.00 AS MONEY) * CAST(0.05 AS FLOAT)) -- Plus 5% fee +AS final_price; +GO +~~START~~ +float +800.0 +~~END~~ + + +-- Complex division and modulo +SELECT (CAST(1234.56 AS MONEY) / CAST(2 AS INT)) + + (CAST(1234.56 AS MONEY) % CAST(500 AS INT)) + + (CAST(1234.56 AS MONEY) * CAST(0.10 AS FLOAT)) +AS result; +GO +~~START~~ +float +975.296 +~~END~~ + + +-- Complex SMALLMONEY Arithmetic Tests +-- Multiple operators in single expression +SELECT (CAST(123.45 AS SMALLMONEY) + CAST(78.91 AS SMALLMONEY)) * + CAST(2 AS INT) / CAST(3 AS INT) AS result; +GO +~~START~~ +smallmoney +134.9066 +~~END~~ + + +-- Nested calculations +SELECT CAST(100.00 AS SMALLMONEY) + + (CAST(200.00 AS SMALLMONEY) * CAST(3 AS INT)) + + (CAST(400.00 AS SMALLMONEY) / CAST(2 AS INT)) AS result; +GO +~~START~~ +smallmoney +900.0000 +~~END~~ + + +-- Mixed money types calculations +SELECT (CAST(1000.00 AS SMALLMONEY) + CAST(500.00 AS SMALLMONEY)) * + (CAST(250.00 AS MONEY) + CAST(125.00 AS SMALLMONEY)) AS result; +GO +~~START~~ +money +562500.0000 +~~END~~ + + +-- Complex percentage calculations with SMALLMONEY +SELECT CAST(1000.00 AS SMALLMONEY) + + (CAST(1000.00 AS SMALLMONEY) * CAST(0.10 AS FLOAT)) + -- Add 10% + (CAST(1000.00 AS SMALLMONEY) * CAST(0.05 AS FLOAT)) -- Add 5% +AS result; +GO +~~START~~ +float +1150.0 +~~END~~ + + +-- Mixed numeric type operations +SELECT (CAST(1000.00 AS SMALLMONEY) * CAST(1.5 AS FLOAT)) + + (CAST(500.00 AS SMALLMONEY) * CAST(2.5 AS NUMERIC(5,2))) + + (CAST(250.00 AS SMALLMONEY) / CAST(2 AS INT)) +AS result; +GO +~~START~~ +float +2875.0 +~~END~~ + + +-- Price adjustment calculation +SELECT CAST(100.00 AS SMALLMONEY) + + (CAST(100.00 AS SMALLMONEY) * + CASE + WHEN CAST(100.00 AS SMALLMONEY) > CAST(50.00 AS SMALLMONEY) + THEN CAST(0.10 AS FLOAT) + ELSE CAST(0.05 AS FLOAT) + END) +AS adjusted_price; +GO +~~START~~ +float +110.0 +~~END~~ + + +-- Multi-step calculation +SELECT (CAST(100.00 AS SMALLMONEY) * + CAST(1.10 AS FLOAT) + -- Add 10% + CAST(25.00 AS SMALLMONEY)) * -- Add fixed amount + CAST(0.95 AS FLOAT) -- Apply 5% discount +AS result; +GO +~~START~~ +float +128.25 +~~END~~ + + +-- Weighted average price calculation +SELECT (CAST(100.00 AS SMALLMONEY) * CAST(0.7 AS FLOAT)) + + (CAST(200.00 AS SMALLMONEY) * CAST(0.3 AS FLOAT)) +AS weighted_average; +GO +~~START~~ +float +130.0 +~~END~~ + + +-- Complex rounding test +SELECT CAST( + (CAST(123.456 AS FLOAT) * + CAST(100.00 AS SMALLMONEY)) / + CAST(3 AS INT) +AS SMALLMONEY) AS rounded_result; +GO +~~START~~ +smallmoney +4115.2000 +~~END~~ + + +-- Mathematical formula implementation +SELECT CAST(100.00 AS SMALLMONEY) * + POWER(CAST(1 AS FLOAT) + CAST(0.05 AS FLOAT), 4) -- Compound interest +AS future_value; +GO +~~START~~ +float +121.55062500000003 +~~END~~ + + +-- Complex marginal calculation +SELECT CASE + WHEN CAST(1000.00 AS SMALLMONEY) <= CAST(500.00 AS SMALLMONEY) + THEN CAST(1000.00 AS SMALLMONEY) * CAST(1.10 AS FLOAT) + WHEN CAST(1000.00 AS SMALLMONEY) <= CAST(1000.00 AS SMALLMONEY) + THEN CAST(1000.00 AS SMALLMONEY) * CAST(1.20 AS FLOAT) + ELSE CAST(1000.00 AS SMALLMONEY) * CAST(1.30 AS FLOAT) +END AS tiered_pricing; +GO +~~START~~ +float +1200.0 +~~END~~ + + +-- Mixed arithmetic with multiple data types +SELECT (CAST(100.00 AS SMALLMONEY) * CAST(1.1 AS FLOAT)) + + (CAST(50.00 AS SMALLMONEY) / CAST(2 AS INT)) + + (CAST(25.00 AS SMALLMONEY) * CAST(0.8 AS NUMERIC(3,1))) + + CAST(10 AS TINYINT) +AS mixed_calculation; +GO +~~START~~ +float +165.0 +~~END~~ + + + +------------------------------------------------------------------------ +---- 3. Mathematical Functions Tests +------------------------------------------------------------------------ +-- ABS Function +-- MONEY tests +SELECT ABS(CAST(123.45 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +money +123.4500 +~~END~~ + +SELECT ABS(CAST(-123.45 AS MONEY)) AS result; -- Negative MONEY +GO +~~START~~ +money +123.4500 +~~END~~ + +SELECT ABS(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT ABS(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +money +922337203685477.5807 +~~END~~ + +SELECT ABS(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + +SELECT ABS(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +money + +~~END~~ + +SELECT ABS(CAST(-0.0001 AS MONEY)) AS result; -- Small negative MONEY value +GO +~~START~~ +money +0.0001 +~~END~~ + +SELECT ABS(CAST(-0.00 AS MONEY)) AS result; -- Negative zero MONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +-- SMALLMONEY tests +SELECT ABS(CAST(123.45 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +money +123.4500 +~~END~~ + +SELECT ABS(CAST(-123.45 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO +~~START~~ +money +123.4500 +~~END~~ + +SELECT ABS(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +~~START~~ +money +0.0000 +~~END~~ + +SELECT ABS(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +money +214748.3647 +~~END~~ + +SELECT ABS(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value +GO +~~START~~ +money +214748.3648 +~~END~~ + +SELECT ABS(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +money + +~~END~~ + +SELECT ABS(CAST(-0.0001 AS SMALLMONEY)) AS result; -- Small negative SMALLMONEY value +GO +~~START~~ +money +0.0001 +~~END~~ + +SELECT ABS(CAST(-0.00 AS SMALLMONEY)) AS result; -- Negative zero SMALLMONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + + +-- CEILING tests for MONEY +SELECT CEILING(CAST(123.45 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +money +124.0000 +~~END~~ + + +SELECT CEILING(CAST(-123.45 AS MONEY)) AS result; -- Negative MONEY +GO +~~START~~ +money +-123.0000 +~~END~~ + + +SELECT CEILING(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT CEILING(CAST(123.00 AS MONEY)) AS result; -- Integer value MONEY +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT CEILING(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT CEILING(CAST(999.999 AS MONEY)) AS result; -- Value close to next integer +GO +~~START~~ +money +1000.0000 +~~END~~ + + +SELECT CEILING(CAST(-999.001 AS MONEY)) AS result; -- Negative value close to integer +GO +~~START~~ +money +-999.0000 +~~END~~ + + +SELECT CEILING(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT CEILING(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value +GO +~~START~~ +money +-922337203685477.0000 +~~END~~ + + +SELECT CEILING(CAST(0.0001 AS MONEY)) AS result; -- Small positive value +GO +~~START~~ +money +1.0000 +~~END~~ + + + +-- CEILING tests for SMALLMONEY +SELECT CEILING(CAST(123.45 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +money +124.0000 +~~END~~ + + +SELECT CEILING(CAST(-123.45 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO +~~START~~ +money +-123.0000 +~~END~~ + + +SELECT CEILING(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT CEILING(CAST(123.00 AS SMALLMONEY)) AS result; -- Integer value SMALLMONEY +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT CEILING(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT CEILING(CAST(999.999 AS SMALLMONEY)) AS result; -- Value close to next integer +GO +~~START~~ +money +1000.0000 +~~END~~ + + +SELECT CEILING(CAST(-999.001 AS SMALLMONEY)) AS result; -- Negative value close to integer +GO +~~START~~ +money +-999.0000 +~~END~~ + + +SELECT CEILING(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +money +214749.0000 +~~END~~ + + +SELECT CEILING(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value +GO +~~START~~ +money +-214748.0000 +~~END~~ + + +SELECT CEILING(CAST(0.0001 AS SMALLMONEY)) AS result; -- Small positive value +GO +~~START~~ +money +1.0000 +~~END~~ + + + +-- FLOOR tests for MONEY +SELECT FLOOR(CAST(123.45 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT FLOOR(CAST(-123.45 AS MONEY)) AS result; -- Negative MONEY +GO +~~START~~ +money +-124.0000 +~~END~~ + + +SELECT FLOOR(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT FLOOR(CAST(123.00 AS MONEY)) AS result; -- Integer value MONEY +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT FLOOR(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT FLOOR(CAST(999.999 AS MONEY)) AS result; -- Value close to integer +GO +~~START~~ +money +999.0000 +~~END~~ + + +SELECT FLOOR(CAST(-999.001 AS MONEY)) AS result; -- Negative value close to next integer +GO +~~START~~ +money +-1000.0000 +~~END~~ + + +SELECT FLOOR(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +money +922337203685477.0000 +~~END~~ + + +SELECT FLOOR(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +SELECT FLOOR(CAST(0.0001 AS MONEY)) AS result; -- Small positive value +GO +~~START~~ +money +0.0000 +~~END~~ + + + +-- FLOOR tests for SMALLMONEY +SELECT FLOOR(CAST(123.45 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT FLOOR(CAST(-123.45 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO +~~START~~ +money +-124.0000 +~~END~~ + + +SELECT FLOOR(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT FLOOR(CAST(123.00 AS SMALLMONEY)) AS result; -- Integer value SMALLMONEY +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT FLOOR(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT FLOOR(CAST(999.999 AS SMALLMONEY)) AS result; -- Value close to integer +GO +~~START~~ +money +999.0000 +~~END~~ + + +SELECT FLOOR(CAST(-999.001 AS SMALLMONEY)) AS result; -- Negative value close to next integer +GO +~~START~~ +money +-1000.0000 +~~END~~ + + +SELECT FLOOR(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +money +214748.0000 +~~END~~ + + +SELECT FLOOR(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value +GO +~~START~~ +money +-214749.0000 +~~END~~ + + +SELECT FLOOR(CAST(0.0001 AS SMALLMONEY)) AS result; -- Small positive value +GO +~~START~~ +money +0.0000 +~~END~~ + + + +-- ROUND tests for MONEY +SELECT ROUND(CAST(123.45 AS MONEY), 0) AS result; -- MONEY 0 decimals +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT ROUND(CAST(-123.45 AS MONEY), 0) AS result; -- Negative MONEY 0 decimals +GO +~~START~~ +money +-123.0000 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), 1) AS result; -- MONEY 1 decimal +GO +~~START~~ +money +123.5000 +~~END~~ + + +SELECT ROUND(CAST(-123.45 AS MONEY), 1) AS result; -- Negative MONEY 1 decimal +GO +~~START~~ +money +-123.5000 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), 2) AS result; -- MONEY 2 decimals +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), 3) AS result; -- MONEY 3 decimals +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), -1) AS result; -- MONEY negative digits (round to tens) +GO +~~START~~ +money +120.0000 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), -2) AS result; -- MONEY negative digits (round to hundreds) +GO +~~START~~ +money +100.0000 +~~END~~ + + +SELECT ROUND(CAST(NULL AS MONEY), 1) AS result; -- NULL MONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT ROUND(CAST(123.456 AS MONEY), 2) AS result; -- Round up +GO +~~START~~ +money +123.4600 +~~END~~ + + +SELECT ROUND(CAST(123.454 AS MONEY), 2) AS result; -- Round down +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.455 AS MONEY), 2) AS result; -- Round half (banker's rounding) +GO +~~START~~ +money +123.4600 +~~END~~ + + +SELECT ROUND(CAST(-123.456 AS MONEY), 2) AS result; -- Negative round up +GO +~~START~~ +money +-123.4600 +~~END~~ + + +SELECT ROUND(CAST(-123.454 AS MONEY), 2) AS result; -- Negative round down +GO +~~START~~ +money +-123.4500 +~~END~~ + + +SELECT ROUND(CAST(-123.455 AS MONEY), 2) AS result; -- Negative round half +GO +~~START~~ +money +-123.4600 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), 2, 0) AS result; -- Explicit round (default) +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS MONEY), 2, 1) AS result; -- Explicit truncate +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(555.55 AS MONEY), -2, 1) AS result; -- Truncate to hundreds +GO +~~START~~ +money +500.0000 +~~END~~ + + + +-- ROUND tests for SMALLMONEY +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 0) AS result; -- SMALLMONEY 0 decimals +GO +~~START~~ +money +123.0000 +~~END~~ + + +SELECT ROUND(CAST(-123.45 AS SMALLMONEY), 0) AS result; -- Negative SMALLMONEY 0 decimals +GO +~~START~~ +money +-123.0000 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 1) AS result; -- SMALLMONEY 1 decimal +GO +~~START~~ +money +123.5000 +~~END~~ + + +SELECT ROUND(CAST(-123.45 AS SMALLMONEY), 1) AS result; -- Negative SMALLMONEY 1 decimal +GO +~~START~~ +money +-123.5000 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 2) AS result; -- SMALLMONEY 2 decimals +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 3) AS result; -- SMALLMONEY 3 decimals +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), -1) AS result; -- SMALLMONEY negative digits (round to tens) +GO +~~START~~ +money +120.0000 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), -2) AS result; -- SMALLMONEY negative digits (round to hundreds) +GO +~~START~~ +money +100.0000 +~~END~~ + + +SELECT ROUND(CAST(NULL AS SMALLMONEY), 1) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT ROUND(CAST(123.456 AS SMALLMONEY), 2) AS result; -- Round up +GO +~~START~~ +money +123.4600 +~~END~~ + + +SELECT ROUND(CAST(123.454 AS SMALLMONEY), 2) AS result; -- Round down +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.455 AS SMALLMONEY), 2) AS result; -- Round half (banker's rounding) +GO +~~START~~ +money +123.4600 +~~END~~ + + +SELECT ROUND(CAST(-123.456 AS SMALLMONEY), 2) AS result; -- Negative round up +GO +~~START~~ +money +-123.4600 +~~END~~ + + +SELECT ROUND(CAST(-123.454 AS SMALLMONEY), 2) AS result; -- Negative round down +GO +~~START~~ +money +-123.4500 +~~END~~ + + +SELECT ROUND(CAST(-123.455 AS SMALLMONEY), 2) AS result; -- Negative round half +GO +~~START~~ +money +-123.4600 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 2, 0) AS result; -- Explicit round (default) +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 2, 1) AS result; -- Explicit truncate +GO +~~START~~ +money +123.4500 +~~END~~ + + +SELECT ROUND(CAST(555.55 AS SMALLMONEY), -2, 1) AS result; -- Truncate to hundreds +GO +~~START~~ +money +500.0000 +~~END~~ + + +-- SIGN tests for MONEY +SELECT SIGN(CAST(123.45 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT SIGN(CAST(-123.45 AS MONEY)) AS result; -- Negative MONEY +GO +~~START~~ +money +-1.0000 +~~END~~ + + +SELECT SIGN(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT SIGN(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT SIGN(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT SIGN(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value +GO +~~START~~ +money +-1.0000 +~~END~~ + + +SELECT SIGN(CAST(0.0001 AS MONEY)) AS result; -- Small positive value +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT SIGN(CAST(-0.0001 AS MONEY)) AS result; -- Small negative value +GO +~~START~~ +money +-1.0000 +~~END~~ + + +-- SIGN tests for SMALLMONEY +SELECT SIGN(CAST(123.45 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT SIGN(CAST(-123.45 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO +~~START~~ +money +-1.0000 +~~END~~ + + +SELECT SIGN(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT SIGN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +money + +~~END~~ + + +SELECT SIGN(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT SIGN(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value +GO +~~START~~ +money +-1.0000 +~~END~~ + + +SELECT SIGN(CAST(0.0001 AS SMALLMONEY)) AS result; -- Small positive value +GO +~~START~~ +money +1.0000 +~~END~~ + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 14) AS result; -- power which overflows +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 14) AS result; -- Negative base,power which overflows +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 9) AS result; -- big power which does not overflows +GO +~~START~~ +money +6634931404.8357 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 9) AS result; -- Negative base, big power which does not overflows +GO +~~START~~ +money +-6634931404.8357 +~~END~~ + + +SELECT SIGN(CAST(-0.0001 AS SMALLMONEY)) AS result; -- Small negative value +GO +~~START~~ +money +-1.0000 +~~END~~ + + +-- POWER tests for MONEY +SELECT POWER(CAST(12.34 AS MONEY), 2) AS result; -- Positive MONEY, Integer Power +GO +~~START~~ +money +152.2756 +~~END~~ + + +SELECT POWER(CAST(12.34 AS MONEY), 0.5) AS result; -- Positive MONEY, Decimal Power +GO +~~START~~ +money +3.5128 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS MONEY), 2) AS result; -- Negative MONEY, Even Integer Power +GO +~~START~~ +money +152.2756 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS MONEY), 3) AS result; -- Negative MONEY, Odd Integer Power +GO +~~START~~ +money +-1879.0809 +~~END~~ + + +SELECT POWER(CAST(0 AS MONEY), 2) AS result; -- Zero MONEY, Positive Power +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT POWER(CAST(12.34 AS MONEY), 0) AS result; -- MONEY, Zero Power +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT POWER(CAST(12.34 AS MONEY), -2) AS result; -- MONEY, Negative Power +GO +~~START~~ +money +0.0066 +~~END~~ + + +SELECT POWER(CAST(NULL AS MONEY), 2) AS result; -- NULL MONEY base +GO +~~START~~ +money + +~~END~~ + + +SELECT POWER(CAST(12.34 AS MONEY), NULL) AS result; -- NULL exponent +GO +~~START~~ +money + +~~END~~ + + +SELECT POWER(CAST(0 AS MONEY), 0) AS result; -- Zero raised to zero power +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT POWER(CAST(0 AS MONEY), -1) AS result; -- Zero raised to negative power +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: zero raised to a negative power is undefined)~~ + + +SELECT POWER(CAST(-12.34 AS MONEY), 0.5) AS result; -- Negative base, fractional power +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: a negative number raised to a non-integer power yields a complex result)~~ + + +SELECT POWER(CAST(12.34 AS MONEY), 14) AS result; -- power which overflows +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT POWER(CAST(-12.34 AS MONEY), 14) AS result; -- Negative base,power which overflows +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT POWER(CAST(12.34 AS MONEY), 9) AS result; -- big power which does not overflows +GO +~~START~~ +money +6634931404.8357 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS MONEY), 9) AS result; -- Negative base, big power which does not overflows +GO +~~START~~ +money +-6634931404.8357 +~~END~~ + + +-- POWER tests for SMALLMONEY +SELECT POWER(CAST(12.34 AS SMALLMONEY), 2) AS result; -- Positive SMALLMONEY, Integer Power +GO +~~START~~ +money +152.2756 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 2) AS result; -- Negative SMALLMONEY, Even Integer Power +GO +~~START~~ +money +152.2756 +~~END~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 0.5) AS result; -- Positive SMALLMONEY, Decimal Power +GO +~~START~~ +money +3.5128 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 3) AS result; -- Negative SMALLMONEY, Odd Integer Power +GO +~~START~~ +money +-1879.0809 +~~END~~ + + +SELECT POWER(CAST(0 AS SMALLMONEY), 2) AS result; -- Zero SMALLMONEY, Positive Power +GO +~~START~~ +money +0.0000 +~~END~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 0) AS result; -- SMALLMONEY, Zero Power +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), -2) AS result; -- SMALLMONEY, Negative Power +GO +~~START~~ +money +0.0066 +~~END~~ + + +SELECT POWER(CAST(NULL AS SMALLMONEY), 2) AS result; -- NULL SMALLMONEY base +GO +~~START~~ +money + +~~END~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), NULL) AS result; -- NULL exponent +GO +~~START~~ +money + +~~END~~ + + +SELECT POWER(CAST(0 AS SMALLMONEY), 0) AS result; -- Zero raised to zero power +GO +~~START~~ +money +1.0000 +~~END~~ + + +SELECT POWER(CAST(0 AS SMALLMONEY), -1) AS result; -- Zero raised to negative power +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: zero raised to a negative power is undefined)~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 0.5) AS result; -- Negative base, fractional power +GO +~~START~~ +money +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: a negative number raised to a non-integer power yields a complex result)~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 14) AS result; -- power which overflows +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 14) AS result; -- Negative base,power which overflows +GO +~~START~~ +money +~~ERROR (Code: 8115)~~ + +~~ERROR (Message: bigint out of range)~~ + + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 9) AS result; -- big power which does not overflows +GO +~~START~~ +money +6634931404.8357 +~~END~~ + + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 9) AS result; -- Negative base, big power which does not overflows +GO +~~START~~ +money +-6634931404.8357 +~~END~~ + + +-- SQRT tests for MONEY +SELECT SQRT(CAST(144.00 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +float +12.0 +~~END~~ + +SELECT SQRT(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT SQRT(CAST(12.25 AS MONEY)) AS result; -- Decimal MONEY +GO +~~START~~ +float +3.5 +~~END~~ + +SELECT SQRT(CAST(-144.00 AS MONEY)) AS result; -- Negative MONEY (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: cannot take square root of a negative number)~~ + +SELECT SQRT(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT SQRT(CAST(2.00 AS MONEY)) AS result; -- Irrational result +GO +~~START~~ +float +1.4142135623730951 +~~END~~ + +SELECT SQRT(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +float +3.0370004999760497E7 +~~END~~ + +SELECT SQRT(CAST(0.0001 AS MONEY)) AS result; -- Small positive value +GO +~~START~~ +float +0.01 +~~END~~ + + +-- SQRT tests for SMALLMONEY +SELECT SQRT(CAST(144.00 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +float +12.0 +~~END~~ + +SELECT SQRT(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT SQRT(CAST(12.25 AS SMALLMONEY)) AS result; -- Decimal SMALLMONEY +GO +~~START~~ +float +3.5 +~~END~~ + +SELECT SQRT(CAST(-144.00 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: cannot take square root of a negative number)~~ + +SELECT SQRT(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT SQRT(CAST(2.00 AS SMALLMONEY)) AS result; -- Irrational result +GO +~~START~~ +float +1.4142135623730951 +~~END~~ + +SELECT SQRT(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +float +463.4095000105199 +~~END~~ + +SELECT SQRT(CAST(0.0001 AS SMALLMONEY)) AS result; -- Small positive value +GO +~~START~~ +float +0.01 +~~END~~ + + +-- LOG tests for MONEY +SELECT LOG(CAST(100.00 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +float +4.605170185988092 +~~END~~ + +SELECT LOG(CAST(0.5 AS MONEY)) AS result; -- MONEY between 0 and 1 +GO +~~START~~ +float +-0.6931471805599453 +~~END~~ + +SELECT LOG(CAST(0 AS MONEY)) AS result; -- Zero MONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: cannot take logarithm of zero)~~ + +SELECT LOG(CAST(-100.00 AS MONEY)) AS result; -- Negative MONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: cannot take logarithm of a negative number)~~ + +SELECT LOG(CAST(1.00 AS MONEY)) AS result; -- LOG of 1 (should be 0) +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT LOG(CAST(2.718281828459045 AS MONEY)) AS result; -- LOG of e (should be 1) +GO +~~START~~ +float +1.0000066849139877 +~~END~~ + +SELECT LOG(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT LOG(CAST(0.0001 AS MONEY)) AS result; -- Very small positive number +GO +~~START~~ +float +-9.210340371976182 +~~END~~ + +SELECT LOG(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +float +34.45793200330037 +~~END~~ + + +-- LOG tests for SMALLMONEY +SELECT LOG(CAST(100.00 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +float +4.605170185988092 +~~END~~ + +SELECT LOG(CAST(0.5 AS SMALLMONEY)) AS result; -- SMALLMONEY between 0 and 1 +GO +~~START~~ +float +-0.6931471805599453 +~~END~~ + +SELECT LOG(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: cannot take logarithm of zero)~~ + +SELECT LOG(CAST(-100.00 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: cannot take logarithm of a negative number)~~ + +SELECT LOG(CAST(1.00 AS SMALLMONEY)) AS result; -- LOG of 1 (should be 0) +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT LOG(CAST(2.718281828459045 AS SMALLMONEY)) AS result; -- LOG of e (should be 1) +GO +~~START~~ +float +1.0000066849139877 +~~END~~ + +SELECT LOG(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT LOG(CAST(0.0001 AS SMALLMONEY)) AS result; -- Very small positive number +GO +~~START~~ +float +-9.210340371976182 +~~END~~ + +SELECT LOG(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +float +12.27722222491646 +~~END~~ + + +-- LOG10 tests for MONEY +SELECT LOG10(CAST(100.00 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +float +2.0 +~~END~~ + +SELECT LOG10(CAST(0.5 AS MONEY)) AS result; -- MONEY between 0 and 1 +GO +~~START~~ +float +-0.3010299956639812 +~~END~~ + +SELECT LOG10(CAST(0 AS MONEY)) AS result; -- Zero MONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: cannot take logarithm of zero)~~ + +SELECT LOG10(CAST(-100.00 AS MONEY)) AS result; -- Negative MONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: cannot take logarithm of a negative number)~~ + +SELECT LOG10(CAST(1.00 AS MONEY)) AS result; -- LOG10 of 1 (should be 0) +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT LOG10(CAST(10.00 AS MONEY)) AS result; -- LOG10 of 10 (should be 1) +GO +~~START~~ +float +1.0 +~~END~~ + +SELECT LOG10(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT LOG10(CAST(0.0001 AS MONEY)) AS result; -- Very small positive number +GO +~~START~~ +float +-4.0 +~~END~~ + +SELECT LOG10(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +~~START~~ +float +14.964889726830815 +~~END~~ + + +-- LOG10 tests for SMALLMONEY +SELECT LOG10(CAST(100.00 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +float +2.0 +~~END~~ + +SELECT LOG10(CAST(0.5 AS SMALLMONEY)) AS result; -- SMALLMONEY between 0 and 1 +GO +~~START~~ +float +-0.3010299956639812 +~~END~~ + +SELECT LOG10(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: cannot take logarithm of zero)~~ + +SELECT LOG10(CAST(-100.00 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY (should return error or NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: cannot take logarithm of a negative number)~~ + +SELECT LOG10(CAST(1.00 AS SMALLMONEY)) AS result; -- LOG10 of 1 (should be 0) +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT LOG10(CAST(10.00 AS SMALLMONEY)) AS result; -- LOG10 of 10 (should be 1) +GO +~~START~~ +float +1.0 +~~END~~ + +SELECT LOG10(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT LOG10(CAST(0.0001 AS SMALLMONEY)) AS result; -- Very small positive number +GO +~~START~~ +float +-4.0 +~~END~~ + +SELECT LOG10(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +~~START~~ +float +5.331929865381183 +~~END~~ + + +-- EXP tests for MONEY +SELECT EXP(CAST(1.00 AS MONEY)) AS result; -- Positive MONEY +GO +~~START~~ +float +2.718281828459045 +~~END~~ + +SELECT EXP(CAST(-1.00 AS MONEY)) AS result; -- Negative MONEY +GO +~~START~~ +float +0.36787944117144233 +~~END~~ + +SELECT EXP(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +~~START~~ +float +1.0 +~~END~~ + +SELECT TRY_CAST(EXP(CAST(1000.00 AS MONEY)) AS FLOAT) AS result; -- Large value causing overflow +GO +~~START~~ +float +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value out of range: overflow)~~ + +SELECT EXP(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT EXP(CAST(0.5 AS MONEY)) AS result; -- Fractional value +GO +~~START~~ +float +1.6487212707001282 +~~END~~ + +SELECT EXP(CAST(-0.5 AS MONEY)) AS result; -- Negative fractional value +GO +~~START~~ +float +0.6065306597126334 +~~END~~ + +SELECT EXP(CAST(10.00 AS MONEY)) AS result; -- Larger positive value +GO +~~START~~ +float +22026.465794806718 +~~END~~ + +SELECT EXP(CAST(-10.00 AS MONEY)) AS result; -- Larger negative value +GO +~~START~~ +float +4.5399929762484854E-5 +~~END~~ + + +-- EXP tests for SMALLMONEY +SELECT EXP(CAST(1.00 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +~~START~~ +float +2.718281828459045 +~~END~~ + +SELECT EXP(CAST(-1.00 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO +~~START~~ +float +0.36787944117144233 +~~END~~ + +SELECT EXP(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +~~START~~ +float +1.0 +~~END~~ + +SELECT TRY_CAST(EXP(CAST(1000.00 AS SMALLMONEY)) AS FLOAT) AS result; -- Large value causing overflow +GO +~~START~~ +float +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value out of range: overflow)~~ + +SELECT EXP(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +~~START~~ +float + +~~END~~ + +SELECT EXP(CAST(0.5 AS SMALLMONEY)) AS result; -- Fractional value +GO +~~START~~ +float +1.6487212707001282 +~~END~~ + +SELECT EXP(CAST(-0.5 AS SMALLMONEY)) AS result; -- Negative fractional value +GO +~~START~~ +float +0.6065306597126334 +~~END~~ + +SELECT EXP(CAST(10.00 AS SMALLMONEY)) AS result; -- Larger positive value +GO +~~START~~ +float +22026.465794806718 +~~END~~ + +SELECT EXP(CAST(-10.00 AS SMALLMONEY)) AS result; -- Larger negative value +GO +~~START~~ +float +4.5399929762484854E-5 +~~END~~ + + +-- SIN tests for MONEY +SELECT SIN(CAST(1.0 AS MONEY)) AS result; -- MONEY +GO +~~START~~ +float +0.8414709848078965 +~~END~~ + +SELECT SIN(CAST(0 AS MONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT SIN(CAST(PI() AS MONEY)) AS result; -- PI +GO +~~START~~ +float +-7.346410206643587E-6 +~~END~~ + +SELECT SIN(CAST(PI()/2 AS MONEY)) AS result; -- PI/2 (90 degrees) +GO +~~START~~ +float +0.9999999999932537 +~~END~~ + +SELECT SIN(CAST(PI()/6 AS MONEY)) AS result; -- PI/6 (30 degrees) +GO +~~START~~ +float +0.5000010603626028 +~~END~~ + +SELECT SIN(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT SIN(CAST(-PI()/2 AS MONEY)) AS result; -- -PI/2 (-90 degrees) +GO +~~START~~ +float +-0.9999999999932537 +~~END~~ + +SELECT SIN(CAST(2*PI() AS MONEY)) AS result; -- 2*PI (360 degrees) +GO +~~START~~ +float +1.469282041289069E-5 +~~END~~ + +SELECT SIN(CAST(100.00 AS MONEY)) AS result; -- Large value +GO +~~START~~ +float +-0.5063656411097588 +~~END~~ + + +-- SIN tests for SMALLMONEY +SELECT SIN(CAST(1.0 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +~~START~~ +float +0.8414709848078965 +~~END~~ + +SELECT SIN(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT SIN(CAST(PI() AS SMALLMONEY)) AS result; -- PI +GO +~~START~~ +float +-7.346410206643587E-6 +~~END~~ + +SELECT SIN(CAST(PI()/2 AS SMALLMONEY)) AS result; -- PI/2 (90 degrees) +GO +~~START~~ +float +0.9999999999932537 +~~END~~ + +SELECT SIN(CAST(PI()/6 AS SMALLMONEY)) AS result; -- PI/6 (30 degrees) +GO +~~START~~ +float +0.5000010603626028 +~~END~~ + +SELECT SIN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT SIN(CAST(-PI()/2 AS SMALLMONEY)) AS result; -- -PI/2 (-90 degrees) +GO +~~START~~ +float +-0.9999999999932537 +~~END~~ + +SELECT SIN(CAST(2*PI() AS SMALLMONEY)) AS result; -- 2*PI (360 degrees) +GO +~~START~~ +float +1.469282041289069E-5 +~~END~~ + +SELECT SIN(CAST(100.00 AS SMALLMONEY)) AS result; -- Large value +GO +~~START~~ +float +-0.5063656411097588 +~~END~~ + + +-- COS tests for MONEY +SELECT COS(CAST(1.0 AS MONEY)) AS result; -- MONEY +GO +~~START~~ +float +0.5403023058681398 +~~END~~ + +SELECT COS(CAST(0 AS MONEY)) AS result; -- Zero +GO +~~START~~ +float +1.0 +~~END~~ + +SELECT COS(CAST(PI() AS MONEY)) AS result; -- PI +GO +~~START~~ +float +-0.9999999999730151 +~~END~~ + +SELECT COS(CAST(PI()/2 AS MONEY)) AS result; -- PI/2 (90 degrees) +GO +~~START~~ +float +-3.673205103346574E-6 +~~END~~ + +SELECT COS(CAST(PI()/3 AS MONEY)) AS result; -- PI/3 (60 degrees) +GO +~~START~~ +float +0.4999978792725457 +~~END~~ + +SELECT COS(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT COS(CAST(-PI() AS MONEY)) AS result; -- -PI (-180 degrees) +GO +~~START~~ +float +-0.9999999999730151 +~~END~~ + +SELECT COS(CAST(2*PI() AS MONEY)) AS result; -- 2*PI (360 degrees) +GO +~~START~~ +float +0.9999999998920606 +~~END~~ + +SELECT COS(CAST(100.00 AS MONEY)) AS result; -- Large value +GO +~~START~~ +float +0.8623188722876839 +~~END~~ + + +-- COS tests for SMALLMONEY +SELECT COS(CAST(1.0 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +~~START~~ +float +0.5403023058681398 +~~END~~ + +SELECT COS(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +~~START~~ +float +1.0 +~~END~~ + +SELECT COS(CAST(PI() AS SMALLMONEY)) AS result; -- PI +GO +~~START~~ +float +-0.9999999999730151 +~~END~~ + +SELECT COS(CAST(PI()/2 AS SMALLMONEY)) AS result; -- PI/2 (90 degrees) +GO +~~START~~ +float +-3.673205103346574E-6 +~~END~~ + +SELECT COS(CAST(PI()/3 AS SMALLMONEY)) AS result; -- PI/3 (60 degrees) +GO +~~START~~ +float +0.4999978792725457 +~~END~~ + +SELECT COS(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT COS(CAST(-PI() AS SMALLMONEY)) AS result; -- -PI (-180 degrees) +GO +~~START~~ +float +-0.9999999999730151 +~~END~~ + +SELECT COS(CAST(2*PI() AS SMALLMONEY)) AS result; -- 2*PI (360 degrees) +GO +~~START~~ +float +0.9999999998920606 +~~END~~ + +SELECT COS(CAST(100.00 AS SMALLMONEY)) AS result; -- Large value +GO +~~START~~ +float +0.8623188722876839 +~~END~~ + + +-- TAN tests for MONEY +SELECT TAN(CAST(1.0 AS MONEY)) AS result; -- MONEY +GO +~~START~~ +float +1.5574077246549023 +~~END~~ + +SELECT TAN(CAST(0 AS MONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT TAN(CAST(PI()/4 AS MONEY)) AS result; -- PI/4 (45 degrees) +GO +~~START~~ +float +1.0000036732118496 +~~END~~ + +SELECT TAN(CAST(PI() AS MONEY)) AS result; -- PI (180 degrees) +GO +~~START~~ +float +7.346410206841829E-6 +~~END~~ + +SELECT TAN(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT TAN(CAST(-PI()/4 AS MONEY)) AS result; -- -PI/4 (-45 degrees) +GO +~~START~~ +float +-1.0000036732118496 +~~END~~ + +SELECT TAN(CAST(PI()/2 - 0.000001 AS MONEY)) AS result; -- Near PI/2 (near 90 degrees) +GO +~~START~~ +float +-272241.80840927624 +~~END~~ + +SELECT TAN(CAST(3*PI()/2 - 0.000001 AS MONEY)) AS result; -- Near 3*PI/2 (near 270 degrees) +GO +~~START~~ +float +-90747.26946832224 +~~END~~ + + +-- TAN tests for SMALLMONEY +SELECT TAN(CAST(1.0 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +~~START~~ +float +1.5574077246549023 +~~END~~ + +SELECT TAN(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT TAN(CAST(PI()/4 AS SMALLMONEY)) AS result; -- PI/4 (45 degrees) +GO +~~START~~ +float +1.0000036732118496 +~~END~~ + +SELECT TAN(CAST(PI() AS SMALLMONEY)) AS result; -- PI (180 degrees) +GO +~~START~~ +float +7.346410206841829E-6 +~~END~~ + +SELECT TAN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT TAN(CAST(-PI()/4 AS SMALLMONEY)) AS result; -- -PI/4 (-45 degrees) +GO +~~START~~ +float +-1.0000036732118496 +~~END~~ + +SELECT TAN(CAST(PI()/2 - 0.000001 AS SMALLMONEY)) AS result; -- Near PI/2 (near 90 degrees) +GO +~~START~~ +float +-272241.80840927624 +~~END~~ + +SELECT TAN(CAST(3*PI()/2 - 0.000001 AS SMALLMONEY)) AS result; -- Near 3*PI/2 (near 270 degrees) +GO +~~START~~ +float +-90747.26946832224 +~~END~~ + + +-- ASIN tests for MONEY +SELECT ASIN(CAST(0.5 AS MONEY)) AS result; -- MONEY +GO +~~START~~ +float +0.5235987755982989 +~~END~~ + +SELECT ASIN(CAST(0 AS MONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT ASIN(CAST(1 AS MONEY)) AS result; -- One +GO +~~START~~ +float +1.5707963267948966 +~~END~~ + +SELECT ASIN(CAST(-1 AS MONEY)) AS result; -- Negative one +GO +~~START~~ +float +-1.5707963267948966 +~~END~~ + +SELECT ASIN(CAST(2 AS MONEY)) AS result; -- Out of range (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ASIN(CAST(-2 AS MONEY)) AS result; -- Out of range negative (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ASIN(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT ASIN(CAST(0.7071067811865475 AS MONEY)) AS result; -- sin(PI/4) +GO +~~START~~ +float +0.7853885733974476 +~~END~~ + +SELECT ASIN(CAST(0.8660254037844386 AS MONEY)) AS result; -- sin(PI/3) +GO +~~START~~ +float +1.0471467458630677 +~~END~~ + + +-- ASIN tests for SMALLMONEY +SELECT ASIN(CAST(0.5 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +~~START~~ +float +0.5235987755982989 +~~END~~ + +SELECT ASIN(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT ASIN(CAST(1 AS SMALLMONEY)) AS result; -- One +GO +~~START~~ +float +1.5707963267948966 +~~END~~ + +SELECT ASIN(CAST(-1 AS SMALLMONEY)) AS result; -- Negative one +GO +~~START~~ +float +-1.5707963267948966 +~~END~~ + +SELECT ASIN(CAST(2 AS SMALLMONEY)) AS result; -- Out of range (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ASIN(CAST(-2 AS SMALLMONEY)) AS result; -- Out of range negative (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ASIN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT ASIN(CAST(0.7071067811865475 AS SMALLMONEY)) AS result; -- sin(PI/4) +GO +~~START~~ +float +0.7853885733974476 +~~END~~ + +SELECT ASIN(CAST(0.8660254037844386 AS SMALLMONEY)) AS result; -- sin(PI/3) +GO +~~START~~ +float +1.0471467458630677 +~~END~~ + + +-- ACOS tests for MONEY +SELECT ACOS(CAST(0.5 AS MONEY)) AS result; -- MONEY +GO +~~START~~ +float +1.0471975511965979 +~~END~~ + +SELECT ACOS(CAST(0 AS MONEY)) AS result; -- Zero +GO +~~START~~ +float +1.5707963267948966 +~~END~~ + +SELECT ACOS(CAST(1 AS MONEY)) AS result; -- One +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT ACOS(CAST(-1 AS MONEY)) AS result; -- Negative one +GO +~~START~~ +float +3.141592653589793 +~~END~~ + +SELECT ACOS(CAST(2 AS MONEY)) AS result; -- Out of range (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ACOS(CAST(-2 AS MONEY)) AS result; -- Out of range negative (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ACOS(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT ACOS(CAST(0.7071067811865475 AS MONEY)) AS result; -- cos(PI/4) +GO +~~START~~ +float +0.785407753397449 +~~END~~ + +SELECT ACOS(CAST(0.5 AS MONEY)) AS result; -- cos(PI/3) +GO +~~START~~ +float +1.0471975511965979 +~~END~~ + + +-- ACOS tests for SMALLMONEY +SELECT ACOS(CAST(0.5 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +~~START~~ +float +1.0471975511965979 +~~END~~ + +SELECT ACOS(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +~~START~~ +float +1.5707963267948966 +~~END~~ + +SELECT ACOS(CAST(1 AS SMALLMONEY)) AS result; -- One +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT ACOS(CAST(-1 AS SMALLMONEY)) AS result; -- Negative one +GO +~~START~~ +float +3.141592653589793 +~~END~~ + +SELECT ACOS(CAST(2 AS SMALLMONEY)) AS result; -- Out of range (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ACOS(CAST(-2 AS SMALLMONEY)) AS result; -- Out of range negative (should return NULL) +GO +~~START~~ +float +~~ERROR (Code: 3623)~~ + +~~ERROR (Message: input is out of range)~~ + +SELECT ACOS(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT ACOS(CAST(0.7071067811865475 AS SMALLMONEY)) AS result; -- cos(PI/4) +GO +~~START~~ +float +0.785407753397449 +~~END~~ + +SELECT ACOS(CAST(0.5 AS SMALLMONEY)) AS result; -- cos(PI/3) +GO +~~START~~ +float +1.0471975511965979 +~~END~~ + + +-- ATAN tests for MONEY +SELECT ATAN(CAST(1.0 AS MONEY)) AS result; -- MONEY +GO +~~START~~ +float +0.7853981633974483 +~~END~~ + +SELECT ATAN(CAST(0 AS MONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT ATAN(CAST(1000000 AS MONEY)) AS result; -- Large value +GO +~~START~~ +float +1.5707953267948966 +~~END~~ + +SELECT ATAN(CAST(-1.0 AS MONEY)) AS result; -- Negative value +GO +~~START~~ +float +-0.7853981633974483 +~~END~~ + +SELECT ATAN(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT ATAN(CAST(1.7320508075688772 AS MONEY)) AS result; -- tan(PI/3) +GO +~~START~~ +float +1.047209849042422 +~~END~~ + +SELECT ATAN(CAST(-1.7320508075688772 AS MONEY)) AS result; -- tan(-PI/3) +GO +~~START~~ +float +-1.047209849042422 +~~END~~ + +SELECT ATAN(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value (approaches PI/2) +GO +~~START~~ +float +1.5707963267948954 +~~END~~ + +SELECT ATAN(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value (approaches -PI/2) +GO +~~START~~ +float +-1.5707963267948954 +~~END~~ + + +-- ATAN tests for SMALLMONEY +SELECT ATAN(CAST(1.0 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +~~START~~ +float +0.7853981633974483 +~~END~~ + +SELECT ATAN(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +~~START~~ +float +0.0 +~~END~~ + +SELECT ATAN(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Large value +GO +~~START~~ +float +1.5707916701820215 +~~END~~ + +SELECT ATAN(CAST(-1.0 AS SMALLMONEY)) AS result; -- Negative value +GO +~~START~~ +float +-0.7853981633974483 +~~END~~ + +SELECT ATAN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +~~START~~ +float + +~~END~~ + +SELECT ATAN(CAST(1.7320508075688772 AS SMALLMONEY)) AS result; -- tan(PI/3) +GO +~~START~~ +float +1.047209849042422 +~~END~~ + +SELECT ATAN(CAST(-1.7320508075688772 AS SMALLMONEY)) AS result; -- tan(-PI/3) +GO +~~START~~ +float +-1.047209849042422 +~~END~~ + +SELECT ATAN(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value (approaches PI/2) +GO +~~START~~ +float +1.5707916701820215 +~~END~~ + +SELECT ATAN(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value (approaches -PI/2) +GO +~~START~~ +float +-1.5707916701820235 +~~END~~ + + +------------------------------------------------------------------------ +---- 4. Comparison Operators +------------------------------------------------------------------------ +-- Equality (=) operator tests +-- MONEY = MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = MONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) = CAST(922337203685477.5807 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MAX MONEY = MAX MONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) = CAST(-922337203685477.5808 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MIN MONEY = MIN MONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(0.0000 AS MONEY) = CAST(0.0000 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [ZERO MONEY = ZERO MONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(-123.45 AS MONEY) = CAST(-123.45 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [NEG MONEY = NEG MONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + + +-- SMALLMONEY = SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) = CAST(123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY = SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) = CAST(214748.3647 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MAX SMALLMONEY = MAX SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) = CAST(-214748.3648 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MIN SMALLMONEY = MIN SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(0.0000 AS SMALLMONEY) = CAST(0.0000 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [ZERO SMALLMONEY = ZERO SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(-123.45 AS SMALLMONEY) = CAST(-123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [NEG SMALLMONEY = NEG SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + + + + +-- Cross money-type comparisons +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + + +-- Money types with other numeric types +SELECT CASE WHEN CAST(123.45 AS MONEY) = 123.45 THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = Literal]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS FLOAT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = FLOAT]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS REAL) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = REAL]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS NUMERIC(5,2)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = NUMERIC]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123 AS INT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = INT]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123 AS BIGINT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = BIGINT]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123 AS SMALLINT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = SMALLINT]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123 AS TINYINT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = TINYINT]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + + +-- Money types with string types +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST('123.45' AS VARCHAR(20)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = VARCHAR]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST('123.45' AS CHAR(20)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = CHAR]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST('123.45' AS NVARCHAR(20)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = NVARCHAR]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST('123.45' AS NCHAR(20)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = NCHAR]; +GO +~~START~~ +varchar +Equal +~~END~~ + + +-- Money types with SQL_VARIANT +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(CAST(123.45 AS MONEY) AS SQL_VARIANT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = SQL_VARIANT]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) = CAST(CAST(123.45 AS SMALLMONEY) AS SQL_VARIANT) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY = SQL_VARIANT]; +GO +~~START~~ +varchar +Equal +~~END~~ + + +-- Inequality (<>) operator tests +-- MONEY <> MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) <> CAST(123.46 AS MONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MONEY <> MONEY]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) <> CAST(922337203685477.5806 AS MONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MAX MONEY <> NEAR MAX]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) <> CAST(-922337203685477.5807 AS MONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MIN MONEY <> NEAR MIN]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + + +-- SMALLMONEY <> SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) <> CAST(123.46 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [SMALLMONEY <> SMALLMONEY]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) <> CAST(214748.3646 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MAX SMALLMONEY <> NEAR MAX]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) <> CAST(-214748.3647 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MIN SMALLMONEY <> NEAR MIN]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + + +-- Cross money-type inequalities +SELECT CASE WHEN CAST(123.45 AS MONEY) <> CAST(123.46 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MONEY <> SMALLMONEY]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + + + +-- Greater than (>) operator tests +-- MONEY > MONEY +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS MONEY) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > MONEY]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) > CAST(922337203685477.5806 AS MONEY) THEN 'Greater' ELSE 'Not Greater' END AS [MAX MONEY > NEAR MAX]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(-922337203685477.5807 AS MONEY) > CAST(-922337203685477.5808 AS MONEY) THEN 'Greater' ELSE 'Not Greater' END AS [NEAR MIN > MIN MONEY]; +GO +~~START~~ +varchar +Greater +~~END~~ + + +-- SMALLMONEY > SMALLMONEY +SELECT CASE WHEN CAST(123.46 AS SMALLMONEY) > CAST(123.45 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [SMALLMONEY > SMALLMONEY]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) > CAST(214748.3646 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [MAX SMALLMONEY > NEAR MAX]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(-214748.3647 AS SMALLMONEY) > CAST(-214748.3648 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [NEAR MIN > MIN SMALLMONEY]; +GO +~~START~~ +varchar +Greater +~~END~~ + + +-- Cross money-type greater than +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > SMALLMONEY]; +GO +~~START~~ +varchar +Greater +~~END~~ + + +-- Money types greater than other numeric types +SELECT CASE WHEN CAST(123.46 AS MONEY) > 123.45 THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > Literal]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS FLOAT) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > FLOAT]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS REAL) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > REAL]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS NUMERIC(5,2)) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > NUMERIC]; +GO +~~START~~ +varchar +Greater +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123 AS INT) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > INT]; +GO +~~START~~ +varchar +Greater +~~END~~ + + +-- Less than (<) operator tests +SELECT 'Less Than (<) Operator Tests' AS test_description; +GO +~~START~~ +varchar +Less Than (<) Operator Tests +~~END~~ + + +-- MONEY < MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS MONEY) THEN 'Less' ELSE 'Not Less' END AS [MONEY < MONEY]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5806 AS MONEY) < CAST(922337203685477.5807 AS MONEY) THEN 'Less' ELSE 'Not Less' END AS [NEAR MAX < MAX MONEY]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) < CAST(-922337203685477.5807 AS MONEY) THEN 'Less' ELSE 'Not Less' END AS [MIN MONEY < NEAR MIN]; +GO +~~START~~ +varchar +Less +~~END~~ + + +-- SMALLMONEY < SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) < CAST(123.46 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [SMALLMONEY < SMALLMONEY]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(214748.3646 AS SMALLMONEY) < CAST(214748.3647 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [NEAR MAX < MAX SMALLMONEY]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) < CAST(-214748.3647 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [MIN SMALLMONEY < NEAR MIN]; +GO +~~START~~ +varchar +Less +~~END~~ + + +-- Cross money-type less than +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [MONEY < SMALLMONEY]; +GO +~~START~~ +varchar +Less +~~END~~ + + +-- Money types less than other numeric types +SELECT CASE WHEN CAST(123.45 AS MONEY) < 123.46 THEN 'Less' ELSE 'Not Less' END AS [MONEY < Literal]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS FLOAT) THEN 'Less' ELSE 'Not Less' END AS [MONEY < FLOAT]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS REAL) THEN 'Less' ELSE 'Not Less' END AS [MONEY < REAL]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS NUMERIC(5,2)) THEN 'Less' ELSE 'Not Less' END AS [MONEY < NUMERIC]; +GO +~~START~~ +varchar +Less +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(124 AS INT) THEN 'Less' ELSE 'Not Less' END AS [MONEY < INT]; +GO +~~START~~ +varchar +Less +~~END~~ + + +-- Greater than or equal to (>=) operator tests +-- MONEY >= MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) >= CAST(123.45 AS MONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MONEY >= MONEY (Equal)]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS MONEY) >= CAST(123.45 AS MONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MONEY >= MONEY (Greater)]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) >= CAST(922337203685477.5807 AS MONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MAX MONEY >= MAX MONEY]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + + +-- SMALLMONEY >= SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) >= CAST(123.45 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [SMALLMONEY >= SMALLMONEY (Equal)]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS SMALLMONEY) >= CAST(123.45 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [SMALLMONEY >= SMALLMONEY (Greater)]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) >= CAST(214748.3647 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MAX SMALLMONEY >= MAX SMALLMONEY]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + + +-- Cross money-type greater than or equal +SELECT CASE WHEN CAST(123.45 AS MONEY) >= CAST(123.45 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MONEY >= SMALLMONEY (Equal)]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + +SELECT CASE WHEN CAST(123.46 AS MONEY) >= CAST(123.45 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MONEY >= SMALLMONEY (Greater)]; +GO +~~START~~ +varchar +Greater or Equal +~~END~~ + + +-- Less than or equal to (<=) operator tests +-- MONEY <= MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) <= CAST(123.45 AS MONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MONEY <= MONEY (Equal)]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS MONEY) <= CAST(123.46 AS MONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MONEY <= MONEY (Less)]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) <= CAST(922337203685477.5807 AS MONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MAX MONEY <= MAX MONEY]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) <= CAST(-922337203685477.5808 AS MONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MIN MONEY <= MIN MONEY]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + + +-- SMALLMONEY <= SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) <= CAST(123.45 AS SMALLMONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [SMALLMONEY <= SMALLMONEY (Equal)]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) <= CAST(123.46 AS SMALLMONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [SMALLMONEY <= SMALLMONEY (Less)]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) <= CAST(214748.3647 AS SMALLMONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MAX SMALLMONEY <= MAX SMALLMONEY]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) <= CAST(-214748.3648 AS SMALLMONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MIN SMALLMONEY <= MIN SMALLMONEY]; +GO +~~START~~ +varchar +Less or Equal +~~END~~ + + +-- BETWEEN operator tests +-- MONEY BETWEEN +SELECT CASE WHEN CAST(123.45 AS MONEY) BETWEEN CAST(123.44 AS MONEY) AND CAST(123.46 AS MONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [MONEY BETWEEN]; +GO +~~START~~ +varchar +In Range +~~END~~ + +SELECT CASE WHEN CAST(0.00 AS MONEY) BETWEEN CAST(-1.00 AS MONEY) AND CAST(1.00 AS MONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [MONEY BETWEEN (Zero)]; +GO +~~START~~ +varchar +In Range +~~END~~ + +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) BETWEEN CAST(922337203685477.5806 AS MONEY) AND CAST(922337203685477.5807 AS MONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [MONEY BETWEEN (Max)]; +GO +~~START~~ +varchar +In Range +~~END~~ + + +-- SMALLMONEY BETWEEN +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) BETWEEN CAST(123.44 AS SMALLMONEY) AND CAST(123.46 AS SMALLMONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [SMALLMONEY BETWEEN]; +GO +~~START~~ +varchar +In Range +~~END~~ + +SELECT CASE WHEN CAST(0.00 AS SMALLMONEY) BETWEEN CAST(-1.00 AS SMALLMONEY) AND CAST(1.00 AS SMALLMONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [SMALLMONEY BETWEEN (Zero)]; +GO +~~START~~ +varchar +In Range +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) BETWEEN CAST(214748.3646 AS SMALLMONEY) AND CAST(214748.3647 AS SMALLMONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [SMALLMONEY BETWEEN (Max)]; +GO +~~START~~ +varchar +In Range +~~END~~ + + +-- Cross type BETWEEN +SELECT CASE WHEN CAST(123.45 AS MONEY) BETWEEN CAST(123.44 AS SMALLMONEY) AND CAST(123.46 AS SMALLMONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [MONEY BETWEEN SMALLMONEY]; +GO +~~START~~ +varchar +In Range +~~END~~ + + +-- IN operator tests +-- MONEY IN +SELECT CASE WHEN CAST(123.45 AS MONEY) IN (CAST(123.44 AS MONEY), CAST(123.45 AS MONEY), CAST(123.46 AS MONEY)) + THEN 'In List' ELSE 'Not In List' END AS [MONEY IN]; +GO +~~START~~ +varchar +In List +~~END~~ + +SELECT CASE WHEN CAST(0.00 AS MONEY) IN (CAST(-1.00 AS MONEY), CAST(0.00 AS MONEY), CAST(1.00 AS MONEY)) + THEN 'In List' ELSE 'Not In List' END AS [MONEY IN (Zero)]; +GO +~~START~~ +varchar +In List +~~END~~ + + +-- SMALLMONEY IN +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) IN (CAST(123.44 AS SMALLMONEY), CAST(123.45 AS SMALLMONEY), CAST(123.46 AS SMALLMONEY)) + THEN 'In List' ELSE 'Not In List' END AS [SMALLMONEY IN]; +GO +~~START~~ +varchar +In List +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) IN (CAST(214748.3646 AS SMALLMONEY), CAST(214748.3647 AS SMALLMONEY)) + THEN 'In List' ELSE 'Not In List' END AS [SMALLMONEY IN (Max)]; +GO +~~START~~ +varchar +In List +~~END~~ + + +-- Cross type IN +SELECT CASE WHEN CAST(123.45 AS MONEY) IN (CAST(123.44 AS SMALLMONEY), CAST(123.45 AS SMALLMONEY), CAST(123.46 AS SMALLMONEY)) + THEN 'In List' ELSE 'Not In List' END AS [MONEY IN SMALLMONEY]; +GO +~~START~~ +varchar +In List +~~END~~ + + +-- NULL comparison tests +-- MONEY NULL comparisons +SELECT CASE WHEN CAST(NULL AS MONEY) = CAST(123.45 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [NULL MONEY = MONEY]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(NULL AS MONEY) <> CAST(123.45 AS MONEY) THEN 'Not Equal' ELSE 'Equal' END AS [NULL MONEY <> MONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(NULL AS MONEY) > CAST(123.45 AS MONEY) THEN 'Greater' ELSE 'Not Greater' END AS [NULL MONEY > MONEY]; +GO +~~START~~ +varchar +Not Greater +~~END~~ + +SELECT CASE WHEN CAST(NULL AS MONEY) < CAST(123.45 AS MONEY) THEN 'Less' ELSE 'Not Less' END AS [NULL MONEY < MONEY]; +GO +~~START~~ +varchar +Not Less +~~END~~ + +SELECT CASE WHEN CAST(NULL AS MONEY) IS NULL THEN 'Is NULL' ELSE 'Is Not NULL' END AS [MONEY IS NULL]; +GO +~~START~~ +varchar +Is NULL +~~END~~ + +SELECT CASE WHEN CAST(NULL AS MONEY) IS NOT NULL THEN 'Is Not NULL' ELSE 'Is NULL' END AS [MONEY IS NOT NULL]; +GO +~~START~~ +varchar +Is NULL +~~END~~ + + +-- SMALLMONEY NULL comparisons +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) = CAST(123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [NULL SMALLMONEY = SMALLMONEY]; +GO +~~START~~ +varchar +Not Equal +~~END~~ + +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) <> CAST(123.45 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [NULL SMALLMONEY <> SMALLMONEY]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) > CAST(123.45 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [NULL SMALLMONEY > SMALLMONEY]; +GO +~~START~~ +varchar +Not Greater +~~END~~ + +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) < CAST(123.45 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [NULL SMALLMONEY < SMALLMONEY]; +GO +~~START~~ +varchar +Not Less +~~END~~ + +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) IS NULL THEN 'Is NULL' ELSE 'Is Not NULL' END AS [SMALLMONEY IS NULL]; +GO +~~START~~ +varchar +Is NULL +~~END~~ + +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) IS NOT NULL THEN 'Is Not NULL' ELSE 'Is NULL' END AS [SMALLMONEY IS NOT NULL]; +GO +~~START~~ +varchar +Is NULL +~~END~~ + + +-- Edge cases and special values +-- Zero comparisons +SELECT CASE WHEN CAST(0 AS MONEY) = CAST(0.0000 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY Zero = Zero]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(0 AS MONEY) = CAST(-0.0000 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY Zero = Negative Zero]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(0 AS SMALLMONEY) = CAST(0.0000 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY Zero = Zero]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(0 AS SMALLMONEY) = CAST(-0.0000 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY Zero = Negative Zero]; +GO +~~START~~ +varchar +Equal +~~END~~ + + +-- Maximum and minimum value comparisons +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) > CAST(922337203685477.5806 AS MONEY) THEN 'True' ELSE 'False' END AS [MAX MONEY > NEAR MAX]; +GO +~~START~~ +varchar +True +~~END~~ + +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) < CAST(-922337203685477.5807 AS MONEY) THEN 'True' ELSE 'False' END AS [MIN MONEY < NEAR MIN]; +GO +~~START~~ +varchar +True +~~END~~ + +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) > CAST(214748.3646 AS SMALLMONEY) THEN 'True' ELSE 'False' END AS [MAX SMALLMONEY > NEAR MAX]; +GO +~~START~~ +varchar +True +~~END~~ + +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) < CAST(-214748.3647 AS SMALLMONEY) THEN 'True' ELSE 'False' END AS [MIN SMALLMONEY < NEAR MIN]; +GO +~~START~~ +varchar +True +~~END~~ + + +-- Precision comparison tests +SELECT CASE WHEN CAST(123.4500 AS MONEY) = CAST(123.45 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY Precision Test]; +GO +~~START~~ +varchar +Equal +~~END~~ + +SELECT CASE WHEN CAST(123.4500 AS SMALLMONEY) = CAST(123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY Precision Test]; +GO +~~START~~ +varchar +Equal +~~END~~ + + +-- Create test table +CREATE TABLE MoneyComparisonTest +( + ID INT PRIMARY KEY, + MoneyVal MONEY, + SmallMoneyVal SMALLMONEY, + MoneyNull MONEY NULL, + SmallMoneyNull SMALLMONEY NULL +); +GO + +-- Insert test data +INSERT INTO MoneyComparisonTest (ID, MoneyVal, SmallMoneyVal, MoneyNull, SmallMoneyNull) +VALUES +(1, 100.00, 100.00, NULL, NULL), +(2, 200.00, 200.00, 200.00, 200.00), +(3, -100.00, -100.00, -100.00, -100.00), +(4, 922337203685477.5807, 214748.3647, NULL, NULL), +(5, -922337203685477.5808, -214748.3648, NULL, NULL), +(6, 0.00, 0.00, 0.00, 0.00), +(7, 123.45, 123.45, 123.45, 123.45); +GO +~~ROW COUNT: 7~~ + + +-- WHERE clause tests +-- Equality tests +SELECT ID, MoneyVal FROM MoneyComparisonTest WHERE MoneyVal = CAST(100.00 AS MONEY); +GO +~~START~~ +int#!#money +1#!#100.0000 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest WHERE SmallMoneyVal = CAST(100.00 AS SMALLMONEY); +GO +~~START~~ +int#!#smallmoney +1#!#100.0000 +~~END~~ + + +-- Inequality tests +SELECT ID, MoneyVal FROM MoneyComparisonTest WHERE MoneyVal <> CAST(100.00 AS MONEY); +GO +~~START~~ +int#!#money +2#!#200.0000 +3#!#-100.0000 +4#!#922337203685477.5807 +5#!#-922337203685477.5808 +6#!#0.0000 +7#!#123.4500 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest WHERE SmallMoneyVal <> CAST(100.00 AS SMALLMONEY); +GO +~~START~~ +int#!#smallmoney +2#!#200.0000 +3#!#-100.0000 +4#!#214748.3647 +5#!#-214748.3648 +6#!#0.0000 +7#!#123.4500 +~~END~~ + + +-- Greater than tests +SELECT ID, MoneyVal FROM MoneyComparisonTest WHERE MoneyVal > CAST(100.00 AS MONEY); +GO +~~START~~ +int#!#money +2#!#200.0000 +4#!#922337203685477.5807 +7#!#123.4500 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest WHERE SmallMoneyVal > CAST(100.00 AS SMALLMONEY); +GO +~~START~~ +int#!#smallmoney +2#!#200.0000 +4#!#214748.3647 +7#!#123.4500 +~~END~~ + + +-- Less than tests +SELECT ID, MoneyVal FROM MoneyComparisonTest WHERE MoneyVal < CAST(100.00 AS MONEY); +GO +~~START~~ +int#!#money +3#!#-100.0000 +5#!#-922337203685477.5808 +6#!#0.0000 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest WHERE SmallMoneyVal < CAST(100.00 AS SMALLMONEY); +GO +~~START~~ +int#!#smallmoney +3#!#-100.0000 +5#!#-214748.3648 +6#!#0.0000 +~~END~~ + + +-- BETWEEN tests +SELECT ID, MoneyVal FROM MoneyComparisonTest +WHERE MoneyVal BETWEEN CAST(100.00 AS MONEY) AND CAST(200.00 AS MONEY); +GO +~~START~~ +int#!#money +1#!#100.0000 +2#!#200.0000 +7#!#123.4500 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest +WHERE SmallMoneyVal BETWEEN CAST(100.00 AS SMALLMONEY) AND CAST(200.00 AS SMALLMONEY); +GO +~~START~~ +int#!#smallmoney +1#!#100.0000 +2#!#200.0000 +7#!#123.4500 +~~END~~ + + +-- IN tests +SELECT ID, MoneyVal FROM MoneyComparisonTest +WHERE MoneyVal IN (CAST(100.00 AS MONEY), CAST(200.00 AS MONEY)); +GO +~~START~~ +int#!#money +1#!#100.0000 +2#!#200.0000 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest +WHERE SmallMoneyVal IN (CAST(100.00 AS SMALLMONEY), CAST(200.00 AS SMALLMONEY)); +GO +~~START~~ +int#!#smallmoney +1#!#100.0000 +2#!#200.0000 +~~END~~ + + +-- NULL tests +SELECT ID, MoneyNull FROM MoneyComparisonTest WHERE MoneyNull IS NULL; +GO +~~START~~ +int#!#money +1#!# +4#!# +5#!# +~~END~~ + +SELECT ID, SmallMoneyNull FROM MoneyComparisonTest WHERE SmallMoneyNull IS NULL; +GO +~~START~~ +int#!#smallmoney +1#!# +4#!# +5#!# +~~END~~ + +SELECT ID, MoneyNull FROM MoneyComparisonTest WHERE MoneyNull IS NOT NULL; +GO +~~START~~ +int#!#money +2#!#200.0000 +3#!#-100.0000 +6#!#0.0000 +7#!#123.4500 +~~END~~ + +SELECT ID, SmallMoneyNull FROM MoneyComparisonTest WHERE SmallMoneyNull IS NOT NULL; +GO +~~START~~ +int#!#smallmoney +2#!#200.0000 +3#!#-100.0000 +6#!#0.0000 +7#!#123.4500 +~~END~~ + + +-- JOIN tests +-- Create second test table +CREATE TABLE MoneyComparisonTest2 +( + ID INT PRIMARY KEY, + MoneyVal MONEY, + SmallMoneyVal SMALLMONEY +); +GO + +-- Insert test data +INSERT INTO MoneyComparisonTest2 (ID, MoneyVal, SmallMoneyVal) +VALUES +(1, 100.00, 100.00), +(2, 200.00, 200.00), +(3, 300.00, 300.00); +GO +~~ROW COUNT: 3~~ + + +-- INNER JOIN tests +SELECT t1.ID, t1.MoneyVal, t2.MoneyVal AS MoneyVal2 +FROM MoneyComparisonTest t1 +INNER JOIN MoneyComparisonTest2 t2 ON t1.MoneyVal = t2.MoneyVal; +GO +~~START~~ +int#!#money#!#money +1#!#100.0000#!#100.0000 +2#!#200.0000#!#200.0000 +~~END~~ + + +SELECT t1.ID, t1.SmallMoneyVal, t2.SmallMoneyVal AS SmallMoneyVal2 +FROM MoneyComparisonTest t1 +INNER JOIN MoneyComparisonTest2 t2 ON t1.SmallMoneyVal = t2.SmallMoneyVal; +GO +~~START~~ +int#!#smallmoney#!#smallmoney +1#!#100.0000#!#100.0000 +2#!#200.0000#!#200.0000 +~~END~~ + + +-- LEFT JOIN tests +SELECT t1.ID, t1.MoneyVal, t2.MoneyVal AS MoneyVal2 +FROM MoneyComparisonTest t1 +LEFT JOIN MoneyComparisonTest2 t2 ON t1.MoneyVal = t2.MoneyVal; +GO +~~START~~ +int#!#money#!#money +5#!#-922337203685477.5808#!# +3#!#-100.0000#!# +6#!#0.0000#!# +1#!#100.0000#!#100.0000 +7#!#123.4500#!# +2#!#200.0000#!#200.0000 +4#!#922337203685477.5807#!# +~~END~~ + + +SELECT t1.ID, t1.SmallMoneyVal, t2.SmallMoneyVal AS SmallMoneyVal2 +FROM MoneyComparisonTest t1 +LEFT JOIN MoneyComparisonTest2 t2 ON t1.SmallMoneyVal = t2.SmallMoneyVal; +GO +~~START~~ +int#!#smallmoney#!#smallmoney +5#!#-214748.3648#!# +3#!#-100.0000#!# +6#!#0.0000#!# +1#!#100.0000#!#100.0000 +7#!#123.4500#!# +2#!#200.0000#!#200.0000 +4#!#214748.3647#!# +~~END~~ + + +-- ORDER BY tests +-- Basic ORDER BY +SELECT ID, MoneyVal FROM MoneyComparisonTest ORDER BY MoneyVal; +GO +~~START~~ +int#!#money +5#!#-922337203685477.5808 +3#!#-100.0000 +6#!#0.0000 +1#!#100.0000 +7#!#123.4500 +2#!#200.0000 +4#!#922337203685477.5807 +~~END~~ + +SELECT ID, MoneyVal FROM MoneyComparisonTest ORDER BY MoneyVal DESC; +GO +~~START~~ +int#!#money +4#!#922337203685477.5807 +2#!#200.0000 +7#!#123.4500 +1#!#100.0000 +6#!#0.0000 +3#!#-100.0000 +5#!#-922337203685477.5808 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest ORDER BY SmallMoneyVal; +GO +~~START~~ +int#!#smallmoney +5#!#-214748.3648 +3#!#-100.0000 +6#!#0.0000 +1#!#100.0000 +7#!#123.4500 +2#!#200.0000 +4#!#214748.3647 +~~END~~ + +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest ORDER BY SmallMoneyVal DESC; +GO +~~START~~ +int#!#smallmoney +4#!#214748.3647 +2#!#200.0000 +7#!#123.4500 +1#!#100.0000 +6#!#0.0000 +3#!#-100.0000 +5#!#-214748.3648 +~~END~~ + + +-- Multiple column ORDER BY +SELECT ID, MoneyVal, SmallMoneyVal +FROM MoneyComparisonTest +ORDER BY MoneyVal, SmallMoneyVal; +GO +~~START~~ +int#!#money#!#smallmoney +5#!#-922337203685477.5808#!#-214748.3648 +3#!#-100.0000#!#-100.0000 +6#!#0.0000#!#0.0000 +1#!#100.0000#!#100.0000 +7#!#123.4500#!#123.4500 +2#!#200.0000#!#200.0000 +4#!#922337203685477.5807#!#214748.3647 +~~END~~ + + +SELECT ID, MoneyVal, SmallMoneyVal +FROM MoneyComparisonTest +ORDER BY MoneyVal DESC, SmallMoneyVal ASC; +GO +~~START~~ +int#!#money#!#smallmoney +4#!#922337203685477.5807#!#214748.3647 +2#!#200.0000#!#200.0000 +7#!#123.4500#!#123.4500 +1#!#100.0000#!#100.0000 +6#!#0.0000#!#0.0000 +3#!#-100.0000#!#-100.0000 +5#!#-922337203685477.5808#!#-214748.3648 +~~END~~ + + +-- ORDER BY with NULL values +SELECT ID, MoneyNull +FROM MoneyComparisonTest +ORDER BY MoneyNull; +GO +~~START~~ +int#!#money +4#!# +1#!# +5#!# +3#!#-100.0000 +6#!#0.0000 +7#!#123.4500 +2#!#200.0000 +~~END~~ + + +SELECT ID, SmallMoneyNull +FROM MoneyComparisonTest +ORDER BY SmallMoneyNull DESC; +GO +~~START~~ +int#!#smallmoney +2#!#200.0000 +7#!#123.4500 +6#!#0.0000 +3#!#-100.0000 +4#!# +1#!# +5#!# +~~END~~ + + +-- GROUP BY tests +-- Basic GROUP BY +SELECT MoneyVal, COUNT(*) as Count +FROM MoneyComparisonTest +GROUP BY MoneyVal; +GO +~~START~~ +money#!#int +-100.0000#!#1 +-922337203685477.5808#!#1 +123.4500#!#1 +200.0000#!#1 +0.0000#!#1 +922337203685477.5807#!#1 +100.0000#!#1 +~~END~~ + + +SELECT SmallMoneyVal, COUNT(*) as Count +FROM MoneyComparisonTest +GROUP BY SmallMoneyVal; +GO +~~START~~ +smallmoney#!#int +214748.3647#!#1 +-100.0000#!#1 +123.4500#!#1 +200.0000#!#1 +0.0000#!#1 +-214748.3648#!#1 +100.0000#!#1 +~~END~~ + + +-- GROUP BY with aggregates +SELECT + CASE + WHEN MoneyVal >= 0 THEN 'Positive' + ELSE 'Negative' + END AS ValueType, + COUNT(*) as Count, + MIN(MoneyVal) as MinValue, + MAX(MoneyVal) as MaxValue, + AVG(CAST(MoneyVal AS FLOAT)) as AvgValue +FROM MoneyComparisonTest +GROUP BY CASE + WHEN MoneyVal >= 0 THEN 'Positive' + ELSE 'Negative' +END +ORDER BY ValueType; +GO +~~START~~ +varchar#!#int#!#money#!#money#!#float +Negative#!#2#!#-922337203685477.5808#!#-100.0000#!#-4.611686018427888E14 +Positive#!#5#!#0.0000#!#922337203685477.5807#!#1.8446744073718022E14 +~~END~~ + + +-- HAVING clause tests +SELECT MoneyVal, COUNT(*) as Count +FROM MoneyComparisonTest +GROUP BY MoneyVal +HAVING MoneyVal > 0; +GO +~~START~~ +money#!#int +123.4500#!#1 +200.0000#!#1 +922337203685477.5807#!#1 +100.0000#!#1 +~~END~~ + + +SELECT SmallMoneyVal, COUNT(*) as Count +FROM MoneyComparisonTest +GROUP BY SmallMoneyVal +HAVING SmallMoneyVal < 0; +GO +~~START~~ +smallmoney#!#int +-100.0000#!#1 +-214748.3648#!#1 +~~END~~ + + +-- Complex comparison scenarios +-- Case expression comparisons +SELECT ID, + CASE + WHEN MoneyVal > 0 THEN 'Positive' + WHEN MoneyVal < 0 THEN 'Negative' + ELSE 'Zero' + END AS MoneyCategory, + CASE + WHEN SmallMoneyVal > 0 THEN 'Positive' + WHEN SmallMoneyVal < 0 THEN 'Negative' + ELSE 'Zero' + END AS SmallMoneyCategory +FROM MoneyComparisonTest; +GO +~~START~~ +int#!#varchar#!#varchar +1#!#Positive#!#Positive +2#!#Positive#!#Positive +3#!#Negative#!#Negative +4#!#Positive#!#Positive +5#!#Negative#!#Negative +6#!#Zero#!#Zero +7#!#Positive#!#Positive +~~END~~ + + +-- Nested comparisons +SELECT ID, MoneyVal +FROM MoneyComparisonTest +WHERE MoneyVal > ( + SELECT AVG(CAST(MoneyVal AS FLOAT)) + FROM MoneyComparisonTest + WHERE MoneyVal > 0 +); +GO +~~START~~ +int#!#money +4#!#922337203685477.5807 +~~END~~ + + +-- Multiple conditions +SELECT ID, MoneyVal, SmallMoneyVal +FROM MoneyComparisonTest +WHERE MoneyVal > 0 +AND SmallMoneyVal > 0 +AND MoneyVal = SmallMoneyVal; +GO +~~START~~ +int#!#money#!#smallmoney +1#!#100.0000#!#100.0000 +2#!#200.0000#!#200.0000 +7#!#123.4500#!#123.4500 +~~END~~ + + +-- Exists with comparison +SELECT ID, MoneyVal +FROM MoneyComparisonTest t1 +WHERE EXISTS ( + SELECT 1 + FROM MoneyComparisonTest2 t2 + WHERE t2.MoneyVal = t1.MoneyVal +); +GO +~~START~~ +int#!#money +1#!#100.0000 +2#!#200.0000 +~~END~~ + + +-- Union with comparisons +SELECT ID, MoneyVal, 'MONEY' as Type +FROM MoneyComparisonTest +WHERE MoneyVal > 0 +UNION ALL +SELECT ID, SmallMoneyVal, 'SMALLMONEY' as Type +FROM MoneyComparisonTest +WHERE SmallMoneyVal > 0 +ORDER BY MoneyVal, ID, Type; +GO +~~START~~ +int#!#money#!#varchar +1#!#100.0000#!#MONEY +1#!#100.0000#!#SMALLMONEY +7#!#123.4500#!#MONEY +7#!#123.4500#!#SMALLMONEY +2#!#200.0000#!#MONEY +2#!#200.0000#!#SMALLMONEY +4#!#214748.3647#!#SMALLMONEY +4#!#922337203685477.5807#!#MONEY +~~END~~ + + +-- Intersection test +SELECT MoneyVal +FROM MoneyComparisonTest +WHERE MoneyVal > 0 +INTERSECT +SELECT MoneyVal +FROM MoneyComparisonTest2 +WHERE MoneyVal > 0; +GO +~~START~~ +money +200.0000 +100.0000 +~~END~~ + + +-- Except test +SELECT MoneyVal +FROM MoneyComparisonTest +WHERE MoneyVal > 0 +EXCEPT +SELECT MoneyVal +FROM MoneyComparisonTest2 +WHERE MoneyVal > 0; +GO +~~START~~ +money +123.4500 +922337203685477.5807 +~~END~~ + + +-- Additional complex scenarios +-- Subquery comparisons +SELECT ID, MoneyVal +FROM MoneyComparisonTest t1 +WHERE MoneyVal = ( + SELECT MAX(MoneyVal) + FROM MoneyComparisonTest + WHERE ID < t1.ID +); +GO +~~START~~ +int#!#money +~~END~~ + + +-- Correlated subqueries +SELECT ID, MoneyVal +FROM MoneyComparisonTest t1 +WHERE MoneyVal > ( + SELECT AVG(CAST(t2.MoneyVal AS FLOAT)) + FROM MoneyComparisonTest t2 + WHERE t2.ID < t1.ID +); +GO +~~START~~ +int#!#money +2#!#200.0000 +4#!#922337203685477.5807 +7#!#123.4500 +~~END~~ + + +-- Window functions with comparisons +SELECT + ID, + MoneyVal, + LAG(MoneyVal) OVER (ORDER BY ID) as PrevValue, + CASE + WHEN MoneyVal > LAG(MoneyVal) OVER (ORDER BY ID) THEN 'Increased' + WHEN MoneyVal < LAG(MoneyVal) OVER (ORDER BY ID) THEN 'Decreased' + WHEN MoneyVal = LAG(MoneyVal) OVER (ORDER BY ID) THEN 'No Change' + ELSE 'First Row' + END as ValueChange +FROM MoneyComparisonTest; +GO +~~START~~ +int#!#money#!#money#!#varchar +1#!#100.0000#!##!#First Row +2#!#200.0000#!#100.0000#!#Increased +3#!#-100.0000#!#200.0000#!#Decreased +4#!#922337203685477.5807#!#-100.0000#!#Increased +5#!#-922337203685477.5808#!#922337203685477.5807#!#Decreased +6#!#0.0000#!#-922337203685477.5808#!#Increased +7#!#123.4500#!#0.0000#!#Increased +~~END~~ + + +-- Running totals with comparisons +SELECT + ID, + MoneyVal, + SUM(MoneyVal) OVER (ORDER BY ID) as RunningTotal, + CASE + WHEN SUM(MoneyVal) OVER (ORDER BY ID) > 0 THEN 'Positive Balance' + ELSE 'Negative Balance' + END as BalanceStatus +FROM MoneyComparisonTest; +GO +~~START~~ +int#!#money#!#money#!#varchar +1#!#100.0000#!#100.0000#!#Positive Balance +2#!#200.0000#!#300.0000#!#Positive Balance +3#!#-100.0000#!#200.0000#!#Positive Balance +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +-- Pivot operations +-- Create sample data for pivot +CREATE TABLE MoneyPivotTest ( + ID INT, + Category VARCHAR(10), + Amount MONEY +); +GO + +INSERT INTO MoneyPivotTest (ID, Category, Amount) +VALUES +(1, 'A', 100.00), +(1, 'B', 200.00), +(2, 'A', 300.00), +(2, 'B', 400.00); +GO +~~ROW COUNT: 4~~ + + +-- Pivot query +SELECT * +FROM ( + SELECT ID, Category, Amount + FROM MoneyPivotTest +) AS SourceTable +PIVOT ( + SUM(Amount) + FOR Category IN ([A], [B]) +) AS PivotTable; +GO +~~START~~ +int#!#money#!#money +1#!#100.0000#!#200.0000 +2#!#300.0000#!#400.0000 +~~END~~ + + +-- Complex conditional aggregation +SELECT + CASE + WHEN MoneyVal BETWEEN -1000 AND 1000 THEN 'Normal Range' + WHEN MoneyVal > 1000 THEN 'High Range' + ELSE 'Low Range' + END AS ValueRange, + COUNT(*) AS Count, + MIN(MoneyVal) AS MinValue, + MAX(MoneyVal) AS MaxValue, + SUM(CASE WHEN MoneyVal > 0 THEN 1 ELSE 0 END) AS PositiveCount, + SUM(CASE WHEN MoneyVal < 0 THEN 1 ELSE 0 END) AS NegativeCount +FROM MoneyComparisonTest +GROUP BY + CASE + WHEN MoneyVal BETWEEN -1000 AND 1000 THEN 'Normal Range' + WHEN MoneyVal > 1000 THEN 'High Range' + ELSE 'Low Range' + END +ORDER BY ValueRange; +GO +~~START~~ +varchar#!#int#!#money#!#money#!#int#!#int +High Range#!#1#!#922337203685477.5807#!#922337203685477.5807#!#1#!#0 +Low Range#!#1#!#-922337203685477.5808#!#-922337203685477.5808#!#0#!#1 +Normal Range#!#5#!#-100.0000#!#200.0000#!#3#!#1 +~~END~~ + + +-- String formatting and comparison tests +SELECT + ID, + MoneyVal, + CAST(MoneyVal AS VARCHAR(20)) AS StringValue, + CASE + WHEN CAST(MoneyVal AS VARCHAR(20)) LIKE '%-%.%' THEN 'Negative Decimal' + WHEN CAST(MoneyVal AS VARCHAR(20)) LIKE '%.%' THEN 'Positive Decimal' + ELSE 'Whole Number' + END AS FormatType +FROM MoneyComparisonTest; +GO +~~START~~ +int#!#money#!#varchar#!#varchar +1#!#100.0000#!#100.00#!#Positive Decimal +2#!#200.0000#!#200.00#!#Positive Decimal +3#!#-100.0000#!#-100.00#!#Negative Decimal +4#!#922337203685477.5807#!#922337203685477.58#!#Positive Decimal +5#!#-922337203685477.5808#!#-922337203685477.58#!#Negative Decimal +6#!#0.0000#!#0.00#!#Positive Decimal +7#!#123.4500#!#123.45#!#Positive Decimal +~~END~~ + + +-- Rounding comparison tests +SELECT + ID, + MoneyVal, + ROUND(MoneyVal, 0) AS RoundedToInteger, + CASE + WHEN MoneyVal = ROUND(MoneyVal, 0) THEN 'Whole Number' + ELSE 'Decimal Number' + END AS NumberType +FROM MoneyComparisonTest; +GO +~~START~~ +int#!#money#!#money#!#varchar +1#!#100.0000#!#100.0000#!#Whole Number +2#!#200.0000#!#200.0000#!#Whole Number +3#!#-100.0000#!#-100.0000#!#Whole Number +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value "922337203685478" is out of range for type fixeddecimal)~~ + + +-- Boundary value analysis +-- Test near-boundary values for MONEY +SELECT + CASE WHEN CAST(922337203685477.5807 AS MONEY) = CAST(922337203685477.5807 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [Max_Money_Equal], + CASE WHEN CAST(-922337203685477.5808 AS MONEY) = CAST(-922337203685477.5808 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [Min_Money_Equal]; +GO +~~START~~ +varchar#!#varchar +Equal#!#Equal +~~END~~ + + +-- Test near-boundary values for SMALLMONEY +SELECT + CASE WHEN CAST(214748.3647 AS SMALLMONEY) = CAST(214748.3647 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [Max_SmallMoney_Equal], + CASE WHEN CAST(-214748.3648 AS SMALLMONEY) = CAST(-214748.3648 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [Min_SmallMoney_Equal]; +GO +~~START~~ +varchar#!#varchar +Equal#!#Equal +~~END~~ + + +-- Cleanup +DROP TABLE MoneyComparisonTest; +DROP TABLE MoneyComparisonTest2; +DROP TABLE MoneyPivotTest; +GO + + + +------------------------------------------------------------------------ +---- 6. Datatype Conversion +------------------------------------------------------------------------ +---- Conversion using CAST() +-- BIT to Money types +SELECT 'BIT to Money Types Conversion' AS test_description; +GO +~~START~~ +varchar +BIT to Money Types Conversion +~~END~~ + + +-- BIT -> MONEY +SELECT CAST(0 AS MONEY) AS [BIT_0_TO_MONEY], CAST(1 AS MONEY) AS [BIT_1_TO_MONEY]; +GO +~~START~~ +money#!#money +0.0000#!#1.0000 +~~END~~ + + +-- BIT -> SMALLMONEY +SELECT CAST(0 AS SMALLMONEY) AS [BIT_0_TO_SMALLMONEY], CAST(1 AS SMALLMONEY) AS [BIT_1_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney +0.0000#!#1.0000 +~~END~~ + + +-- Integer types to Money types +SELECT 'Integer Types to Money Types Conversion' AS test_description; +GO +~~START~~ +varchar +Integer Types to Money Types Conversion +~~END~~ + + +-- TINYINT -> MONEY +SELECT CAST(CAST(0 AS TINYINT) AS MONEY) AS [TINYINT_MIN_TO_MONEY], + CAST(CAST(255 AS TINYINT) AS MONEY) AS [TINYINT_MAX_TO_MONEY], + CAST(CAST(128 AS TINYINT) AS MONEY) AS [TINYINT_MID_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money +0.0000#!#255.0000#!#128.0000 +~~END~~ + + +-- TINYINT -> SMALLMONEY +SELECT CAST(CAST(0 AS TINYINT) AS SMALLMONEY) AS [TINYINT_MIN_TO_SMALLMONEY], + CAST(CAST(255 AS TINYINT) AS SMALLMONEY) AS [TINYINT_MAX_TO_SMALLMONEY], + CAST(CAST(128 AS TINYINT) AS SMALLMONEY) AS [TINYINT_MID_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney +0.0000#!#255.0000#!#128.0000 +~~END~~ + + +-- SMALLINT -> MONEY +SELECT CAST(CAST(-32768 AS SMALLINT) AS MONEY) AS [SMALLINT_MIN_TO_MONEY], + CAST(CAST(32767 AS SMALLINT) AS MONEY) AS [SMALLINT_MAX_TO_MONEY], + CAST(CAST(0 AS SMALLINT) AS MONEY) AS [SMALLINT_ZERO_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money +-32768.0000#!#32767.0000#!#0.0000 +~~END~~ + + +-- SMALLINT -> SMALLMONEY +SELECT CAST(CAST(-32768 AS SMALLINT) AS SMALLMONEY) AS [SMALLINT_MIN_TO_SMALLMONEY], + CAST(CAST(32767 AS SMALLINT) AS SMALLMONEY) AS [SMALLINT_MAX_TO_SMALLMONEY], + CAST(CAST(0 AS SMALLINT) AS SMALLMONEY) AS [SMALLINT_ZERO_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney +-32768.0000#!#32767.0000#!#0.0000 +~~END~~ + + +-- INT -> MONEY +SELECT CAST(CAST(-2147483648 AS INT) AS MONEY) AS [INT_MIN_TO_MONEY], + CAST(CAST(2147483647 AS INT) AS MONEY) AS [INT_MAX_TO_MONEY], + CAST(CAST(0 AS INT) AS MONEY) AS [INT_ZERO_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money +-2147483648.0000#!#2147483647.0000#!#0.0000 +~~END~~ + + +-- INT -> SMALLMONEY +SELECT TRY_CAST(CAST(-2147483648 AS INT) AS SMALLMONEY) AS [INT_MIN_TO_SMALLMONEY], + TRY_CAST(CAST(2147483647 AS INT) AS SMALLMONEY) AS [INT_MAX_TO_SMALLMONEY], + CAST(CAST(0 AS INT) AS SMALLMONEY) AS [INT_ZERO_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney +#!##!#0.0000 +~~END~~ + + +-- BIGINT -> MONEY +SELECT CAST(CAST(-9223372036854775808 AS BIGINT) AS MONEY) AS [BIGINT_MIN_TO_MONEY], + CAST(CAST(9223372036854775807 AS BIGINT) AS MONEY) AS [BIGINT_MAX_TO_MONEY], + CAST(CAST(0 AS BIGINT) AS MONEY) AS [BIGINT_ZERO_TO_MONEY]; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: value "-9223372036854775808" is out of range for type money)~~ + + +-- BIGINT -> SMALLMONEY +SELECT TRY_CAST(CAST(-9223372036854775808 AS BIGINT) AS SMALLMONEY) AS [BIGINT_MIN_TO_SMALLMONEY], + TRY_CAST(CAST(9223372036854775807 AS BIGINT) AS SMALLMONEY) AS [BIGINT_MAX_TO_SMALLMONEY], + CAST(CAST(0 AS BIGINT) AS SMALLMONEY) AS [BIGINT_ZERO_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney +#!##!#0.0000 +~~END~~ + + +-- Floating point types to Money types +-- FLOAT -> MONEY +SELECT CAST(CAST(-1234.56789 AS FLOAT) AS MONEY) AS [FLOAT_NEG_TO_MONEY], + CAST(CAST(1234.56789 AS FLOAT) AS MONEY) AS [FLOAT_POS_TO_MONEY], + CAST(CAST(0.0 AS FLOAT) AS MONEY) AS [FLOAT_ZERO_TO_MONEY], + CAST(CAST(922337203685477.5807 AS FLOAT) AS MONEY) AS [FLOAT_MAX_TO_MONEY], + CAST(CAST(-922337203685477.5808 AS FLOAT) AS MONEY) AS [FLOAT_MIN_TO_MONEY]; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: fixeddecimal out of range)~~ + + +-- FLOAT -> SMALLMONEY +SELECT CAST(CAST(-214748.3648 AS FLOAT) AS SMALLMONEY) AS [FLOAT_NEG_TO_SMALLMONEY], + CAST(CAST(214748.3647 AS FLOAT) AS SMALLMONEY) AS [FLOAT_POS_TO_SMALLMONEY], + CAST(CAST(0.0 AS FLOAT) AS SMALLMONEY) AS [FLOAT_ZERO_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney +-214748.3648#!#214748.3647#!#0.0000 +~~END~~ + + +-- String types to Money types +-- CHAR -> MONEY +SELECT CAST(CAST('123.45' AS CHAR(40)) AS MONEY) AS [CHAR_POS_TO_MONEY], + CAST(CAST('-123.45' AS CHAR(40)) AS MONEY) AS [CHAR_NEG_TO_MONEY], + CAST(CAST('0' AS CHAR(40)) AS MONEY) AS [CHAR_ZERO_TO_MONEY], + CAST(CAST('922337203685477.5807' AS CHAR(40)) AS MONEY) AS [CHAR_MAX_TO_MONEY], + CAST(CAST('-922337203685477.5808' AS CHAR(40)) AS MONEY) AS [CHAR_MIN_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money#!#money#!#money +123.4500#!#-123.4500#!#0.0000#!#922337203685477.5807#!#-922337203685477.5808 +~~END~~ + + +-- CHAR -> SMALLMONEY +SELECT CAST(CAST('214748.3647' AS CHAR(40)) AS SMALLMONEY) AS [CHAR_POS_TO_SMALLMONEY], + CAST(CAST('-214748.3648' AS CHAR(40)) AS SMALLMONEY) AS [CHAR_NEG_TO_SMALLMONEY], + CAST(CAST('0' AS CHAR(40)) AS SMALLMONEY) AS [CHAR_ZERO_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney +214748.3647#!#-214748.3648#!#0.0000 +~~END~~ + + +-- VARCHAR -> MONEY +SELECT CAST(CAST('123.45' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_POS_TO_MONEY], + CAST(CAST('-123.45' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_NEG_TO_MONEY], + CAST(CAST('0' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_ZERO_TO_MONEY], + CAST(CAST('922337203685477.5807' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_MAX_TO_MONEY], + CAST(CAST('-922337203685477.5808' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_MIN_TO_MONEY], + CAST(CAST('$123.45' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_CURRENCY_TO_MONEY], + CAST(CAST('1,234.56' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_COMMA_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money#!#money#!#money#!#money#!#money +123.4500#!#-123.4500#!#0.0000#!#922337203685477.5807#!#-922337203685477.5808#!#123.4500#!#1234.5600 +~~END~~ + + +-- VARCHAR -> SMALLMONEY +SELECT CAST(CAST('214748.3647' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_POS_TO_SMALLMONEY], + CAST(CAST('-214748.3648' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_NEG_TO_SMALLMONEY], + CAST(CAST('0' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_ZERO_TO_SMALLMONEY], + CAST(CAST('$123.45' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_CURRENCY_TO_SMALLMONEY], + CAST(CAST('1,234.56' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_COMMA_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +214748.3647#!#-214748.3648#!#0.0000#!#123.4500#!#1234.5600 +~~END~~ + + +-- NCHAR -> MONEY +SELECT CAST(CAST(N'123.45' AS NCHAR(40)) AS MONEY) AS [NCHAR_POS_TO_MONEY], + CAST(CAST(N'-123.45' AS NCHAR(40)) AS MONEY) AS [NCHAR_NEG_TO_MONEY], + CAST(CAST(N'0' AS NCHAR(40)) AS MONEY) AS [NCHAR_ZERO_TO_MONEY], + CAST(CAST(N'922337203685477.5807' AS NCHAR(40)) AS MONEY) AS [NCHAR_MAX_TO_MONEY], + CAST(CAST(N'-922337203685477.5808' AS NCHAR(40)) AS MONEY) AS [NCHAR_MIN_TO_MONEY], + CAST(CAST(N'$123.45' AS NCHAR(40)) AS MONEY) AS [NCHAR_CURRENCY_TO_MONEY], + CAST(CAST(N'1,234.56' AS NCHAR(40)) AS MONEY) AS [NCHAR_COMMA_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money#!#money#!#money#!#money#!#money +123.4500#!#-123.4500#!#0.0000#!#922337203685477.5807#!#-922337203685477.5808#!#123.4500#!#1234.5600 +~~END~~ + + +-- NCHAR -> SMALLMONEY +SELECT CAST(CAST(N'214748.3647' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_POS_TO_SMALLMONEY], + CAST(CAST(N'-214748.3648' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_NEG_TO_SMALLMONEY], + CAST(CAST(N'0' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_ZERO_TO_SMALLMONEY], + CAST(CAST(N'$123.45' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_CURRENCY_TO_SMALLMONEY], + CAST(CAST(N'1,234.56' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_COMMA_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +214748.3647#!#-214748.3648#!#0.0000#!#123.4500#!#1234.5600 +~~END~~ + + +-- NVARCHAR -> MONEY +SELECT CAST(CAST(N'123.45' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_POS_TO_MONEY], + CAST(CAST(N'-123.45' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_NEG_TO_MONEY], + CAST(CAST(N'0' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_ZERO_TO_MONEY], + CAST(CAST(N'922337203685477.5807' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_MAX_TO_MONEY], + CAST(CAST(N'-922337203685477.5808' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_MIN_TO_MONEY], + CAST(CAST(N'$123.45' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_CURRENCY_TO_MONEY], + CAST(CAST(N'1,234.56' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_COMMA_TO_MONEY]; +GO +~~START~~ +money#!#money#!#money#!#money#!#money#!#money#!#money +123.4500#!#-123.4500#!#0.0000#!#922337203685477.5807#!#-922337203685477.5808#!#123.4500#!#1234.5600 +~~END~~ + + +-- NVARCHAR -> SMALLMONEY +SELECT CAST(CAST(N'214748.3647' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_POS_TO_SMALLMONEY], + CAST(CAST(N'-214748.3648' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_NEG_TO_SMALLMONEY], + CAST(CAST(N'0' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_ZERO_TO_SMALLMONEY], + CAST(CAST(N'$123.45' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_CURRENCY_TO_SMALLMONEY], + CAST(CAST(N'1,234.56' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_COMMA_TO_SMALLMONEY]; +GO +~~START~~ +smallmoney#!#smallmoney#!#smallmoney#!#smallmoney#!#smallmoney +214748.3647#!#-214748.3648#!#0.0000#!#123.4500#!#1234.5600 +~~END~~ + diff --git a/test/JDBC/input/babel_varbinary-vu-verify.mix b/test/JDBC/input/babel_varbinary-vu-verify.mix index 7af3a5a0fcb..4b53b4ae35f 100644 --- a/test/JDBC/input/babel_varbinary-vu-verify.mix +++ b/test/JDBC/input/babel_varbinary-vu-verify.mix @@ -605,7 +605,6 @@ SELECT bit_col + smallint_col as bit_smallint_add, bit_col + tinyint_col as bit_tinyint_add, bit_col + money_col as bit_money_add, - bit_col + bit_col as bit_bit_add, bit_col + guid_col as bit_guid_add, bit_col + image_col as bit_image_add, bit_col + binary_col as bit_binary_add @@ -619,7 +618,6 @@ ORDER BY bit_smallint_add, bit_tinyint_add, bit_money_add, - bit_bit_add, bit_guid_add, bit_image_add, bit_binary_add; diff --git a/test/JDBC/input/bit_arith-vu-cleanup.sql b/test/JDBC/input/bit_arith-vu-cleanup.sql new file mode 100644 index 00000000000..6890b672b99 --- /dev/null +++ b/test/JDBC/input/bit_arith-vu-cleanup.sql @@ -0,0 +1,74 @@ +DROP VIEW bitfloatpl_vu; +GO + +DROP VIEW bitfloatmi_vu; +GO + +DROP VIEW bitfloatmul_vu; +GO + +DROP VIEW bitfloatdiv_vu; +GO + +DROP VIEW floatbitpl_vu; +GO + +DROP VIEW floatbitmi_vu; +GO + +DROP VIEW floatbitmul_vu; +GO + +DROP VIEW floatbitdiv_vu; +GO + +DROP VIEW floatbitdivfail_vu; +GO + +DROP VIEW bitbigintpl_vu; +GO + +DROP VIEW bitbigintmi_vu; +GO + +DROP VIEW bitbigintmul_vu; +GO + +DROP VIEW bitbigintdiv_vu; +GO + +DROP VIEW bitbigintdivfail_vu; +GO + +DROP VIEW bitnumericpl_vu; +GO + +DROP VIEW bitnumericmi_vu; +GO + +DROP VIEW bitnumericmul_vu; +GO + +DROP VIEW bitnumericdiv_vu; +GO + +DROP VIEW bitfloatdivfail_vu; +GO + +DROP VIEW bitsmallmoneymul_vu +GO + +DROP VIEW bitsmallmoneydiv_vu +GO + +DROP VIEW smallmoneybitmul_vu +GO + +DROP VIEW smallmoneybitdiv_vu +GO + +DROP VIEW bitsmallmoneydivfail_vu +GO + +DROP VIEW smallmoneybitdivfail_vu +GO \ No newline at end of file diff --git a/test/JDBC/input/bit_arith-vu-prepare.sql b/test/JDBC/input/bit_arith-vu-prepare.sql new file mode 100644 index 00000000000..8b8a4621526 --- /dev/null +++ b/test/JDBC/input/bit_arith-vu-prepare.sql @@ -0,0 +1,74 @@ +CREATE VIEW bitfloatpl_vu AS SELECT CAST(1 AS sys.BIT) + CAST(1234.03456 as float) AS result; +GO + +CREATE VIEW bitfloatmi_vu AS SELECT CAST(1 AS sys.BIT) - CAST(1234.03456 as float) AS result; +GO + +CREATE VIEW bitfloatmul_vu AS SELECT CAST(1 AS sys.BIT) * CAST(1234.03456 as float) AS result; +GO + +CREATE VIEW bitfloatdiv_vu AS SELECT CAST(1 AS sys.BIT) / CAST(1234.03456 as float) AS result; +GO + +CREATE VIEW bitfloatdivfail_vu AS SELECT CAST(1 AS sys.BIT) / CAST(0 as float) AS result; +GO + +CREATE VIEW floatbitpl_vu AS SELECT CAST(1234.03456 as float) + CAST(1 AS sys.BIT) AS result; +GO + +CREATE VIEW floatbitmi_vu AS SELECT CAST(1234.03456 as float) - CAST(1 AS sys.BIT) AS result; +GO + +CREATE VIEW floatbitmul_vu AS SELECT CAST(1234.03456 as float) * CAST(1 AS sys.BIT) AS result; +GO + +CREATE VIEW floatbitdiv_vu AS SELECT CAST(1234.03456 as float) / CAST(1 AS sys.BIT) AS result; +GO + +CREATE VIEW floatbitdivfail_vu AS SELECT CAST(1234.03456 as float) / CAST(0 AS sys.BIT) AS result; +GO + +CREATE VIEW bitbigintpl_vu AS SELECT CAST(1 AS sys.BIT) + CAST(1 as BIGINT) AS A, CAST(0 AS sys.BIT) + CAST(1 AS BIGINT) AS B, CAST(1 AS sys.BIT) + CAST(0 as BIGINT) AS C, CAST(0 AS sys.BIT) + CAST(0 as BIGINT) AS D; +GO + +CREATE VIEW bitbigintmi_vu AS SELECT CAST(1 AS sys.BIT) - CAST(1 as BIGINT) AS A, CAST(0 AS sys.BIT) - CAST(1 as BIGINT) AS B, CAST(1 AS sys.BIT) - CAST(0 as BIGINT) AS C, CAST(0 AS sys.BIT) - CAST(0 as BIGINT) AS D; +GO + +CREATE VIEW bitbigintmul_vu AS SELECT CAST(1 AS sys.BIT) * CAST(1 as BIGINT) AS A, CAST(0 AS sys.BIT) * CAST(1 AS BIGINT) AS B, CAST(1 AS sys.BIT) * CAST(0 as BIGINT) AS C, CAST(0 AS sys.BIT) * CAST(0 as BIGINT) AS D; +GO + +CREATE VIEW bitbigintdiv_vu AS SELECT CAST(1 AS sys.BIT) / CAST(1 as BIGINT) AS A, CAST(0 AS sys.BIT) / CAST(1 AS BIGINT) AS B; +GO + +CREATE VIEW bitbigintdivfail_vu AS SELECT CAST(1 AS sys.BIT) / CAST(0 as BIGINT) AS A; +GO + +CREATE VIEW bitnumericpl_vu AS SELECT CAST(1 AS sys.BIT) + CAST(1234.03456 as numeric) AS result; +GO + +CREATE VIEW bitnumericmi_vu AS SELECT CAST(1 AS sys.BIT) - CAST(1234.03456 as numeric) AS result; +GO + +CREATE VIEW bitnumericmul_vu AS SELECT CAST(1 AS sys.BIT) * CAST(1234.03456 as numeric) AS result; +GO + +CREATE VIEW bitnumericdiv_vu AS SELECT CAST(1 AS sys.BIT) / CAST(1234.03456 as numeric) AS result; +GO + +CREATE VIEW bitsmallmoneymul_vu AS SELECT CAST(1 AS sys.BIT) * CAST(1234.0356 as sys.SMALLMONEY) AS A, CAST(0 AS sys.BIT) * CAST(1234.0356 as sys.SMALLMONEY) AS B; +GO + +CREATE VIEW bitsmallmoneydiv_vu AS SELECT CAST(1 AS sys.BIT) / CAST(1234.0346 as sys.SMALLMONEY) AS A, CAST(0 AS sys.BIT) / CAST(1234.0346 as sys.SMALLMONEY) AS B; +GO + +CREATE VIEW smallmoneybitmul_vu AS SELECT CAST(1234.0346 as sys.SMALLMONEY) * CAST(1 as sys.BIT) AS A, CAST(1234.0346 as sys.SMALLMONEY) * CAST(0 as sys.BIT) AS B; +GO + +CREATE VIEW smallmoneybitdiv_vu AS SELECT CAST(1234.0456 as sys.SMALLMONEY) / CAST(1 as sys.BIT) AS result; +GO + +CREATE VIEW bitsmallmoneydivfail_vu AS SELECT CAST(1 AS sys.BIT) / CAST(0 as sys.SMALLMONEY) AS A; +GO + +CREATE VIEW smallmoneybitdivfail_vu AS SELECT CAST(123.456 as sys.SMALLMONEY) / CAST(0 as sys.BIT) AS result; +GO \ No newline at end of file diff --git a/test/JDBC/input/bit_arith-vu-verify.sql b/test/JDBC/input/bit_arith-vu-verify.sql new file mode 100644 index 00000000000..7813e1f3b49 --- /dev/null +++ b/test/JDBC/input/bit_arith-vu-verify.sql @@ -0,0 +1,79 @@ +SELECT * FROM bitfloatpl_vu; +GO + +SELECT * FROM bitfloatmi_vu; +GO + +SELECT * FROM bitfloatmul_vu; +GO + +SELECT * FROM bitfloatdiv_vu; +GO + +SELECT * FROM floatbitpl_vu; +GO + +SELECT * FROM floatbitmul_vu; +GO + +SELECT * FROM floatbitmi_vu; +GO + +SELECT * FROM floatbitdiv_vu; +GO + +SELECT * FROM bitbigintpl_vu; +GO + +SELECT * FROM bitbigintmi_vu; +GO + +SELECT * FROM bitbigintmul_vu; +GO + +SELECT * FROM bitbigintdiv_vu; +GO + +SELECT * FROM bitfloatdivfail_vu; +GO + +SELECT * FROM bitnumericpl_vu; +GO + +SELECT * FROM bitnumericmi_vu; +GO + +SELECT * FROM bitnumericmul_vu; +GO + +SELECT * FROM bitnumericdiv_vu; +GO + +SELECT * FROM bitbigintdivfail_vu; +GO + +SELECT * FROM floatbitdivfail_vu; +GO + +SELECT * FROM bitsmallmoneydiv_vu; +GO + +SELECT * FROM bitsmallmoneymul_vu; +GO + +SELECT * FROM smallmoneybitdivfail_vu; +GO + +SELECT * FROM smallmoneybitdiv_vu; +GO + +SELECT * FROM smallmoneybitmul_vu; +GO + +SELECT * FROM bitsmallmoneydivfail_vu; +GO + +-- bit arithmetic is not supported +-- this fails +SELECT CAST(1 AS sys.BIT) + CAST(1 as sys.BIT) AS A, CAST(0 AS sys.BIT) / CAST(1 AS sys.BIT) AS B, CAST(1 AS sys.BIT) * CAST(0 as sys.BIT) AS C, CAST(0 AS sys.BIT) - CAST(0 as sys.BIT) AS D; +GO \ No newline at end of file diff --git a/test/JDBC/input/datatypes/Test-spatial-functions-2-vu-verify.sql b/test/JDBC/input/datatypes/Test-spatial-functions-2-vu-verify.sql index 1ebace28a15..ed0ba40d5de 100644 --- a/test/JDBC/input/datatypes/Test-spatial-functions-2-vu-verify.sql +++ b/test/JDBC/input/datatypes/Test-spatial-functions-2-vu-verify.sql @@ -190,7 +190,7 @@ go --Use in a Group By Clause DECLARE @referencePoint geometry = geometry::Point(0.0, 0.0, 4326); -DECLARE @intersection_points BIT = 1; +DECLARE @intersection_points INT = 1; SELECT ROUND(PointColumn.STIntersects(@referencePoint) / @intersection_points, 0) * @intersection_points AS Intersectinggroup, COUNT(*) AS PointCount FROM TestGeospatialMethods_YourTableTemp @@ -443,7 +443,7 @@ select geometry::Point(@pnt.STY, @pnt.STX, 4326).STDisjoint(@pnt) --Use in a Group By Clause DECLARE @referencePoint geometry = geometry::Point(0.0, 0.0, 4326); -DECLARE @disjoints BIT = 1; +DECLARE @disjoints INT = 1; SELECT ROUND(PointColumn.STDisjoint(@referencePoint) / @disjoints, 0) * @disjoints AS Grp, COUNT(*) AS PointCount FROM TestGeospatialMethods_YourTableTemp diff --git a/test/JDBC/input/datatypes/Test-spatial-functions-vu-verify.sql b/test/JDBC/input/datatypes/Test-spatial-functions-vu-verify.sql index 82c9159b5a0..3ad735a3e84 100644 --- a/test/JDBC/input/datatypes/Test-spatial-functions-vu-verify.sql +++ b/test/JDBC/input/datatypes/Test-spatial-functions-vu-verify.sql @@ -201,7 +201,7 @@ select geometry::Point(@pnt.STY, @pnt.STX, 4326).STEquals(@pnt) go DECLARE @referencePoint geometry = geometry::Point(0.0, 0.0, 4326); -DECLARE @equal BIT = 1; +DECLARE @equal INT = 1; SELECT ROUND(PointColumn.STEquals(@referencePoint) / @equal, 0) * @equal AS Equalitygroup, COUNT(*) AS PointCount FROM TestSpatialFunction_YourTableTemp @@ -410,7 +410,7 @@ SET @pnt = geometry::STGeomFromText('POINT(-122.34900 47.65100)', 4326); select geometry::Point(@pnt.STY, @pnt.STX, 4326).STContains(@pnt) DECLARE @referencePoint geometry = geometry::Point(0.0, 0.0, 4326); -DECLARE @contains BIT = 1; +DECLARE @contains INT = 1; SELECT ROUND(PointColumn.STContains(@referencePoint) / @contains, 0) * @contains AS Grp, COUNT(*) AS PointCount FROM TestSpatialFunction_YourTableTemp diff --git a/test/JDBC/input/money_smallmoney-vu-cleanup.sql b/test/JDBC/input/money_smallmoney-vu-cleanup.sql new file mode 100644 index 00000000000..d67a5837cbb --- /dev/null +++ b/test/JDBC/input/money_smallmoney-vu-cleanup.sql @@ -0,0 +1,80 @@ +DROP VIEW int2smallmoneyadd_vu; +GO + +DROP VIEW int4smallmoneyadd_vu; +GO + +DROP VIEW int8smallmoneyadd_vu; +GO + +DROP VIEW smallmoneyint2add_vu; +GO + +DROP VIEW smallmoneyint4add_vu; +GO + +DROP VIEW smallmoneyint8add_vu; +GO + +DROP VIEW int2smallmoneymul_vu; +GO + +DROP VIEW int4smallmoneymul_vu; +GO + +DROP FUNCTION int2smallmoney_func() +GO + +DROP FUNCTION int8smallmoney_func() +GO + +DROP FUNCTION bitsmallmoney_func() +GO + +DROP FUNCTION bitmoney_func() +GO + +DROP FUNCTION int4smallmoney_func() +GO + +DROP FUNCTION smallintsmallmoney_func() +GO + +DROP FUNCTION principalsquared_func(sys.MONEY) +GO + +DROP TABLE money_smallmoney_vu_test; +GO + +DROP TABLE MoneyTestTable1 +GO + +DROP VIEW bitsmallmoneypl_vu; +GO + +DROP VIEW bitsmallmoneymi_vu; +GO + +DROP VIEW smallmoneybitpl_vu; +GO + +DROP VIEW smallmoneybitmi_vu; +GO + +DROP VIEW floormaxmoney_vu; +GO + +DROP VIEW ceilingminmoney_vu; +GO + +DROP VIEW powersmallmoneyfail_vu; +GO + +DROP VIEW powermoneyfail_vu; +GO + +DROP VIEW powermoney_vu; +GO + +DROP VIEW powersmallmoney_vu; +GO \ No newline at end of file diff --git a/test/JDBC/input/money_smallmoney-vu-prepare.mix b/test/JDBC/input/money_smallmoney-vu-prepare.mix new file mode 100644 index 00000000000..d6661ac2612 --- /dev/null +++ b/test/JDBC/input/money_smallmoney-vu-prepare.mix @@ -0,0 +1,206 @@ +-- tsql +CREATE VIEW int2smallmoneyadd_vu AS SELECT cast(100 AS TINYINT) + cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW int4smallmoneyadd_vu AS SELECT cast(100 AS INT) + cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW int8smallmoneyadd_vu AS SELECT cast(100 AS BIGINT) + cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW smallmoneyint2add_vu AS SELECT cast(123.45 AS SMALLMONEY) + cast(100 AS TINYINT) AS result; +GO + +CREATE VIEW smallmoneyint4add_vu AS SELECT cast(123.45 AS SMALLMONEY) + cast(100 as INT) AS result; +GO + +CREATE VIEW smallmoneyint8add_vu AS SELECT cast(123.45 AS SMALLMONEY) + cast(100 as BIGINT) AS result; +GO + +CREATE VIEW int2smallmoneymul_vu AS SELECT cast(100 AS TINYINT) * cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW int4smallmoneymul_vu AS SELECT cast(100 AS INT) * cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW bitsmallmoneypl_vu AS SELECT cast(100 AS BIT) + cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW bitsmallmoneymi_vu AS SELECT cast(100 AS BIT) - cast(123.45 AS SMALLMONEY) AS result; +GO + +CREATE VIEW smallmoneybitpl_vu AS SELECT cast(123.45 AS SMALLMONEY) + cast(100 AS BIT) AS result; +GO + +CREATE VIEW smallmoneybitmi_vu AS SELECT cast(123.45 AS SMALLMONEY) - cast(100 AS BIT) AS result; +GO + +CREATE VIEW floormaxmoney_vu AS SELECT floor(cast(922337203685477.5807 as MONEY)) AS result; +GO + +CREATE VIEW ceilingminmoney_vu AS SELECT ceiling(cast(-922337203685477.5807 as MONEY)) AS result; +GO + +CREATE VIEW powermoney_vu AS SELECT POWER(cast(-100.5807 as MONEY), 2) AS result; +GO + +CREATE VIEW powermoneyfail_vu AS SELECT POWER(cast(-92233720368.5807 as MONEY), 2) AS result; +GO + +CREATE VIEW powersmallmoney_vu AS SELECT POWER(cast(-100.5807 as SMALLMONEY), 2) AS result; +GO + +CREATE VIEW powersmallmoneyfail_vu AS SELECT POWER(cast(-92233720368.5807 as SMALLMONEY), 2) AS result; +GO + +CREATE FUNCTION principalsquared_func(@amount sys.MONEY) +RETURNS sys.MONEY +AS +BEGIN + RETURN (SELECT POWER(@amount, 2)); +END; +GO + +CREATE FUNCTION int2smallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS TINYINT) * cast(123.45 AS SMALLMONEY) + , cast(100 AS TINYINT) / cast(123.45 AS SMALLMONEY) + , cast(100 AS TINYINT) + cast(123.45 AS SMALLMONEY) + , cast(100 AS TINYINT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS TINYINT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS TINYINT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS TINYINT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS TINYINT); + RETURN 0; +END; +GO + +CREATE FUNCTION smallintsmallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS SMALLINT) * cast(123.45 AS SMALLMONEY) + , cast(100 AS SMALLINT) / cast(123.45 AS SMALLMONEY) + , cast(100 AS SMALLINT) + cast(123.45 AS SMALLMONEY) + , cast(100 AS SMALLINT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS SMALLINT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS SMALLINT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS SMALLINT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS SMALLINT); + RETURN 0; +END; +GO + + +CREATE FUNCTION int8smallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS BIGINT) * cast(123.45 AS SMALLMONEY) + , cast(100 AS BIGINT) / cast(123.45 AS SMALLMONEY) + , cast(100 AS BIGINT) + cast(123.45 AS SMALLMONEY) + , cast(100 AS BIGINT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS BIGINT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS BIGINT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS BIGINT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS BIGINT); + RETURN 0; +END; +GO + +CREATE FUNCTION bitsmallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS BIT) * cast(123.45 AS SMALLMONEY) + , cast(100 AS BIT) / cast(123.45 AS SMALLMONEY) + , cast(100 AS BIT) + cast(123.45 AS SMALLMONEY) + , cast(100 AS BIT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS BIT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS BIT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS BIT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS BIT); + RETURN 0; +END; +GO + +CREATE FUNCTION bitmoney_func() +RETURNS @test TABLE(a money, b money, c money, d money, e money, f money, g money, h money) +AS +BEGIN + INSERT INTO @test + SELECT cast(100 AS BIT) * cast(123.45 AS MONEY) + , cast(100 AS BIT) / cast(123.45 AS MONEY) + , cast(100 AS BIT) + cast(123.45 AS MONEY) + , cast(100 AS BIT) - cast(123.45 AS MONEY) + , cast(123.45 AS MONEY) * cast(100 AS BIT) + , cast(123.45 AS MONEY) / cast(100 AS BIT) + , cast(123.45 AS MONEY) + cast(100 AS BIT) + , cast(123.45 AS MONEY) - cast(100 AS BIT); + RETURN 0; +END; +GO + +CREATE FUNCTION int4smallmoney_func() +RETURNS @test TABLE(a smallmoney, b smallmoney, c smallmoney, d smallmoney, e smallmoney, f smallmoney, g smallmoney, h smallmoney) +AS +BEGIN + INSERT INTO @test + SELECT cast(1000 AS INT) * cast(123.45 AS SMALLMONEY) + , cast(10000 AS INT) / cast(123.45 AS SMALLMONEY) + , cast(10000 AS INT) + cast(123.45 AS SMALLMONEY) + , cast(10000 AS INT) - cast(123.45 AS SMALLMONEY) + , cast(123.45 AS SMALLMONEY) * cast(100 AS INT) + , cast(123.45 AS SMALLMONEY) / cast(100 AS INT) + , cast(123.45 AS SMALLMONEY) + cast(100 AS INT) + , cast(123.45 AS SMALLMONEY) - cast(100 AS INT); + RETURN; +END; +GO + +CREATE TABLE money_smallmoney_vu_test(id SERIAL, cost_sm SMALLMONEY, cost_m sys.MONEY); +GO + +CREATE INDEX idx_cost_smallmoney on money_smallmoney_vu_test(cost_sm); +GO + +CREATE INDEX idx_cost_money on money_smallmoney_vu_test(cost_m); +GO + +INSERT INTO money_smallmoney_vu_test(cost_sm, cost_m) VALUES +(100,2000), (200,40), (400,20), (300, 500), (100, 1000), +(10,100), (10,40000), (125,20), (50, 590), (300, 900), +(100,100), (10,40000), (125,20), (50, 590), (300, 900); +GO + +-- tsql +-- Create test tables +CREATE TABLE MoneyTestTable1 ( + ID INT IDENTITY(1,1), + MoneyVal MONEY, + SmallMoneyVal SMALLMONEY, + Description VARCHAR(100) +); + +-- Test default values +INSERT INTO MoneyTestTable1 DEFAULT VALUES; +GO + +INSERT INTO MoneyTestTable1 (MoneyVal, SmallMoneyVal, Description) +VALUES + (-922337203685477.5808, -214748.3648, 'MIN values'), + (922337203685477.5807, 214748.3647, 'MAX values'), + (NULL, NULL, 'NULL values'), + (CAST(RAND() * 1000000 AS MONEY), + CAST(RAND() * 10000 AS SMALLMONEY), 'Random values'), + (0.0001, 0.0001, 'Small positive values'), + (-0.0001, -0.0001, 'Small negative values'), + (0,0, 'Zero Values'); + + diff --git a/test/JDBC/input/money_smallmoney-vu-verify.mix b/test/JDBC/input/money_smallmoney-vu-verify.mix new file mode 100644 index 00000000000..e31bfafff96 --- /dev/null +++ b/test/JDBC/input/money_smallmoney-vu-verify.mix @@ -0,0 +1,3100 @@ +-- parallel_query_expected +-- psql +-- analyze the money_smallmoney_vu_test created +ANALYZE master_dbo.money_smallmoney_vu_test; +GO + +-- Display results +-- tsql +SELECT 'Range Test Results' AS TestName, * FROM MoneyTestTable1 where Description NOT LIKE 'Random values'; +GO + +-- ============================================= +-- 1.Select from dependent objects +-- ============================================= +-- tsql +SELECT * FROM dbo.int2smallmoneyadd_vu; +GO + +SELECT * FROM dbo.int4smallmoneyadd_vu; +GO + +SELECT * FROM dbo.int8smallmoneyadd_vu; +GO + +SELECT * FROM dbo.smallmoneyint2add_vu; +GO + +SELECT * FROM dbo.smallmoneyint4add_vu; +GO + +SELECT * FROM dbo.smallmoneyint8add_vu; +GO + +SELECT * FROM dbo.int2smallmoneymul_vu; +GO + +SELECT * FROM dbo.int4smallmoneymul_vu; +GO + +SELECT * FROM dbo.bitsmallmoneypl_vu; +GO + +SELECT * FROM dbo.bitsmallmoneymi_vu; +GO + +SELECT * FROM dbo.smallmoneybitpl_vu; +GO + +SELECT * FROM dbo.smallmoneybitmi_vu; +GO + +SELECT * FROM dbo.floormaxmoney_vu; +GO + +SELECT * FROM dbo.ceilingminmoney_vu; +GO + +SELECT * FROM dbo.powersmallmoney_vu; +GO + +SELECT * FROM dbo.powermoney_vu; +GO + +SELECT * FROM dbo.powersmallmoneyfail_vu; +GO + +SELECT * FROM dbo.powermoneyfail_vu; +GO + +SELECT * FROM dbo.int4smallmoney_func(); +GO + +SELECT * FROM dbo.bitsmallmoney_func(); +GO + +SELECT * FROM dbo.int8smallmoney_func(); +GO + +SELECT * FROM dbo.int2smallmoney_func(); +GO + +SELECT * FROM dbo.smallintsmallmoney_func(); +GO + +SELECT principalsquared_func(cast(1000.450 as money)); +GO + +-- =============================================================== +-- 2.Check if index is picked up for all arithmetic operations +-- =============================================================== +SELECT set_config('enable_seqscan', 'off', false); +GO + +SELECT set_config('babelfishpg_tsql.explain_costs', 'off', false) +GO + +SET babelfish_showplan_all ON; +GO + +SELECT * FROM money_smallmoney_vu_test WHERE cost_sm BETWEEN 100 and 200; +GO + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm > 100; +GO + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm <= CAST(50 AS SMALLMONEY) + CAST(50 AS SMALLMONEY); +GO + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm = CAST(2 AS INT) * CAST(50 AS SMALLMONEY); +GO + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_sm > CAST(200 AS INT) / CAST(2 AS SMALLMONEY); +GO + +SELECT cost_sm FROM money_smallmoney_vu_test WHERE cost_sm <= CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY); +GO + +SELECT * FROM money_smallmoney_vu_test WHERE cost_sm < CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY); +GO + +SELECT * FROM money_smallmoney_vu_test WHERE cost_m BETWEEN 100 and 200; +GO + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m > 100; +GO + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m >= CAST(50 AS SMALLMONEY) + CAST(50 AS SMALLMONEY); +GO + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m = CAST(2 AS INT) * CAST(50 AS SMALLMONEY); +GO + +SELECT COUNT(*) FROM money_smallmoney_vu_test WHERE cost_m < CAST(200 AS INT) / CAST(2 AS SMALLMONEY); +GO + +SELECT cost_m FROM money_smallmoney_vu_test WHERE cost_m < CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY); +GO + +SELECT * FROM money_smallmoney_vu_test WHERE cost_m > CAST(200 AS BIGINT) * CAST(2 AS SMALLMONEY); +GO + +SET babelfish_showplan_all OFF; +GO + +SELECT set_config('enable_seqscan', 'on', false); +GO +-- ============================================= +-- 3.Overflow Tests +-- ============================================= +INSERT INTO MoneyTestTable1 (MoneyVal, Description) VALUES (922337203685477.5808, 'Overflow MONEY test'); -- Exceeds maximum +GO + +INSERT INTO MoneyTestTable1 (SmallMoneyVal, Description) VALUES (214748.3648, 'Overflow SMALLMONEY test'); -- Exceeds maximum +GO + +INSERT INTO MoneyTestTable1 (MoneyVal, Description) VALUES (-922337203685477.5809, 'Underflow MONEY test'); -- Below minimum +GO + +INSERT INTO MoneyTestTable1 (SmallMoneyVal, Description) VALUES (-214748.3649, 'Underflow SMALLMONEY test'); -- Below minimum +GO + +-- Try Overflow with Arithematic Operators +-- ============================================= +-- Result Overflows +-- ============================================= +-- + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS MONEY); +GO +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS SMALLMONEY); +GO +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS TINYINT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS SMALLINT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS INT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS BIGINT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS BIT); +GO +SELECT CAST(1 AS MONEY) + CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS SMALLMONEY) + CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS TINYINT) + CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS SMALLINT) + CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS INT) + CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS BIGINT) + CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS BIT) + CAST(922337203685477.5807 AS MONEY); +GO + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= + +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS REAL); +GO +SELECT CAST(922337203685477.5807 AS MONEY) + CAST(1 AS FLOAT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS MONEY); +GO +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS SMALLMONEY); +GO +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS TINYINT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS SMALLINT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS INT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS BIGINT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) - CAST(1 AS BIT); +GO +SELECT CAST(1 AS MONEY) - CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS SMALLMONEY) - CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS TINYINT) - CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS SMALLINT) - CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS INT) - CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS BIGINT) - CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS BIT) - CAST(922337203685477.5807 AS MONEY); +GO + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- - +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS MONEY); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS SMALLMONEY); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS TINYINT); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS SMALLINT); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS INT); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS BIT); +GO +SELECT CAST(1 AS BIGINT) - CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS MONEY) - CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS SMALLMONEY) - CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS TINYINT) - CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS SMALLINT) - CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS INT) - CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS BIGINT) - CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS BIT) - CAST(-922337203685477.5808 AS MONEY); +GO + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS REAL); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) - CAST(1 AS FLOAT); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS MONEY); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS SMALLMONEY); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS TINYINT); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS SMALLINT); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS INT); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(1 AS BIT); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) + CAST(0 AS BIT); +GO +SELECT CAST(1 AS BIGINT) + CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS MONEY) + CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS SMALLMONEY) + CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS TINYINT) + CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS SMALLINT) + CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS INT) + CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS BIGINT) + CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(1 AS BIT) + CAST(-922337203685477.5808 AS MONEY); +GO +SELECT CAST(0 AS BIT) + CAST(-922337203685477.5808 AS MONEY); +GO + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- + +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1.1 AS MONEY); +GO +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1.1 AS SMALLMONEY); +GO +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(2 AS TINYINT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(2 AS SMALLINT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(2 AS INT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(2 AS BIGINT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1 AS BIT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(0 AS BIT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1.1 AS MONEY) * CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1.1 AS SMALLMONEY) * CAST(922337203685477.5807 AS MONEY);; +GO +SELECT CAST(2 AS TINYINT) * CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(2 AS SMALLINT) * CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(2 AS INT) * CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(2 AS BIGINT) * CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(0 AS BIT) * CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS BIT) * CAST(922337203685477.5807 AS MONEY); +GO + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1.1 AS REAL); +GO +SELECT CAST(922337203685477.5807 AS MONEY) * CAST(1.1 AS FLOAT); +GO + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- - +SELECT CAST(-922337203685477.5808 AS MONEY) / CAST(0.9 AS MONEY); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) / CAST(0.9 AS SMALLMONEY); +GO +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS TINYINT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS SMALLINT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS INT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS BIGINT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(2 AS BIT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(500 AS BIT); +GO +SELECT CAST(922337203685477.5807 AS MONEY) / CAST(0 AS BIT); +GO +SELECT CAST(1.1 AS MONEY) / CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1.1 AS SMALLMONEY) / CAST(922337203685477.5807 AS MONEY);; +GO +SELECT CAST(2 AS TINYINT) / CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(2 AS SMALLINT) / CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(2 AS INT) / CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(2 AS BIGINT) / CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(2 AS BIT) / CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(1 AS BIT) / CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(500 AS BIT) / CAST(922337203685477.5807 AS MONEY); +GO +SELECT CAST(0 AS BIT) / CAST(922337203685477.5807 AS MONEY); +GO + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(-922337203685477.5808 AS MONEY) / CAST(0.9 AS REAL); +GO +SELECT CAST(-922337203685477.5808 AS MONEY) / CAST(0.9 AS FLOAT); +GO + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- + +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS SMALLMONEY); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS TINYINT); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS SMALLINT); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS INT); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS BIGINT); +GO +SELECT CAST(1 AS SMALLMONEY) + CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1 AS TINYINT) + CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1 AS SMALLINT) + CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1 AS INT) + CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1 AS BIGINT) + CAST(214748.3647 AS SMALLMONEY); +GO + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS MONEY); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS REAL); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) + CAST(1 AS FLOAT); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS SMALLMONEY); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS TINYINT); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS SMALLINT); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS INT); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) - CAST(1 AS BIGINT); +GO +SELECT CAST(1 AS SMALLMONEY) - CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1 AS TINYINT) - CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1 AS SMALLINT) - CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1 AS INT) - CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1 AS BIGINT) - CAST(214748.3647 AS SMALLMONEY); +GO + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- - +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS SMALLMONEY); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS TINYINT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS SMALLINT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS INT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS BIGINT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(0 AS BIT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS BIT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS SMALLMONEY) - CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS TINYINT) - CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS SMALLINT) - CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS INT) - CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS BIGINT) - CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS BIT) - CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(0 AS BIT) - CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) - CAST(-214748.3648 AS SMALLMONEY); +GO + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS MONEY); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS REAL); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(1 AS FLOAT); +GO +SELECT CAST(1 AS MONEY) - CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS REAL) - CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS FLOAT) - CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS SMALLMONEY); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS TINYINT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS SMALLINT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS INT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) + CAST(1 AS BIGINT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) - CAST(214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS SMALLMONEY) + CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS TINYINT) + CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS SMALLINT) + CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS INT) + CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS BIGINT) + CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) + CAST(-214748.3648 AS SMALLMONEY); +GO + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- * +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS SMALLMONEY); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS TINYINT); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS SMALLINT); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS INT); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1.1 AS SMALLMONEY) * CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1.1 AS TINYINT) * CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1.1 AS SMALLINT) * CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1.1 AS INT) * CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1 AS BIT) * CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(0 AS BIT) * CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(500 AS BIT) * CAST(214748.3647 AS SMALLMONEY); +GO + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS MONEY); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS REAL); +GO +SELECT CAST(214748.3647 AS SMALLMONEY) * CAST(1.1 AS FLOAT); +GO +SELECT CAST(1.1 AS MONEY) * CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1.1 AS REAL) * CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1.1 AS FLOAT) * CAST(214748.3647 AS SMALLMONEY); +GO +SELECT CAST(-214748.3647 AS SMALLMONEY) * CAST(1.1 AS MONEY); +GO +SELECT CAST(-214748.3647 AS SMALLMONEY) * CAST(1.1 AS REAL); +GO +SELECT CAST(-214748.3647 AS SMALLMONEY) * CAST(1.1 AS FLOAT); +GO +SELECT CAST(1.1 AS MONEY) * CAST(-214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1.1 AS REAL) * CAST(-214748.3647 AS SMALLMONEY); +GO +SELECT CAST(1.1 AS FLOAT) * CAST(-214748.3647 AS SMALLMONEY); +GO + + + + +-- ============================================= +-- Result Overflows +-- ============================================= +-- / +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(0.9 AS SMALLMONEY); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(214749 AS BIGINT); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(0.9 AS SMALLMONEY); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(214749 AS BIGINT); +GO + + + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(0.9 AS MONEY); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(0.9 AS REAL); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(0.9 AS FLOAT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(2 AS BIGINT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(1 AS TINYINT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(60 AS SMALLINT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(43 AS INT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(10000 AS BIGINT); +GO +SELECT CAST(0.9 AS SMALLMONEY) / CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(2 AS BIGINT) / CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS TINYINT) / CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(60 AS SMALLINT) / CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(43 AS INT) / CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(10000 AS BIGINT) / CAST(-214748.3648 AS SMALLMONEY); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(214748 AS BIGINT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(1 AS BIT); +GO +SELECT CAST(-214748.3648 AS SMALLMONEY) / CAST(214748 AS BIT); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(0.9 AS MONEY); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(0.9 AS REAL); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(0.9 AS FLOAT); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(2 AS BIGINT); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(1 AS TINYINT); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(60 AS SMALLINT); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(43 AS INT); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(10000 AS BIGINT); +GO +SELECT CAST(0.9 AS SMALLMONEY) / CAST(214748.3648 AS SMALLMONEY); +GO +SELECT CAST(2 AS BIGINT) / CAST(214748.3648 AS SMALLMONEY); +GO +SELECT CAST(1 AS TINYINT) / CAST(214748.3648 AS SMALLMONEY); +GO +SELECT CAST(60 AS SMALLINT) / CAST(214748.3648 AS SMALLMONEY); +GO +SELECT CAST(43 AS INT) / CAST(214748.3648 AS SMALLMONEY); +GO +SELECT CAST(10000 AS BIGINT) / CAST(214748.3648 AS SMALLMONEY); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(214748 AS BIGINT); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(1 AS BIT); +GO +SELECT CAST(214748.3648 AS SMALLMONEY) / CAST(214748 AS BIT); +GO + + + + +-- ============================================= +-- Result Overflows +-- ============================================= +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) * CAST(1.0001 as SMALLMONEY) +END +GO +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(922337203685477.5807 as MONEY) * CAST(1.0001 as MONEY) +END +GO +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) + CAST(214748.3647 as SMALLMONEY) +END +GO +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) / CAST(0.5 as SMALLMONEY) +END +GO +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(-214748.3647 as SMALLMONEY) * CAST(1.001 as SMALLMONEY) +END +GO + +-- ============================================= +-- Result Does NOT Overflow +-- ============================================= +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as MONEY) * CAST(1.0001 as MONEY) +END +GO +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) + CAST(214748.3647 as MONEY) +END +GO +SELECT CASE 2 +WHEN 1 THEN CAST(5.5 as DECIMAL(10,2)) +ELSE CAST(214748.3647 as SMALLMONEY) / CAST(0.5 as MONEY) +END +GO + + +------------------------------------------------------------------------ +---- 3. Arithmetic Operations Tests +------------------------------------------------------------------------ +-- Addition (+) operator tests with MONEY +-- MONEY + MONEY +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS MONEY) AS result; +GO + +-- MONEY + SMALLMONEY +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS SMALLMONEY) AS result; +GO + +-- MONEY + TINYINT +SELECT CAST(123.45 AS MONEY) + CAST(255 AS TINYINT) AS result; +GO + +-- MONEY + SMALLINT +SELECT CAST(123.45 AS MONEY) + CAST(32767 AS SMALLINT) AS result; +GO + +-- MONEY + INT +SELECT CAST(123.45 AS MONEY) + CAST(2147483647 AS INT) AS result; +GO + +-- MONEY + BIGINT +SELECT CAST(123.45 AS MONEY) + CAST(9223372036854775807 AS BIGINT) AS result; +GO + +-- MONEY + REAL +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS REAL) AS result; +GO + +-- MONEY + FLOAT +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS FLOAT) AS result; +GO + +-- MONEY + NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) + CAST(678.90 AS NUMERIC(5,2)) AS result; +GO + +-- MONEY + NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) + CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO + +-- MONEY + NUMERIC(18,6) +SELECT CAST(123.45 AS MONEY) + CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO + +-- MONEY + BIT +SELECT CAST(123.45 AS MONEY) + CAST(1 AS BIT) AS result; +GO + +-- BIT + MONEY +SELECT CAST(1 AS BIT) + CAST(123.45 AS MONEY) AS result; +GO + +-- BIT + MONEY +SELECT CAST(0 AS BIT) + CAST(123.45 AS MONEY) AS result; +GO + +-- BIT + MONEY +SELECT CAST(-32 AS BIT) + CAST(123.45 AS MONEY) AS result; +GO + +-- BIT + MONEY +SELECT CAST(32 AS BIT) + CAST(123.45 AS MONEY) AS result; +GO + +-- Subtraction (-) operator tests with MONEY +-- MONEY - MONEY +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS MONEY) AS result; +GO + +-- MONEY - SMALLMONEY +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS SMALLMONEY) AS result; +GO + +-- MONEY - TINYINT +SELECT CAST(123.45 AS MONEY) - CAST(255 AS TINYINT) AS result; +GO + +-- MONEY - SMALLINT +SELECT CAST(123.45 AS MONEY) - CAST(32767 AS SMALLINT) AS result; +GO + +-- MONEY - INT +SELECT CAST(123.45 AS MONEY) - CAST(2147483647 AS INT) AS result; +GO + +-- MONEY - BIGINT +SELECT CAST(123.45 AS MONEY) - CAST(9223372036854775807 AS BIGINT) AS result; +GO + +-- MONEY - REAL +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS REAL) AS result; +GO + +-- MONEY - FLOAT +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS FLOAT) AS result; +GO + +-- MONEY - NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) - CAST(678.90 AS NUMERIC(5,2)) AS result; +GO + +-- MONEY - NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) - CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO + +-- MONEY - NUMERIC(18,6) +SELECT CAST(123.45 AS MONEY) - CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO + +-- MONEY - BIT +SELECT CAST(123.45 AS MONEY) - CAST(1 AS BIT) AS result; +GO + +-- MONEY * MONEY +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS MONEY) AS result; +GO + +-- MONEY * SMALLMONEY +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS SMALLMONEY) AS result; +GO + +-- MONEY * TINYINT +SELECT CAST(123.45 AS MONEY) * CAST(255 AS TINYINT) AS result; +GO + +-- MONEY * SMALLINT +SELECT CAST(123.45 AS MONEY) * CAST(32767 AS SMALLINT) AS result; +GO + +-- MONEY * INT +SELECT CAST(123.45 AS MONEY) * CAST(2147483647 AS INT) AS result; +GO + +-- MONEY * BIGINT +SELECT CAST(123.45 AS MONEY) * CAST(9223372036854775807 AS BIGINT) AS result; +GO + +-- MONEY * REAL +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS REAL) AS result; +GO + +-- MONEY * FLOAT +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS FLOAT) AS result; +GO + +-- MONEY * NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) * CAST(678.90 AS NUMERIC(5,2)) AS result; +GO + +-- MONEY * NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) * CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO + +-- MONEY * BIT +SELECT CAST(123.45 AS MONEY) * CAST(1 AS BIT) AS result; +GO + +-- Division (/) operator tests with MONEY +-- MONEY / MONEY +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS MONEY) AS result; +GO + +-- MONEY / SMALLMONEY +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS SMALLMONEY) AS result; +GO + +-- MONEY / TINYINT +SELECT CAST(123.45 AS MONEY) / CAST(255 AS TINYINT) AS result; +GO + +-- MONEY / SMALLINT +SELECT CAST(123.45 AS MONEY) / CAST(32767 AS SMALLINT) AS result; +GO + +-- MONEY / INT +SELECT CAST(123.45 AS MONEY) / CAST(2147483647 AS INT) AS result; +GO + +-- MONEY / BIGINT +SELECT CAST(123.45 AS MONEY) / CAST(9223372036854775807 AS BIGINT) AS result; +GO + +-- MONEY / REAL +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS REAL) AS result; +GO + +-- MONEY / FLOAT +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS FLOAT) AS result; +GO + +-- MONEY / NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) / CAST(678.90 AS NUMERIC(5,2)) AS result; +GO + +-- MONEY / NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) / CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO + +-- MONEY / NUMERIC(18,6) +SELECT CAST(123.45 AS MONEY) / CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO + +-- MONEY / BIT +SELECT CAST(123.45 AS MONEY) / CAST(1 AS BIT) AS result; +GO + +-- Modulo (%) operator tests with MONEY +-- MONEY % MONEY +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS MONEY) AS result; +GO + +-- MONEY % SMALLMONEY +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS SMALLMONEY) AS result; +GO + +-- MONEY % TINYINT +SELECT CAST(123.45 AS MONEY) % CAST(255 AS TINYINT) AS result; +GO + +-- MONEY % SMALLINT +SELECT CAST(123.45 AS MONEY) % CAST(32767 AS SMALLINT) AS result; +GO + +-- MONEY % INT +SELECT CAST(123.45 AS MONEY) % CAST(2147483647 AS INT) AS result; +GO + +-- MONEY % BIGINT +SELECT CAST(123.45 AS MONEY) % CAST(9223372036854775807 AS BIGINT) AS result; +GO + + +-- MONEY % REAL +-- FIXME: To be fixed in BABEL-5746 +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS REAL) AS result; +GO + + +-- MONEY % FLOAT +-- FIXME: To be fixed in BABEL-5746 +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS FLOAT) AS result; +GO + + +-- MONEY % NUMERIC(5,2) +SELECT CAST(123.45 AS MONEY) % CAST(678.90 AS NUMERIC(5,2)) AS result; +GO + +-- MONEY % NUMERIC(10,4) +SELECT CAST(123.45 AS MONEY) % CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO + +-- MONEY % NUMERIC(18,6) +SELECT CAST(123.45 AS MONEY) % CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO + +-- MONEY % BIT +SELECT CAST(123.45 AS MONEY) % CAST(1 AS BIT) AS result; +GO + + +-- Addition (+) operator tests with SMALLMONEY +-- SMALLMONEY + MONEY +SELECT CAST(123.45 AS SMALLMONEY) + CAST(678.90 AS MONEY) AS result; +GO + +-- SMALLMONEY + SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) + CAST(678.90 AS SMALLMONEY) AS result; +GO + +-- SMALLMONEY + TINYINT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(255 AS TINYINT) AS result; +GO + +-- SMALLMONEY + SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(32767 AS SMALLINT) AS result; +GO + +-- SMALLMONEY + INT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(2147483647 AS INT) AS result; +GO + +-- SMALLMONEY + BIGINT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(9223372036854775807 AS BIGINT) AS result; +GO + +-- SMALLMONEY + REAL +SELECT CAST(123.45 AS SMALLMONEY) + CAST(678.90 AS REAL) AS result; +GO + +-- SMALLMONEY + FLOAT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(678.90 AS FLOAT) AS result; +GO + +-- SMALLMONEY + BIT +SELECT CAST(123.45 AS SMALLMONEY) + CAST(1 AS BIT) AS result; +GO + +-- Subtraction (-) operator tests with SMALLMONEY +-- SMALLMONEY - MONEY +SELECT CAST(123.45 AS SMALLMONEY) - CAST(678.90 AS MONEY) AS result; +GO + +-- SMALLMONEY - SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) - CAST(678.90 AS SMALLMONEY) AS result; +GO + +-- SMALLMONEY - TINYINT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(255 AS TINYINT) AS result; +GO + +-- SMALLMONEY - SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(32767 AS SMALLINT) AS result; +GO + +-- SMALLMONEY - INT + +SELECT CAST(123.45 AS SMALLMONEY) - CAST(2147483647 AS INT) AS result; +GO + + +-- SMALLMONEY - BIGINT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(9223372036854775807 AS BIGINT) AS result; +GO + +-- SMALLMONEY - REAL +SELECT CAST(123.45 AS SMALLMONEY) - CAST(678.90 AS REAL) AS result; +GO + +-- SMALLMONEY - FLOAT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(678.90 AS FLOAT) AS result; +GO + + +-- SMALLMONEY - BIT +SELECT CAST(123.45 AS SMALLMONEY) - CAST(1 AS BIT) AS result; +GO + +-- Multiplication (*) operator tests with SMALLMONEY +-- SMALLMONEY * MONEY +SELECT CAST(123.45 AS SMALLMONEY) * CAST(678.90 AS MONEY) AS result; +GO + +-- SMALLMONEY * SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) * CAST(678.90 AS SMALLMONEY) AS result; +GO + +-- SMALLMONEY * TINYINT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(255 AS TINYINT) AS result; +GO + +-- SMALLMONEY * SMALLINT + +SELECT CAST(123.45 AS SMALLMONEY) * CAST(32767 AS SMALLINT) AS result; +GO + +-- SMALLMONEY * INT + +SELECT CAST(123.45 AS SMALLMONEY) * CAST(2147483647 AS INT) AS result; +GO + + +-- SMALLMONEY * BIGINT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(9223372036854775807 AS BIGINT) AS result; +GO + +-- SMALLMONEY * REAL +SELECT CAST(123.45 AS SMALLMONEY) * CAST(678.90 AS REAL) AS result; +GO + +-- SMALLMONEY * FLOAT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(678.90 AS FLOAT) AS result; +GO + + +-- SMALLMONEY * BIT +SELECT CAST(123.45 AS SMALLMONEY) * CAST(1 AS BIT) AS result; +GO + +-- Division (/) operator tests with SMALLMONEY +-- SMALLMONEY / MONEY +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS MONEY) AS result; +GO + +-- SMALLMONEY / SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS SMALLMONEY) AS result; +GO + +-- SMALLMONEY / TINYINT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(255 AS TINYINT) AS result; +GO + +-- SMALLMONEY / SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(32767 AS SMALLINT) AS result; +GO + + +-- SMALLMONEY / INT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(2147483647 AS INT) AS result; +GO + + +-- SMALLMONEY / BIGINT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(9223372036854775807 AS BIGINT) AS result; +GO + +-- SMALLMONEY / REAL +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS REAL) AS result; +GO + +-- SMALLMONEY / FLOAT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS FLOAT) AS result; +GO + + +-- SMALLMONEY / NUMERIC(5,2) +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.90 AS NUMERIC(5,2)) AS result; +GO + + +-- SMALLMONEY / NUMERIC(10,4) +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO + + +-- SMALLMONEY / NUMERIC(18,6) +SELECT CAST(123.45 AS SMALLMONEY) / CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO + + +-- SMALLMONEY / BIT +SELECT CAST(123.45 AS SMALLMONEY) / CAST(1 AS BIT) AS result; +GO + +-- Modulo (%) operator tests with SMALLMONEY +SELECT 'Modulo (%) Operator Tests with SMALLMONEY' AS test_description; +GO + +-- SMALLMONEY % MONEY +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS MONEY) AS result; +GO + +-- SMALLMONEY % SMALLMONEY +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS SMALLMONEY) AS result; +GO + +-- SMALLMONEY % TINYINT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(255 AS TINYINT) AS result; +GO + +-- SMALLMONEY % SMALLINT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(32767 AS SMALLINT) AS result; +GO + +-- SMALLMONEY % INT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(2147483647 AS INT) AS result; +GO + +-- SMALLMONEY % BIGINT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(9223372036854775807 AS BIGINT) AS result; +GO + + +-- SMALLMONEY % REAL +-- FIXME: To be fixed in BABEL-5746 +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS REAL) AS result; +GO + + +-- SMALLMONEY % FLOAT +-- FIXME: To be fixed in BABEL-5746 +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS FLOAT) AS result; +GO + + +-- SMALLMONEY % NUMERIC(5,2) +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.90 AS NUMERIC(5,2)) AS result; +GO + +-- SMALLMONEY % NUMERIC(10,4) +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.9012 AS NUMERIC(10,4)) AS result; +GO + +-- SMALLMONEY % NUMERIC(18,6) +SELECT CAST(123.45 AS SMALLMONEY) % CAST(678.901234 AS NUMERIC(18,6)) AS result; +GO + +-- SMALLMONEY % BIT +SELECT CAST(123.45 AS SMALLMONEY) % CAST(1 AS BIT) AS result; +GO + +-- Unary minus (-) operator tests +-- Unary Minus MONEY +SELECT -CAST(123.45 AS MONEY) AS result; +GO + +-- Unary Minus SMALLMONEY +SELECT -CAST(123.45 AS SMALLMONEY) AS result; +GO + +-- Complex Arithmetic Tests for MONEY +-- Multiple operators in single expression +SELECT (CAST(1234.56 AS MONEY) + CAST(789.12 AS MONEY)) * CAST(2 AS INT) / CAST(3 AS INT) AS result; +GO + +-- Nested calculations +SELECT CAST(100.00 AS MONEY) + (CAST(200.00 AS MONEY) * CAST(3 AS INT)) + (CAST(400.00 AS MONEY) / CAST(2 AS INT)) AS result; +GO + +-- Mixed money types calculations +SELECT (CAST(1000.00 AS MONEY) + CAST(500.00 AS SMALLMONEY)) * + (CAST(250.00 AS MONEY) + CAST(125.00 AS SMALLMONEY)) AS result; +GO + +-- Complex percentage calculations +SELECT CAST(1000.00 AS MONEY) + + (CAST(1000.00 AS MONEY) * CAST(0.10 AS FLOAT)) + -- Add 10% + (CAST(1000.00 AS MONEY) * CAST(0.05 AS FLOAT)) -- Add 5% +AS result; +GO + +-- Mixed numeric type operations +SELECT (CAST(1000.00 AS MONEY) * CAST(1.5 AS FLOAT)) + + (CAST(500.00 AS MONEY) * CAST(2.5 AS NUMERIC(5,2))) + + (CAST(250.00 AS MONEY) / CAST(2 AS INT)) +AS result; +GO + +-- Nested modulo operations +SELECT (CAST(1000.00 AS MONEY) % CAST(300 AS INT)) + + (CAST(500.00 AS MONEY) % CAST(200 AS INT)) AS result; +GO + +-- Compound interest calculation +SELECT CAST(1000.00 AS MONEY) * + POWER(CAST(1.05 AS FLOAT), 3) -- 5% interest compounded for 3 periods +AS result; +GO + +-- Tax calculation with multiple rates +SELECT CAST(1000.00 AS MONEY) + + (CAST(1000.00 AS MONEY) * CAST(0.05 AS FLOAT)) + -- State tax 5% + (CAST(1000.00 AS MONEY) * CAST(0.08 AS FLOAT)) + -- County tax 8% + (CAST(1000.00 AS MONEY) * CAST(0.02 AS FLOAT)) -- Special tax 2% +AS total_with_taxes; +GO + +-- Complex discount calculation +SELECT CAST(1000.00 AS MONEY) - + (CAST(1000.00 AS MONEY) * CAST(0.20 AS FLOAT)) - -- 20% off + (CAST(50.00 AS MONEY)) + -- Less $50 + (CAST(1000.00 AS MONEY) * CAST(0.05 AS FLOAT)) -- Plus 5% fee +AS final_price; +GO + +-- Complex division and modulo +SELECT (CAST(1234.56 AS MONEY) / CAST(2 AS INT)) + + (CAST(1234.56 AS MONEY) % CAST(500 AS INT)) + + (CAST(1234.56 AS MONEY) * CAST(0.10 AS FLOAT)) +AS result; +GO + +-- Complex SMALLMONEY Arithmetic Tests +-- Multiple operators in single expression +SELECT (CAST(123.45 AS SMALLMONEY) + CAST(78.91 AS SMALLMONEY)) * + CAST(2 AS INT) / CAST(3 AS INT) AS result; +GO + +-- Nested calculations +SELECT CAST(100.00 AS SMALLMONEY) + + (CAST(200.00 AS SMALLMONEY) * CAST(3 AS INT)) + + (CAST(400.00 AS SMALLMONEY) / CAST(2 AS INT)) AS result; +GO + +-- Mixed money types calculations +SELECT (CAST(1000.00 AS SMALLMONEY) + CAST(500.00 AS SMALLMONEY)) * + (CAST(250.00 AS MONEY) + CAST(125.00 AS SMALLMONEY)) AS result; +GO + +-- Complex percentage calculations with SMALLMONEY +SELECT CAST(1000.00 AS SMALLMONEY) + + (CAST(1000.00 AS SMALLMONEY) * CAST(0.10 AS FLOAT)) + -- Add 10% + (CAST(1000.00 AS SMALLMONEY) * CAST(0.05 AS FLOAT)) -- Add 5% +AS result; +GO + +-- Mixed numeric type operations +SELECT (CAST(1000.00 AS SMALLMONEY) * CAST(1.5 AS FLOAT)) + + (CAST(500.00 AS SMALLMONEY) * CAST(2.5 AS NUMERIC(5,2))) + + (CAST(250.00 AS SMALLMONEY) / CAST(2 AS INT)) +AS result; +GO + +-- Price adjustment calculation +SELECT CAST(100.00 AS SMALLMONEY) + + (CAST(100.00 AS SMALLMONEY) * + CASE + WHEN CAST(100.00 AS SMALLMONEY) > CAST(50.00 AS SMALLMONEY) + THEN CAST(0.10 AS FLOAT) + ELSE CAST(0.05 AS FLOAT) + END) +AS adjusted_price; +GO + +-- Multi-step calculation +SELECT (CAST(100.00 AS SMALLMONEY) * + CAST(1.10 AS FLOAT) + -- Add 10% + CAST(25.00 AS SMALLMONEY)) * -- Add fixed amount + CAST(0.95 AS FLOAT) -- Apply 5% discount +AS result; +GO + +-- Weighted average price calculation +SELECT (CAST(100.00 AS SMALLMONEY) * CAST(0.7 AS FLOAT)) + + (CAST(200.00 AS SMALLMONEY) * CAST(0.3 AS FLOAT)) +AS weighted_average; +GO + +-- Complex rounding test +SELECT CAST( + (CAST(123.456 AS FLOAT) * + CAST(100.00 AS SMALLMONEY)) / + CAST(3 AS INT) +AS SMALLMONEY) AS rounded_result; +GO + +-- Mathematical formula implementation +SELECT CAST(100.00 AS SMALLMONEY) * + POWER(CAST(1 AS FLOAT) + CAST(0.05 AS FLOAT), 4) -- Compound interest +AS future_value; +GO + +-- Complex marginal calculation +SELECT CASE + WHEN CAST(1000.00 AS SMALLMONEY) <= CAST(500.00 AS SMALLMONEY) + THEN CAST(1000.00 AS SMALLMONEY) * CAST(1.10 AS FLOAT) + WHEN CAST(1000.00 AS SMALLMONEY) <= CAST(1000.00 AS SMALLMONEY) + THEN CAST(1000.00 AS SMALLMONEY) * CAST(1.20 AS FLOAT) + ELSE CAST(1000.00 AS SMALLMONEY) * CAST(1.30 AS FLOAT) +END AS tiered_pricing; +GO + +-- Mixed arithmetic with multiple data types +SELECT (CAST(100.00 AS SMALLMONEY) * CAST(1.1 AS FLOAT)) + + (CAST(50.00 AS SMALLMONEY) / CAST(2 AS INT)) + + (CAST(25.00 AS SMALLMONEY) * CAST(0.8 AS NUMERIC(3,1))) + + CAST(10 AS TINYINT) +AS mixed_calculation; +GO + +------------------------------------------------------------------------ +---- 3. Mathematical Functions Tests +------------------------------------------------------------------------ + +-- ABS Function +-- MONEY tests +SELECT ABS(CAST(123.45 AS MONEY)) AS result; -- Positive MONEY +GO +SELECT ABS(CAST(-123.45 AS MONEY)) AS result; -- Negative MONEY +GO +SELECT ABS(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +SELECT ABS(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +SELECT ABS(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value +GO +SELECT ABS(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +SELECT ABS(CAST(-0.0001 AS MONEY)) AS result; -- Small negative MONEY value +GO +SELECT ABS(CAST(-0.00 AS MONEY)) AS result; -- Negative zero MONEY +GO + +-- SMALLMONEY tests +SELECT ABS(CAST(123.45 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +SELECT ABS(CAST(-123.45 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO +SELECT ABS(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +SELECT ABS(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +SELECT ABS(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value +GO +SELECT ABS(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +SELECT ABS(CAST(-0.0001 AS SMALLMONEY)) AS result; -- Small negative SMALLMONEY value +GO +SELECT ABS(CAST(-0.00 AS SMALLMONEY)) AS result; -- Negative zero SMALLMONEY +GO + +-- CEILING tests for MONEY + +SELECT CEILING(CAST(123.45 AS MONEY)) AS result; -- Positive MONEY +GO + +SELECT CEILING(CAST(-123.45 AS MONEY)) AS result; -- Negative MONEY +GO + +SELECT CEILING(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO + +SELECT CEILING(CAST(123.00 AS MONEY)) AS result; -- Integer value MONEY +GO + +SELECT CEILING(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO + +SELECT CEILING(CAST(999.999 AS MONEY)) AS result; -- Value close to next integer +GO + +SELECT CEILING(CAST(-999.001 AS MONEY)) AS result; -- Negative value close to integer +GO + +SELECT CEILING(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO + +SELECT CEILING(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value +GO + +SELECT CEILING(CAST(0.0001 AS MONEY)) AS result; -- Small positive value +GO + +-- CEILING tests for SMALLMONEY + +SELECT CEILING(CAST(123.45 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO + +SELECT CEILING(CAST(-123.45 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO + +SELECT CEILING(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO + +SELECT CEILING(CAST(123.00 AS SMALLMONEY)) AS result; -- Integer value SMALLMONEY +GO + +SELECT CEILING(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO + +SELECT CEILING(CAST(999.999 AS SMALLMONEY)) AS result; -- Value close to next integer +GO + +SELECT CEILING(CAST(-999.001 AS SMALLMONEY)) AS result; -- Negative value close to integer +GO + +SELECT CEILING(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO + +SELECT CEILING(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value +GO + +SELECT CEILING(CAST(0.0001 AS SMALLMONEY)) AS result; -- Small positive value +GO + +-- FLOOR tests for MONEY + +SELECT FLOOR(CAST(123.45 AS MONEY)) AS result; -- Positive MONEY +GO + +SELECT FLOOR(CAST(-123.45 AS MONEY)) AS result; -- Negative MONEY +GO + +SELECT FLOOR(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO + +SELECT FLOOR(CAST(123.00 AS MONEY)) AS result; -- Integer value MONEY +GO + +SELECT FLOOR(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO + +SELECT FLOOR(CAST(999.999 AS MONEY)) AS result; -- Value close to integer +GO + +SELECT FLOOR(CAST(-999.001 AS MONEY)) AS result; -- Negative value close to next integer +GO + +SELECT FLOOR(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO + +SELECT FLOOR(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value +GO + +SELECT FLOOR(CAST(0.0001 AS MONEY)) AS result; -- Small positive value +GO + +-- FLOOR tests for SMALLMONEY + +SELECT FLOOR(CAST(123.45 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO + +SELECT FLOOR(CAST(-123.45 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO + +SELECT FLOOR(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO + +SELECT FLOOR(CAST(123.00 AS SMALLMONEY)) AS result; -- Integer value SMALLMONEY +GO + +SELECT FLOOR(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO + +SELECT FLOOR(CAST(999.999 AS SMALLMONEY)) AS result; -- Value close to integer +GO + +SELECT FLOOR(CAST(-999.001 AS SMALLMONEY)) AS result; -- Negative value close to next integer +GO + +SELECT FLOOR(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO + +SELECT FLOOR(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value +GO + +SELECT FLOOR(CAST(0.0001 AS SMALLMONEY)) AS result; -- Small positive value +GO + +-- ROUND tests for MONEY + +SELECT ROUND(CAST(123.45 AS MONEY), 0) AS result; -- MONEY 0 decimals +GO + +SELECT ROUND(CAST(-123.45 AS MONEY), 0) AS result; -- Negative MONEY 0 decimals +GO + +SELECT ROUND(CAST(123.45 AS MONEY), 1) AS result; -- MONEY 1 decimal +GO + +SELECT ROUND(CAST(-123.45 AS MONEY), 1) AS result; -- Negative MONEY 1 decimal +GO + +SELECT ROUND(CAST(123.45 AS MONEY), 2) AS result; -- MONEY 2 decimals +GO + +SELECT ROUND(CAST(123.45 AS MONEY), 3) AS result; -- MONEY 3 decimals +GO + +SELECT ROUND(CAST(123.45 AS MONEY), -1) AS result; -- MONEY negative digits (round to tens) +GO + +SELECT ROUND(CAST(123.45 AS MONEY), -2) AS result; -- MONEY negative digits (round to hundreds) +GO + +SELECT ROUND(CAST(NULL AS MONEY), 1) AS result; -- NULL MONEY value +GO + +SELECT ROUND(CAST(123.456 AS MONEY), 2) AS result; -- Round up +GO + +SELECT ROUND(CAST(123.454 AS MONEY), 2) AS result; -- Round down +GO + +SELECT ROUND(CAST(123.455 AS MONEY), 2) AS result; -- Round half (banker's rounding) +GO + +SELECT ROUND(CAST(-123.456 AS MONEY), 2) AS result; -- Negative round up +GO + +SELECT ROUND(CAST(-123.454 AS MONEY), 2) AS result; -- Negative round down +GO + +SELECT ROUND(CAST(-123.455 AS MONEY), 2) AS result; -- Negative round half +GO + +SELECT ROUND(CAST(123.45 AS MONEY), 2, 0) AS result; -- Explicit round (default) +GO + +SELECT ROUND(CAST(123.45 AS MONEY), 2, 1) AS result; -- Explicit truncate +GO + +SELECT ROUND(CAST(555.55 AS MONEY), -2, 1) AS result; -- Truncate to hundreds +GO + +-- ROUND tests for SMALLMONEY + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 0) AS result; -- SMALLMONEY 0 decimals +GO + +SELECT ROUND(CAST(-123.45 AS SMALLMONEY), 0) AS result; -- Negative SMALLMONEY 0 decimals +GO + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 1) AS result; -- SMALLMONEY 1 decimal +GO + +SELECT ROUND(CAST(-123.45 AS SMALLMONEY), 1) AS result; -- Negative SMALLMONEY 1 decimal +GO + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 2) AS result; -- SMALLMONEY 2 decimals +GO + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 3) AS result; -- SMALLMONEY 3 decimals +GO + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), -1) AS result; -- SMALLMONEY negative digits (round to tens) +GO + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), -2) AS result; -- SMALLMONEY negative digits (round to hundreds) +GO + +SELECT ROUND(CAST(NULL AS SMALLMONEY), 1) AS result; -- NULL SMALLMONEY value +GO + +SELECT ROUND(CAST(123.456 AS SMALLMONEY), 2) AS result; -- Round up +GO + +SELECT ROUND(CAST(123.454 AS SMALLMONEY), 2) AS result; -- Round down +GO + +SELECT ROUND(CAST(123.455 AS SMALLMONEY), 2) AS result; -- Round half (banker's rounding) +GO + +SELECT ROUND(CAST(-123.456 AS SMALLMONEY), 2) AS result; -- Negative round up +GO + +SELECT ROUND(CAST(-123.454 AS SMALLMONEY), 2) AS result; -- Negative round down +GO + +SELECT ROUND(CAST(-123.455 AS SMALLMONEY), 2) AS result; -- Negative round half +GO + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 2, 0) AS result; -- Explicit round (default) +GO + +SELECT ROUND(CAST(123.45 AS SMALLMONEY), 2, 1) AS result; -- Explicit truncate +GO + +SELECT ROUND(CAST(555.55 AS SMALLMONEY), -2, 1) AS result; -- Truncate to hundreds +GO + +-- SIGN tests for MONEY +SELECT SIGN(CAST(123.45 AS MONEY)) AS result; -- Positive MONEY +GO + +SELECT SIGN(CAST(-123.45 AS MONEY)) AS result; -- Negative MONEY +GO + +SELECT SIGN(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO + +SELECT SIGN(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO + +SELECT SIGN(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO + +SELECT SIGN(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value +GO + +SELECT SIGN(CAST(0.0001 AS MONEY)) AS result; -- Small positive value +GO + +SELECT SIGN(CAST(-0.0001 AS MONEY)) AS result; -- Small negative value +GO + +-- SIGN tests for SMALLMONEY +SELECT SIGN(CAST(123.45 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO + +SELECT SIGN(CAST(-123.45 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO + +SELECT SIGN(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO + +SELECT SIGN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO + +SELECT SIGN(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO + +SELECT SIGN(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value +GO + +SELECT SIGN(CAST(0.0001 AS SMALLMONEY)) AS result; -- Small positive value +GO +SELECT POWER(CAST(12.34 AS SMALLMONEY), 14) AS result; -- power which overflows +GO + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 14) AS result; -- Negative base,power which overflows +GO + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 9) AS result; -- big power which does not overflows +GO + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 9) AS result; -- Negative base, big power which does not overflows +GO + +SELECT SIGN(CAST(-0.0001 AS SMALLMONEY)) AS result; -- Small negative value +GO + +-- POWER tests for MONEY +SELECT POWER(CAST(12.34 AS MONEY), 2) AS result; -- Positive MONEY, Integer Power +GO + +SELECT POWER(CAST(12.34 AS MONEY), 0.5) AS result; -- Positive MONEY, Decimal Power +GO + +SELECT POWER(CAST(-12.34 AS MONEY), 2) AS result; -- Negative MONEY, Even Integer Power +GO + +SELECT POWER(CAST(-12.34 AS MONEY), 3) AS result; -- Negative MONEY, Odd Integer Power +GO + +SELECT POWER(CAST(0 AS MONEY), 2) AS result; -- Zero MONEY, Positive Power +GO + +SELECT POWER(CAST(12.34 AS MONEY), 0) AS result; -- MONEY, Zero Power +GO + +SELECT POWER(CAST(12.34 AS MONEY), -2) AS result; -- MONEY, Negative Power +GO + +SELECT POWER(CAST(NULL AS MONEY), 2) AS result; -- NULL MONEY base +GO + +SELECT POWER(CAST(12.34 AS MONEY), NULL) AS result; -- NULL exponent +GO + +SELECT POWER(CAST(0 AS MONEY), 0) AS result; -- Zero raised to zero power +GO + +SELECT POWER(CAST(0 AS MONEY), -1) AS result; -- Zero raised to negative power +GO + +SELECT POWER(CAST(-12.34 AS MONEY), 0.5) AS result; -- Negative base, fractional power +GO + +SELECT POWER(CAST(12.34 AS MONEY), 14) AS result; -- power which overflows +GO + +SELECT POWER(CAST(-12.34 AS MONEY), 14) AS result; -- Negative base,power which overflows +GO + +SELECT POWER(CAST(12.34 AS MONEY), 9) AS result; -- big power which does not overflows +GO + +SELECT POWER(CAST(-12.34 AS MONEY), 9) AS result; -- Negative base, big power which does not overflows +GO + +-- POWER tests for SMALLMONEY +SELECT POWER(CAST(12.34 AS SMALLMONEY), 2) AS result; -- Positive SMALLMONEY, Integer Power +GO + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 2) AS result; -- Negative SMALLMONEY, Even Integer Power +GO + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 0.5) AS result; -- Positive SMALLMONEY, Decimal Power +GO + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 3) AS result; -- Negative SMALLMONEY, Odd Integer Power +GO + +SELECT POWER(CAST(0 AS SMALLMONEY), 2) AS result; -- Zero SMALLMONEY, Positive Power +GO + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 0) AS result; -- SMALLMONEY, Zero Power +GO + +SELECT POWER(CAST(12.34 AS SMALLMONEY), -2) AS result; -- SMALLMONEY, Negative Power +GO + +SELECT POWER(CAST(NULL AS SMALLMONEY), 2) AS result; -- NULL SMALLMONEY base +GO + +SELECT POWER(CAST(12.34 AS SMALLMONEY), NULL) AS result; -- NULL exponent +GO + +SELECT POWER(CAST(0 AS SMALLMONEY), 0) AS result; -- Zero raised to zero power +GO + +SELECT POWER(CAST(0 AS SMALLMONEY), -1) AS result; -- Zero raised to negative power +GO + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 0.5) AS result; -- Negative base, fractional power +GO + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 14) AS result; -- power which overflows +GO + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 14) AS result; -- Negative base,power which overflows +GO + +SELECT POWER(CAST(12.34 AS SMALLMONEY), 9) AS result; -- big power which does not overflows +GO + +SELECT POWER(CAST(-12.34 AS SMALLMONEY), 9) AS result; -- Negative base, big power which does not overflows +GO + +-- SQRT tests for MONEY +SELECT SQRT(CAST(144.00 AS MONEY)) AS result; -- Positive MONEY +GO +SELECT SQRT(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +SELECT SQRT(CAST(12.25 AS MONEY)) AS result; -- Decimal MONEY +GO +SELECT SQRT(CAST(-144.00 AS MONEY)) AS result; -- Negative MONEY (should return NULL) +GO +SELECT SQRT(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +SELECT SQRT(CAST(2.00 AS MONEY)) AS result; -- Irrational result +GO +SELECT SQRT(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO +SELECT SQRT(CAST(0.0001 AS MONEY)) AS result; -- Small positive value +GO + +-- SQRT tests for SMALLMONEY +SELECT SQRT(CAST(144.00 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +SELECT SQRT(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +SELECT SQRT(CAST(12.25 AS SMALLMONEY)) AS result; -- Decimal SMALLMONEY +GO +SELECT SQRT(CAST(-144.00 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY (should return NULL) +GO +SELECT SQRT(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +SELECT SQRT(CAST(2.00 AS SMALLMONEY)) AS result; -- Irrational result +GO +SELECT SQRT(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO +SELECT SQRT(CAST(0.0001 AS SMALLMONEY)) AS result; -- Small positive value +GO + +-- LOG tests for MONEY +SELECT LOG(CAST(100.00 AS MONEY)) AS result; -- Positive MONEY +GO +SELECT LOG(CAST(0.5 AS MONEY)) AS result; -- MONEY between 0 and 1 +GO +SELECT LOG(CAST(0 AS MONEY)) AS result; -- Zero MONEY (should return error or NULL) +GO +SELECT LOG(CAST(-100.00 AS MONEY)) AS result; -- Negative MONEY (should return error or NULL) +GO +SELECT LOG(CAST(1.00 AS MONEY)) AS result; -- LOG of 1 (should be 0) +GO +SELECT LOG(CAST(2.718281828459045 AS MONEY)) AS result; -- LOG of e (should be 1) +GO +SELECT LOG(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +SELECT LOG(CAST(0.0001 AS MONEY)) AS result; -- Very small positive number +GO +SELECT LOG(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO + +-- LOG tests for SMALLMONEY +SELECT LOG(CAST(100.00 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +SELECT LOG(CAST(0.5 AS SMALLMONEY)) AS result; -- SMALLMONEY between 0 and 1 +GO +SELECT LOG(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY (should return error or NULL) +GO +SELECT LOG(CAST(-100.00 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY (should return error or NULL) +GO +SELECT LOG(CAST(1.00 AS SMALLMONEY)) AS result; -- LOG of 1 (should be 0) +GO +SELECT LOG(CAST(2.718281828459045 AS SMALLMONEY)) AS result; -- LOG of e (should be 1) +GO +SELECT LOG(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +SELECT LOG(CAST(0.0001 AS SMALLMONEY)) AS result; -- Very small positive number +GO +SELECT LOG(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO + +-- LOG10 tests for MONEY +SELECT LOG10(CAST(100.00 AS MONEY)) AS result; -- Positive MONEY +GO +SELECT LOG10(CAST(0.5 AS MONEY)) AS result; -- MONEY between 0 and 1 +GO +SELECT LOG10(CAST(0 AS MONEY)) AS result; -- Zero MONEY (should return error or NULL) +GO +SELECT LOG10(CAST(-100.00 AS MONEY)) AS result; -- Negative MONEY (should return error or NULL) +GO +SELECT LOG10(CAST(1.00 AS MONEY)) AS result; -- LOG10 of 1 (should be 0) +GO +SELECT LOG10(CAST(10.00 AS MONEY)) AS result; -- LOG10 of 10 (should be 1) +GO +SELECT LOG10(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +SELECT LOG10(CAST(0.0001 AS MONEY)) AS result; -- Very small positive number +GO +SELECT LOG10(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value +GO + +-- LOG10 tests for SMALLMONEY +SELECT LOG10(CAST(100.00 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +SELECT LOG10(CAST(0.5 AS SMALLMONEY)) AS result; -- SMALLMONEY between 0 and 1 +GO +SELECT LOG10(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY (should return error or NULL) +GO +SELECT LOG10(CAST(-100.00 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY (should return error or NULL) +GO +SELECT LOG10(CAST(1.00 AS SMALLMONEY)) AS result; -- LOG10 of 1 (should be 0) +GO +SELECT LOG10(CAST(10.00 AS SMALLMONEY)) AS result; -- LOG10 of 10 (should be 1) +GO +SELECT LOG10(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +SELECT LOG10(CAST(0.0001 AS SMALLMONEY)) AS result; -- Very small positive number +GO +SELECT LOG10(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value +GO + +-- EXP tests for MONEY +SELECT EXP(CAST(1.00 AS MONEY)) AS result; -- Positive MONEY +GO +SELECT EXP(CAST(-1.00 AS MONEY)) AS result; -- Negative MONEY +GO +SELECT EXP(CAST(0 AS MONEY)) AS result; -- Zero MONEY +GO +SELECT TRY_CAST(EXP(CAST(1000.00 AS MONEY)) AS FLOAT) AS result; -- Large value causing overflow +GO +SELECT EXP(CAST(NULL AS MONEY)) AS result; -- NULL MONEY value +GO +SELECT EXP(CAST(0.5 AS MONEY)) AS result; -- Fractional value +GO +SELECT EXP(CAST(-0.5 AS MONEY)) AS result; -- Negative fractional value +GO +SELECT EXP(CAST(10.00 AS MONEY)) AS result; -- Larger positive value +GO +SELECT EXP(CAST(-10.00 AS MONEY)) AS result; -- Larger negative value +GO + +-- EXP tests for SMALLMONEY +SELECT EXP(CAST(1.00 AS SMALLMONEY)) AS result; -- Positive SMALLMONEY +GO +SELECT EXP(CAST(-1.00 AS SMALLMONEY)) AS result; -- Negative SMALLMONEY +GO +SELECT EXP(CAST(0 AS SMALLMONEY)) AS result; -- Zero SMALLMONEY +GO +SELECT TRY_CAST(EXP(CAST(1000.00 AS SMALLMONEY)) AS FLOAT) AS result; -- Large value causing overflow +GO +SELECT EXP(CAST(NULL AS SMALLMONEY)) AS result; -- NULL SMALLMONEY value +GO +SELECT EXP(CAST(0.5 AS SMALLMONEY)) AS result; -- Fractional value +GO +SELECT EXP(CAST(-0.5 AS SMALLMONEY)) AS result; -- Negative fractional value +GO +SELECT EXP(CAST(10.00 AS SMALLMONEY)) AS result; -- Larger positive value +GO +SELECT EXP(CAST(-10.00 AS SMALLMONEY)) AS result; -- Larger negative value +GO + +-- SIN tests for MONEY +SELECT SIN(CAST(1.0 AS MONEY)) AS result; -- MONEY +GO +SELECT SIN(CAST(0 AS MONEY)) AS result; -- Zero +GO +SELECT SIN(CAST(PI() AS MONEY)) AS result; -- PI +GO +SELECT SIN(CAST(PI()/2 AS MONEY)) AS result; -- PI/2 (90 degrees) +GO +SELECT SIN(CAST(PI()/6 AS MONEY)) AS result; -- PI/6 (30 degrees) +GO +SELECT SIN(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +SELECT SIN(CAST(-PI()/2 AS MONEY)) AS result; -- -PI/2 (-90 degrees) +GO +SELECT SIN(CAST(2*PI() AS MONEY)) AS result; -- 2*PI (360 degrees) +GO +SELECT SIN(CAST(100.00 AS MONEY)) AS result; -- Large value +GO + +-- SIN tests for SMALLMONEY +SELECT SIN(CAST(1.0 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +SELECT SIN(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +SELECT SIN(CAST(PI() AS SMALLMONEY)) AS result; -- PI +GO +SELECT SIN(CAST(PI()/2 AS SMALLMONEY)) AS result; -- PI/2 (90 degrees) +GO +SELECT SIN(CAST(PI()/6 AS SMALLMONEY)) AS result; -- PI/6 (30 degrees) +GO +SELECT SIN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +SELECT SIN(CAST(-PI()/2 AS SMALLMONEY)) AS result; -- -PI/2 (-90 degrees) +GO +SELECT SIN(CAST(2*PI() AS SMALLMONEY)) AS result; -- 2*PI (360 degrees) +GO +SELECT SIN(CAST(100.00 AS SMALLMONEY)) AS result; -- Large value +GO + +-- COS tests for MONEY +SELECT COS(CAST(1.0 AS MONEY)) AS result; -- MONEY +GO +SELECT COS(CAST(0 AS MONEY)) AS result; -- Zero +GO +SELECT COS(CAST(PI() AS MONEY)) AS result; -- PI +GO +SELECT COS(CAST(PI()/2 AS MONEY)) AS result; -- PI/2 (90 degrees) +GO +SELECT COS(CAST(PI()/3 AS MONEY)) AS result; -- PI/3 (60 degrees) +GO +SELECT COS(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +SELECT COS(CAST(-PI() AS MONEY)) AS result; -- -PI (-180 degrees) +GO +SELECT COS(CAST(2*PI() AS MONEY)) AS result; -- 2*PI (360 degrees) +GO +SELECT COS(CAST(100.00 AS MONEY)) AS result; -- Large value +GO + +-- COS tests for SMALLMONEY +SELECT COS(CAST(1.0 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +SELECT COS(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +SELECT COS(CAST(PI() AS SMALLMONEY)) AS result; -- PI +GO +SELECT COS(CAST(PI()/2 AS SMALLMONEY)) AS result; -- PI/2 (90 degrees) +GO +SELECT COS(CAST(PI()/3 AS SMALLMONEY)) AS result; -- PI/3 (60 degrees) +GO +SELECT COS(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +SELECT COS(CAST(-PI() AS SMALLMONEY)) AS result; -- -PI (-180 degrees) +GO +SELECT COS(CAST(2*PI() AS SMALLMONEY)) AS result; -- 2*PI (360 degrees) +GO +SELECT COS(CAST(100.00 AS SMALLMONEY)) AS result; -- Large value +GO + +-- TAN tests for MONEY +SELECT TAN(CAST(1.0 AS MONEY)) AS result; -- MONEY +GO +SELECT TAN(CAST(0 AS MONEY)) AS result; -- Zero +GO +SELECT TAN(CAST(PI()/4 AS MONEY)) AS result; -- PI/4 (45 degrees) +GO +SELECT TAN(CAST(PI() AS MONEY)) AS result; -- PI (180 degrees) +GO +SELECT TAN(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +SELECT TAN(CAST(-PI()/4 AS MONEY)) AS result; -- -PI/4 (-45 degrees) +GO +SELECT TAN(CAST(PI()/2 - 0.000001 AS MONEY)) AS result; -- Near PI/2 (near 90 degrees) +GO +SELECT TAN(CAST(3*PI()/2 - 0.000001 AS MONEY)) AS result; -- Near 3*PI/2 (near 270 degrees) +GO + +-- TAN tests for SMALLMONEY +SELECT TAN(CAST(1.0 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +SELECT TAN(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +SELECT TAN(CAST(PI()/4 AS SMALLMONEY)) AS result; -- PI/4 (45 degrees) +GO +SELECT TAN(CAST(PI() AS SMALLMONEY)) AS result; -- PI (180 degrees) +GO +SELECT TAN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +SELECT TAN(CAST(-PI()/4 AS SMALLMONEY)) AS result; -- -PI/4 (-45 degrees) +GO +SELECT TAN(CAST(PI()/2 - 0.000001 AS SMALLMONEY)) AS result; -- Near PI/2 (near 90 degrees) +GO +SELECT TAN(CAST(3*PI()/2 - 0.000001 AS SMALLMONEY)) AS result; -- Near 3*PI/2 (near 270 degrees) +GO + +-- ASIN tests for MONEY +SELECT ASIN(CAST(0.5 AS MONEY)) AS result; -- MONEY +GO +SELECT ASIN(CAST(0 AS MONEY)) AS result; -- Zero +GO +SELECT ASIN(CAST(1 AS MONEY)) AS result; -- One +GO +SELECT ASIN(CAST(-1 AS MONEY)) AS result; -- Negative one +GO +SELECT ASIN(CAST(2 AS MONEY)) AS result; -- Out of range (should return NULL) +GO +SELECT ASIN(CAST(-2 AS MONEY)) AS result; -- Out of range negative (should return NULL) +GO +SELECT ASIN(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +SELECT ASIN(CAST(0.7071067811865475 AS MONEY)) AS result; -- sin(PI/4) +GO +SELECT ASIN(CAST(0.8660254037844386 AS MONEY)) AS result; -- sin(PI/3) +GO + +-- ASIN tests for SMALLMONEY +SELECT ASIN(CAST(0.5 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +SELECT ASIN(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +SELECT ASIN(CAST(1 AS SMALLMONEY)) AS result; -- One +GO +SELECT ASIN(CAST(-1 AS SMALLMONEY)) AS result; -- Negative one +GO +SELECT ASIN(CAST(2 AS SMALLMONEY)) AS result; -- Out of range (should return NULL) +GO +SELECT ASIN(CAST(-2 AS SMALLMONEY)) AS result; -- Out of range negative (should return NULL) +GO +SELECT ASIN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +SELECT ASIN(CAST(0.7071067811865475 AS SMALLMONEY)) AS result; -- sin(PI/4) +GO +SELECT ASIN(CAST(0.8660254037844386 AS SMALLMONEY)) AS result; -- sin(PI/3) +GO + +-- ACOS tests for MONEY +SELECT ACOS(CAST(0.5 AS MONEY)) AS result; -- MONEY +GO +SELECT ACOS(CAST(0 AS MONEY)) AS result; -- Zero +GO +SELECT ACOS(CAST(1 AS MONEY)) AS result; -- One +GO +SELECT ACOS(CAST(-1 AS MONEY)) AS result; -- Negative one +GO +SELECT ACOS(CAST(2 AS MONEY)) AS result; -- Out of range (should return NULL) +GO +SELECT ACOS(CAST(-2 AS MONEY)) AS result; -- Out of range negative (should return NULL) +GO +SELECT ACOS(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +SELECT ACOS(CAST(0.7071067811865475 AS MONEY)) AS result; -- cos(PI/4) +GO +SELECT ACOS(CAST(0.5 AS MONEY)) AS result; -- cos(PI/3) +GO + +-- ACOS tests for SMALLMONEY +SELECT ACOS(CAST(0.5 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +SELECT ACOS(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +SELECT ACOS(CAST(1 AS SMALLMONEY)) AS result; -- One +GO +SELECT ACOS(CAST(-1 AS SMALLMONEY)) AS result; -- Negative one +GO +SELECT ACOS(CAST(2 AS SMALLMONEY)) AS result; -- Out of range (should return NULL) +GO +SELECT ACOS(CAST(-2 AS SMALLMONEY)) AS result; -- Out of range negative (should return NULL) +GO +SELECT ACOS(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +SELECT ACOS(CAST(0.7071067811865475 AS SMALLMONEY)) AS result; -- cos(PI/4) +GO +SELECT ACOS(CAST(0.5 AS SMALLMONEY)) AS result; -- cos(PI/3) +GO + +-- ATAN tests for MONEY +SELECT ATAN(CAST(1.0 AS MONEY)) AS result; -- MONEY +GO +SELECT ATAN(CAST(0 AS MONEY)) AS result; -- Zero +GO +SELECT ATAN(CAST(1000000 AS MONEY)) AS result; -- Large value +GO +SELECT ATAN(CAST(-1.0 AS MONEY)) AS result; -- Negative value +GO +SELECT ATAN(CAST(NULL AS MONEY)) AS result; -- NULL value +GO +SELECT ATAN(CAST(1.7320508075688772 AS MONEY)) AS result; -- tan(PI/3) +GO +SELECT ATAN(CAST(-1.7320508075688772 AS MONEY)) AS result; -- tan(-PI/3) +GO +SELECT ATAN(CAST(922337203685477.5807 AS MONEY)) AS result; -- Maximum MONEY value (approaches PI/2) +GO +SELECT ATAN(CAST(-922337203685477.5808 AS MONEY)) AS result; -- Minimum MONEY value (approaches -PI/2) +GO + +-- ATAN tests for SMALLMONEY +SELECT ATAN(CAST(1.0 AS SMALLMONEY)) AS result; -- SMALLMONEY +GO +SELECT ATAN(CAST(0 AS SMALLMONEY)) AS result; -- Zero +GO +SELECT ATAN(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Large value +GO +SELECT ATAN(CAST(-1.0 AS SMALLMONEY)) AS result; -- Negative value +GO +SELECT ATAN(CAST(NULL AS SMALLMONEY)) AS result; -- NULL value +GO +SELECT ATAN(CAST(1.7320508075688772 AS SMALLMONEY)) AS result; -- tan(PI/3) +GO +SELECT ATAN(CAST(-1.7320508075688772 AS SMALLMONEY)) AS result; -- tan(-PI/3) +GO +SELECT ATAN(CAST(214748.3647 AS SMALLMONEY)) AS result; -- Maximum SMALLMONEY value (approaches PI/2) +GO +SELECT ATAN(CAST(-214748.3648 AS SMALLMONEY)) AS result; -- Minimum SMALLMONEY value (approaches -PI/2) +GO + +------------------------------------------------------------------------ +---- 4. Comparison Operators +------------------------------------------------------------------------ +-- Equality (=) operator tests +-- MONEY = MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = MONEY]; +GO +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) = CAST(922337203685477.5807 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MAX MONEY = MAX MONEY]; +GO +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) = CAST(-922337203685477.5808 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MIN MONEY = MIN MONEY]; +GO +SELECT CASE WHEN CAST(0.0000 AS MONEY) = CAST(0.0000 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [ZERO MONEY = ZERO MONEY]; +GO +SELECT CASE WHEN CAST(-123.45 AS MONEY) = CAST(-123.45 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [NEG MONEY = NEG MONEY]; +GO + +-- SMALLMONEY = SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) = CAST(123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY = SMALLMONEY]; +GO +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) = CAST(214748.3647 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MAX SMALLMONEY = MAX SMALLMONEY]; +GO +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) = CAST(-214748.3648 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MIN SMALLMONEY = MIN SMALLMONEY]; +GO +SELECT CASE WHEN CAST(0.0000 AS SMALLMONEY) = CAST(0.0000 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [ZERO SMALLMONEY = ZERO SMALLMONEY]; +GO +SELECT CASE WHEN CAST(-123.45 AS SMALLMONEY) = CAST(-123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [NEG SMALLMONEY = NEG SMALLMONEY]; +GO + + + +-- Cross money-type comparisons +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = SMALLMONEY]; +GO + +-- Money types with other numeric types +SELECT CASE WHEN CAST(123.45 AS MONEY) = 123.45 THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = Literal]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS FLOAT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = FLOAT]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS REAL) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = REAL]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123.45 AS NUMERIC(5,2)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = NUMERIC]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123 AS INT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = INT]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123 AS BIGINT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = BIGINT]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123 AS SMALLINT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = SMALLINT]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(123 AS TINYINT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = TINYINT]; +GO + +-- Money types with string types +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST('123.45' AS VARCHAR(20)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = VARCHAR]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST('123.45' AS CHAR(20)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = CHAR]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST('123.45' AS NVARCHAR(20)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = NVARCHAR]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST('123.45' AS NCHAR(20)) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = NCHAR]; +GO + +-- Money types with SQL_VARIANT +SELECT CASE WHEN CAST(123.45 AS MONEY) = CAST(CAST(123.45 AS MONEY) AS SQL_VARIANT) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY = SQL_VARIANT]; +GO +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) = CAST(CAST(123.45 AS SMALLMONEY) AS SQL_VARIANT) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY = SQL_VARIANT]; +GO + +-- Inequality (<>) operator tests +-- MONEY <> MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) <> CAST(123.46 AS MONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MONEY <> MONEY]; +GO +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) <> CAST(922337203685477.5806 AS MONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MAX MONEY <> NEAR MAX]; +GO +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) <> CAST(-922337203685477.5807 AS MONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MIN MONEY <> NEAR MIN]; +GO + +-- SMALLMONEY <> SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) <> CAST(123.46 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [SMALLMONEY <> SMALLMONEY]; +GO +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) <> CAST(214748.3646 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MAX SMALLMONEY <> NEAR MAX]; +GO +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) <> CAST(-214748.3647 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MIN SMALLMONEY <> NEAR MIN]; +GO + +-- Cross money-type inequalities +SELECT CASE WHEN CAST(123.45 AS MONEY) <> CAST(123.46 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [MONEY <> SMALLMONEY]; +GO + +-- Greater than (>) operator tests + +-- MONEY > MONEY +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS MONEY) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > MONEY]; +GO +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) > CAST(922337203685477.5806 AS MONEY) THEN 'Greater' ELSE 'Not Greater' END AS [MAX MONEY > NEAR MAX]; +GO +SELECT CASE WHEN CAST(-922337203685477.5807 AS MONEY) > CAST(-922337203685477.5808 AS MONEY) THEN 'Greater' ELSE 'Not Greater' END AS [NEAR MIN > MIN MONEY]; +GO + +-- SMALLMONEY > SMALLMONEY +SELECT CASE WHEN CAST(123.46 AS SMALLMONEY) > CAST(123.45 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [SMALLMONEY > SMALLMONEY]; +GO +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) > CAST(214748.3646 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [MAX SMALLMONEY > NEAR MAX]; +GO +SELECT CASE WHEN CAST(-214748.3647 AS SMALLMONEY) > CAST(-214748.3648 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [NEAR MIN > MIN SMALLMONEY]; +GO + +-- Cross money-type greater than +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > SMALLMONEY]; +GO + +-- Money types greater than other numeric types +SELECT CASE WHEN CAST(123.46 AS MONEY) > 123.45 THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > Literal]; +GO +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS FLOAT) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > FLOAT]; +GO +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS REAL) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > REAL]; +GO +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123.45 AS NUMERIC(5,2)) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > NUMERIC]; +GO +SELECT CASE WHEN CAST(123.46 AS MONEY) > CAST(123 AS INT) THEN 'Greater' ELSE 'Not Greater' END AS [MONEY > INT]; +GO + +-- Less than (<) operator tests +SELECT 'Less Than (<) Operator Tests' AS test_description; +GO + +-- MONEY < MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS MONEY) THEN 'Less' ELSE 'Not Less' END AS [MONEY < MONEY]; +GO +SELECT CASE WHEN CAST(922337203685477.5806 AS MONEY) < CAST(922337203685477.5807 AS MONEY) THEN 'Less' ELSE 'Not Less' END AS [NEAR MAX < MAX MONEY]; +GO +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) < CAST(-922337203685477.5807 AS MONEY) THEN 'Less' ELSE 'Not Less' END AS [MIN MONEY < NEAR MIN]; +GO + +-- SMALLMONEY < SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) < CAST(123.46 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [SMALLMONEY < SMALLMONEY]; +GO +SELECT CASE WHEN CAST(214748.3646 AS SMALLMONEY) < CAST(214748.3647 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [NEAR MAX < MAX SMALLMONEY]; +GO +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) < CAST(-214748.3647 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [MIN SMALLMONEY < NEAR MIN]; +GO + +-- Cross money-type less than +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [MONEY < SMALLMONEY]; +GO + +-- Money types less than other numeric types +SELECT CASE WHEN CAST(123.45 AS MONEY) < 123.46 THEN 'Less' ELSE 'Not Less' END AS [MONEY < Literal]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS FLOAT) THEN 'Less' ELSE 'Not Less' END AS [MONEY < FLOAT]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS REAL) THEN 'Less' ELSE 'Not Less' END AS [MONEY < REAL]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(123.46 AS NUMERIC(5,2)) THEN 'Less' ELSE 'Not Less' END AS [MONEY < NUMERIC]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) < CAST(124 AS INT) THEN 'Less' ELSE 'Not Less' END AS [MONEY < INT]; +GO + +-- Greater than or equal to (>=) operator tests +-- MONEY >= MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) >= CAST(123.45 AS MONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MONEY >= MONEY (Equal)]; +GO +SELECT CASE WHEN CAST(123.46 AS MONEY) >= CAST(123.45 AS MONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MONEY >= MONEY (Greater)]; +GO +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) >= CAST(922337203685477.5807 AS MONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MAX MONEY >= MAX MONEY]; +GO + +-- SMALLMONEY >= SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) >= CAST(123.45 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [SMALLMONEY >= SMALLMONEY (Equal)]; +GO +SELECT CASE WHEN CAST(123.46 AS SMALLMONEY) >= CAST(123.45 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [SMALLMONEY >= SMALLMONEY (Greater)]; +GO +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) >= CAST(214748.3647 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MAX SMALLMONEY >= MAX SMALLMONEY]; +GO + +-- Cross money-type greater than or equal +SELECT CASE WHEN CAST(123.45 AS MONEY) >= CAST(123.45 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MONEY >= SMALLMONEY (Equal)]; +GO +SELECT CASE WHEN CAST(123.46 AS MONEY) >= CAST(123.45 AS SMALLMONEY) THEN 'Greater or Equal' ELSE 'Less' END AS [MONEY >= SMALLMONEY (Greater)]; +GO + +-- Less than or equal to (<=) operator tests +-- MONEY <= MONEY +SELECT CASE WHEN CAST(123.45 AS MONEY) <= CAST(123.45 AS MONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MONEY <= MONEY (Equal)]; +GO +SELECT CASE WHEN CAST(123.45 AS MONEY) <= CAST(123.46 AS MONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MONEY <= MONEY (Less)]; +GO +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) <= CAST(922337203685477.5807 AS MONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MAX MONEY <= MAX MONEY]; +GO +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) <= CAST(-922337203685477.5808 AS MONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MIN MONEY <= MIN MONEY]; +GO + +-- SMALLMONEY <= SMALLMONEY +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) <= CAST(123.45 AS SMALLMONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [SMALLMONEY <= SMALLMONEY (Equal)]; +GO +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) <= CAST(123.46 AS SMALLMONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [SMALLMONEY <= SMALLMONEY (Less)]; +GO +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) <= CAST(214748.3647 AS SMALLMONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MAX SMALLMONEY <= MAX SMALLMONEY]; +GO +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) <= CAST(-214748.3648 AS SMALLMONEY) THEN 'Less or Equal' ELSE 'Greater' END AS [MIN SMALLMONEY <= MIN SMALLMONEY]; +GO + +-- BETWEEN operator tests +-- MONEY BETWEEN +SELECT CASE WHEN CAST(123.45 AS MONEY) BETWEEN CAST(123.44 AS MONEY) AND CAST(123.46 AS MONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [MONEY BETWEEN]; +GO +SELECT CASE WHEN CAST(0.00 AS MONEY) BETWEEN CAST(-1.00 AS MONEY) AND CAST(1.00 AS MONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [MONEY BETWEEN (Zero)]; +GO +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) BETWEEN CAST(922337203685477.5806 AS MONEY) AND CAST(922337203685477.5807 AS MONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [MONEY BETWEEN (Max)]; +GO + +-- SMALLMONEY BETWEEN +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) BETWEEN CAST(123.44 AS SMALLMONEY) AND CAST(123.46 AS SMALLMONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [SMALLMONEY BETWEEN]; +GO +SELECT CASE WHEN CAST(0.00 AS SMALLMONEY) BETWEEN CAST(-1.00 AS SMALLMONEY) AND CAST(1.00 AS SMALLMONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [SMALLMONEY BETWEEN (Zero)]; +GO +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) BETWEEN CAST(214748.3646 AS SMALLMONEY) AND CAST(214748.3647 AS SMALLMONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [SMALLMONEY BETWEEN (Max)]; +GO + +-- Cross type BETWEEN +SELECT CASE WHEN CAST(123.45 AS MONEY) BETWEEN CAST(123.44 AS SMALLMONEY) AND CAST(123.46 AS SMALLMONEY) + THEN 'In Range' ELSE 'Not In Range' END AS [MONEY BETWEEN SMALLMONEY]; +GO + +-- IN operator tests +-- MONEY IN +SELECT CASE WHEN CAST(123.45 AS MONEY) IN (CAST(123.44 AS MONEY), CAST(123.45 AS MONEY), CAST(123.46 AS MONEY)) + THEN 'In List' ELSE 'Not In List' END AS [MONEY IN]; +GO +SELECT CASE WHEN CAST(0.00 AS MONEY) IN (CAST(-1.00 AS MONEY), CAST(0.00 AS MONEY), CAST(1.00 AS MONEY)) + THEN 'In List' ELSE 'Not In List' END AS [MONEY IN (Zero)]; +GO + +-- SMALLMONEY IN +SELECT CASE WHEN CAST(123.45 AS SMALLMONEY) IN (CAST(123.44 AS SMALLMONEY), CAST(123.45 AS SMALLMONEY), CAST(123.46 AS SMALLMONEY)) + THEN 'In List' ELSE 'Not In List' END AS [SMALLMONEY IN]; +GO +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) IN (CAST(214748.3646 AS SMALLMONEY), CAST(214748.3647 AS SMALLMONEY)) + THEN 'In List' ELSE 'Not In List' END AS [SMALLMONEY IN (Max)]; +GO + +-- Cross type IN +SELECT CASE WHEN CAST(123.45 AS MONEY) IN (CAST(123.44 AS SMALLMONEY), CAST(123.45 AS SMALLMONEY), CAST(123.46 AS SMALLMONEY)) + THEN 'In List' ELSE 'Not In List' END AS [MONEY IN SMALLMONEY]; +GO + +-- NULL comparison tests +-- MONEY NULL comparisons +SELECT CASE WHEN CAST(NULL AS MONEY) = CAST(123.45 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [NULL MONEY = MONEY]; +GO +SELECT CASE WHEN CAST(NULL AS MONEY) <> CAST(123.45 AS MONEY) THEN 'Not Equal' ELSE 'Equal' END AS [NULL MONEY <> MONEY]; +GO +SELECT CASE WHEN CAST(NULL AS MONEY) > CAST(123.45 AS MONEY) THEN 'Greater' ELSE 'Not Greater' END AS [NULL MONEY > MONEY]; +GO +SELECT CASE WHEN CAST(NULL AS MONEY) < CAST(123.45 AS MONEY) THEN 'Less' ELSE 'Not Less' END AS [NULL MONEY < MONEY]; +GO +SELECT CASE WHEN CAST(NULL AS MONEY) IS NULL THEN 'Is NULL' ELSE 'Is Not NULL' END AS [MONEY IS NULL]; +GO +SELECT CASE WHEN CAST(NULL AS MONEY) IS NOT NULL THEN 'Is Not NULL' ELSE 'Is NULL' END AS [MONEY IS NOT NULL]; +GO + +-- SMALLMONEY NULL comparisons +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) = CAST(123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [NULL SMALLMONEY = SMALLMONEY]; +GO +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) <> CAST(123.45 AS SMALLMONEY) THEN 'Not Equal' ELSE 'Equal' END AS [NULL SMALLMONEY <> SMALLMONEY]; +GO +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) > CAST(123.45 AS SMALLMONEY) THEN 'Greater' ELSE 'Not Greater' END AS [NULL SMALLMONEY > SMALLMONEY]; +GO +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) < CAST(123.45 AS SMALLMONEY) THEN 'Less' ELSE 'Not Less' END AS [NULL SMALLMONEY < SMALLMONEY]; +GO +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) IS NULL THEN 'Is NULL' ELSE 'Is Not NULL' END AS [SMALLMONEY IS NULL]; +GO +SELECT CASE WHEN CAST(NULL AS SMALLMONEY) IS NOT NULL THEN 'Is Not NULL' ELSE 'Is NULL' END AS [SMALLMONEY IS NOT NULL]; +GO + +-- Edge cases and special values +-- Zero comparisons +SELECT CASE WHEN CAST(0 AS MONEY) = CAST(0.0000 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY Zero = Zero]; +GO +SELECT CASE WHEN CAST(0 AS MONEY) = CAST(-0.0000 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY Zero = Negative Zero]; +GO +SELECT CASE WHEN CAST(0 AS SMALLMONEY) = CAST(0.0000 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY Zero = Zero]; +GO +SELECT CASE WHEN CAST(0 AS SMALLMONEY) = CAST(-0.0000 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY Zero = Negative Zero]; +GO + +-- Maximum and minimum value comparisons +SELECT CASE WHEN CAST(922337203685477.5807 AS MONEY) > CAST(922337203685477.5806 AS MONEY) THEN 'True' ELSE 'False' END AS [MAX MONEY > NEAR MAX]; +GO +SELECT CASE WHEN CAST(-922337203685477.5808 AS MONEY) < CAST(-922337203685477.5807 AS MONEY) THEN 'True' ELSE 'False' END AS [MIN MONEY < NEAR MIN]; +GO +SELECT CASE WHEN CAST(214748.3647 AS SMALLMONEY) > CAST(214748.3646 AS SMALLMONEY) THEN 'True' ELSE 'False' END AS [MAX SMALLMONEY > NEAR MAX]; +GO +SELECT CASE WHEN CAST(-214748.3648 AS SMALLMONEY) < CAST(-214748.3647 AS SMALLMONEY) THEN 'True' ELSE 'False' END AS [MIN SMALLMONEY < NEAR MIN]; +GO + +-- Precision comparison tests +SELECT CASE WHEN CAST(123.4500 AS MONEY) = CAST(123.45 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [MONEY Precision Test]; +GO +SELECT CASE WHEN CAST(123.4500 AS SMALLMONEY) = CAST(123.45 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [SMALLMONEY Precision Test]; +GO + +-- Create test table +CREATE TABLE MoneyComparisonTest +( + ID INT PRIMARY KEY, + MoneyVal MONEY, + SmallMoneyVal SMALLMONEY, + MoneyNull MONEY NULL, + SmallMoneyNull SMALLMONEY NULL +); +GO + +-- Insert test data +INSERT INTO MoneyComparisonTest (ID, MoneyVal, SmallMoneyVal, MoneyNull, SmallMoneyNull) +VALUES +(1, 100.00, 100.00, NULL, NULL), +(2, 200.00, 200.00, 200.00, 200.00), +(3, -100.00, -100.00, -100.00, -100.00), +(4, 922337203685477.5807, 214748.3647, NULL, NULL), +(5, -922337203685477.5808, -214748.3648, NULL, NULL), +(6, 0.00, 0.00, 0.00, 0.00), +(7, 123.45, 123.45, 123.45, 123.45); +GO + +-- WHERE clause tests +-- Equality tests +SELECT ID, MoneyVal FROM MoneyComparisonTest WHERE MoneyVal = CAST(100.00 AS MONEY); +GO +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest WHERE SmallMoneyVal = CAST(100.00 AS SMALLMONEY); +GO + +-- Inequality tests +SELECT ID, MoneyVal FROM MoneyComparisonTest WHERE MoneyVal <> CAST(100.00 AS MONEY); +GO +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest WHERE SmallMoneyVal <> CAST(100.00 AS SMALLMONEY); +GO + +-- Greater than tests +SELECT ID, MoneyVal FROM MoneyComparisonTest WHERE MoneyVal > CAST(100.00 AS MONEY); +GO +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest WHERE SmallMoneyVal > CAST(100.00 AS SMALLMONEY); +GO + +-- Less than tests +SELECT ID, MoneyVal FROM MoneyComparisonTest WHERE MoneyVal < CAST(100.00 AS MONEY); +GO +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest WHERE SmallMoneyVal < CAST(100.00 AS SMALLMONEY); +GO + +-- BETWEEN tests +SELECT ID, MoneyVal FROM MoneyComparisonTest +WHERE MoneyVal BETWEEN CAST(100.00 AS MONEY) AND CAST(200.00 AS MONEY); +GO +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest +WHERE SmallMoneyVal BETWEEN CAST(100.00 AS SMALLMONEY) AND CAST(200.00 AS SMALLMONEY); +GO + +-- IN tests +SELECT ID, MoneyVal FROM MoneyComparisonTest +WHERE MoneyVal IN (CAST(100.00 AS MONEY), CAST(200.00 AS MONEY)); +GO +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest +WHERE SmallMoneyVal IN (CAST(100.00 AS SMALLMONEY), CAST(200.00 AS SMALLMONEY)); +GO + +-- NULL tests +SELECT ID, MoneyNull FROM MoneyComparisonTest WHERE MoneyNull IS NULL; +GO +SELECT ID, SmallMoneyNull FROM MoneyComparisonTest WHERE SmallMoneyNull IS NULL; +GO +SELECT ID, MoneyNull FROM MoneyComparisonTest WHERE MoneyNull IS NOT NULL; +GO +SELECT ID, SmallMoneyNull FROM MoneyComparisonTest WHERE SmallMoneyNull IS NOT NULL; +GO + +-- JOIN tests +-- Create second test table +CREATE TABLE MoneyComparisonTest2 +( + ID INT PRIMARY KEY, + MoneyVal MONEY, + SmallMoneyVal SMALLMONEY +); +GO + +-- Insert test data +INSERT INTO MoneyComparisonTest2 (ID, MoneyVal, SmallMoneyVal) +VALUES +(1, 100.00, 100.00), +(2, 200.00, 200.00), +(3, 300.00, 300.00); +GO + +-- INNER JOIN tests +SELECT t1.ID, t1.MoneyVal, t2.MoneyVal AS MoneyVal2 +FROM MoneyComparisonTest t1 +INNER JOIN MoneyComparisonTest2 t2 ON t1.MoneyVal = t2.MoneyVal; +GO + +SELECT t1.ID, t1.SmallMoneyVal, t2.SmallMoneyVal AS SmallMoneyVal2 +FROM MoneyComparisonTest t1 +INNER JOIN MoneyComparisonTest2 t2 ON t1.SmallMoneyVal = t2.SmallMoneyVal; +GO + +-- LEFT JOIN tests +SELECT t1.ID, t1.MoneyVal, t2.MoneyVal AS MoneyVal2 +FROM MoneyComparisonTest t1 +LEFT JOIN MoneyComparisonTest2 t2 ON t1.MoneyVal = t2.MoneyVal; +GO + +SELECT t1.ID, t1.SmallMoneyVal, t2.SmallMoneyVal AS SmallMoneyVal2 +FROM MoneyComparisonTest t1 +LEFT JOIN MoneyComparisonTest2 t2 ON t1.SmallMoneyVal = t2.SmallMoneyVal; +GO + +-- ORDER BY tests +-- Basic ORDER BY +SELECT ID, MoneyVal FROM MoneyComparisonTest ORDER BY MoneyVal; +GO +SELECT ID, MoneyVal FROM MoneyComparisonTest ORDER BY MoneyVal DESC; +GO +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest ORDER BY SmallMoneyVal; +GO +SELECT ID, SmallMoneyVal FROM MoneyComparisonTest ORDER BY SmallMoneyVal DESC; +GO + +-- Multiple column ORDER BY +SELECT ID, MoneyVal, SmallMoneyVal +FROM MoneyComparisonTest +ORDER BY MoneyVal, SmallMoneyVal; +GO + +SELECT ID, MoneyVal, SmallMoneyVal +FROM MoneyComparisonTest +ORDER BY MoneyVal DESC, SmallMoneyVal ASC; +GO + +-- ORDER BY with NULL values +SELECT ID, MoneyNull +FROM MoneyComparisonTest +ORDER BY MoneyNull; +GO + +SELECT ID, SmallMoneyNull +FROM MoneyComparisonTest +ORDER BY SmallMoneyNull DESC; +GO + +-- GROUP BY tests +-- Basic GROUP BY +SELECT MoneyVal, COUNT(*) as Count +FROM MoneyComparisonTest +GROUP BY MoneyVal; +GO + +SELECT SmallMoneyVal, COUNT(*) as Count +FROM MoneyComparisonTest +GROUP BY SmallMoneyVal; +GO + +-- GROUP BY with aggregates +SELECT + CASE + WHEN MoneyVal >= 0 THEN 'Positive' + ELSE 'Negative' + END AS ValueType, + COUNT(*) as Count, + MIN(MoneyVal) as MinValue, + MAX(MoneyVal) as MaxValue, + AVG(CAST(MoneyVal AS FLOAT)) as AvgValue +FROM MoneyComparisonTest +GROUP BY CASE + WHEN MoneyVal >= 0 THEN 'Positive' + ELSE 'Negative' +END +ORDER BY ValueType; +GO + +-- HAVING clause tests +SELECT MoneyVal, COUNT(*) as Count +FROM MoneyComparisonTest +GROUP BY MoneyVal +HAVING MoneyVal > 0; +GO + +SELECT SmallMoneyVal, COUNT(*) as Count +FROM MoneyComparisonTest +GROUP BY SmallMoneyVal +HAVING SmallMoneyVal < 0; +GO + +-- Complex comparison scenarios +-- Case expression comparisons +SELECT ID, + CASE + WHEN MoneyVal > 0 THEN 'Positive' + WHEN MoneyVal < 0 THEN 'Negative' + ELSE 'Zero' + END AS MoneyCategory, + CASE + WHEN SmallMoneyVal > 0 THEN 'Positive' + WHEN SmallMoneyVal < 0 THEN 'Negative' + ELSE 'Zero' + END AS SmallMoneyCategory +FROM MoneyComparisonTest; +GO + +-- Nested comparisons +SELECT ID, MoneyVal +FROM MoneyComparisonTest +WHERE MoneyVal > ( + SELECT AVG(CAST(MoneyVal AS FLOAT)) + FROM MoneyComparisonTest + WHERE MoneyVal > 0 +); +GO + +-- Multiple conditions +SELECT ID, MoneyVal, SmallMoneyVal +FROM MoneyComparisonTest +WHERE MoneyVal > 0 +AND SmallMoneyVal > 0 +AND MoneyVal = SmallMoneyVal; +GO + +-- Exists with comparison +SELECT ID, MoneyVal +FROM MoneyComparisonTest t1 +WHERE EXISTS ( + SELECT 1 + FROM MoneyComparisonTest2 t2 + WHERE t2.MoneyVal = t1.MoneyVal +); +GO + +-- Union with comparisons +SELECT ID, MoneyVal, 'MONEY' as Type +FROM MoneyComparisonTest +WHERE MoneyVal > 0 +UNION ALL +SELECT ID, SmallMoneyVal, 'SMALLMONEY' as Type +FROM MoneyComparisonTest +WHERE SmallMoneyVal > 0 +ORDER BY MoneyVal, ID, Type; +GO + +-- Intersection test +SELECT MoneyVal +FROM MoneyComparisonTest +WHERE MoneyVal > 0 +INTERSECT +SELECT MoneyVal +FROM MoneyComparisonTest2 +WHERE MoneyVal > 0; +GO + +-- Except test +SELECT MoneyVal +FROM MoneyComparisonTest +WHERE MoneyVal > 0 +EXCEPT +SELECT MoneyVal +FROM MoneyComparisonTest2 +WHERE MoneyVal > 0; +GO + +-- Additional complex scenarios +-- Subquery comparisons +SELECT ID, MoneyVal +FROM MoneyComparisonTest t1 +WHERE MoneyVal = ( + SELECT MAX(MoneyVal) + FROM MoneyComparisonTest + WHERE ID < t1.ID +); +GO + +-- Correlated subqueries +SELECT ID, MoneyVal +FROM MoneyComparisonTest t1 +WHERE MoneyVal > ( + SELECT AVG(CAST(t2.MoneyVal AS FLOAT)) + FROM MoneyComparisonTest t2 + WHERE t2.ID < t1.ID +); +GO + +-- Window functions with comparisons +SELECT + ID, + MoneyVal, + LAG(MoneyVal) OVER (ORDER BY ID) as PrevValue, + CASE + WHEN MoneyVal > LAG(MoneyVal) OVER (ORDER BY ID) THEN 'Increased' + WHEN MoneyVal < LAG(MoneyVal) OVER (ORDER BY ID) THEN 'Decreased' + WHEN MoneyVal = LAG(MoneyVal) OVER (ORDER BY ID) THEN 'No Change' + ELSE 'First Row' + END as ValueChange +FROM MoneyComparisonTest; +GO + +-- Running totals with comparisons +SELECT + ID, + MoneyVal, + SUM(MoneyVal) OVER (ORDER BY ID) as RunningTotal, + CASE + WHEN SUM(MoneyVal) OVER (ORDER BY ID) > 0 THEN 'Positive Balance' + ELSE 'Negative Balance' + END as BalanceStatus +FROM MoneyComparisonTest; +GO + +-- Pivot operations +-- Create sample data for pivot +CREATE TABLE MoneyPivotTest ( + ID INT, + Category VARCHAR(10), + Amount MONEY +); +GO + +INSERT INTO MoneyPivotTest (ID, Category, Amount) +VALUES +(1, 'A', 100.00), +(1, 'B', 200.00), +(2, 'A', 300.00), +(2, 'B', 400.00); +GO + +-- Pivot query +SELECT * +FROM ( + SELECT ID, Category, Amount + FROM MoneyPivotTest +) AS SourceTable +PIVOT ( + SUM(Amount) + FOR Category IN ([A], [B]) +) AS PivotTable; +GO + +-- Complex conditional aggregation +SELECT + CASE + WHEN MoneyVal BETWEEN -1000 AND 1000 THEN 'Normal Range' + WHEN MoneyVal > 1000 THEN 'High Range' + ELSE 'Low Range' + END AS ValueRange, + COUNT(*) AS Count, + MIN(MoneyVal) AS MinValue, + MAX(MoneyVal) AS MaxValue, + SUM(CASE WHEN MoneyVal > 0 THEN 1 ELSE 0 END) AS PositiveCount, + SUM(CASE WHEN MoneyVal < 0 THEN 1 ELSE 0 END) AS NegativeCount +FROM MoneyComparisonTest +GROUP BY + CASE + WHEN MoneyVal BETWEEN -1000 AND 1000 THEN 'Normal Range' + WHEN MoneyVal > 1000 THEN 'High Range' + ELSE 'Low Range' + END +ORDER BY ValueRange; +GO + +-- String formatting and comparison tests +SELECT + ID, + MoneyVal, + CAST(MoneyVal AS VARCHAR(20)) AS StringValue, + CASE + WHEN CAST(MoneyVal AS VARCHAR(20)) LIKE '%-%.%' THEN 'Negative Decimal' + WHEN CAST(MoneyVal AS VARCHAR(20)) LIKE '%.%' THEN 'Positive Decimal' + ELSE 'Whole Number' + END AS FormatType +FROM MoneyComparisonTest; +GO + +-- Rounding comparison tests +SELECT + ID, + MoneyVal, + ROUND(MoneyVal, 0) AS RoundedToInteger, + CASE + WHEN MoneyVal = ROUND(MoneyVal, 0) THEN 'Whole Number' + ELSE 'Decimal Number' + END AS NumberType +FROM MoneyComparisonTest; +GO + +-- Boundary value analysis +-- Test near-boundary values for MONEY +SELECT + CASE WHEN CAST(922337203685477.5807 AS MONEY) = CAST(922337203685477.5807 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [Max_Money_Equal], + CASE WHEN CAST(-922337203685477.5808 AS MONEY) = CAST(-922337203685477.5808 AS MONEY) THEN 'Equal' ELSE 'Not Equal' END AS [Min_Money_Equal]; +GO + +-- Test near-boundary values for SMALLMONEY +SELECT + CASE WHEN CAST(214748.3647 AS SMALLMONEY) = CAST(214748.3647 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [Max_SmallMoney_Equal], + CASE WHEN CAST(-214748.3648 AS SMALLMONEY) = CAST(-214748.3648 AS SMALLMONEY) THEN 'Equal' ELSE 'Not Equal' END AS [Min_SmallMoney_Equal]; +GO + +-- Cleanup +DROP TABLE MoneyComparisonTest; +DROP TABLE MoneyComparisonTest2; +DROP TABLE MoneyPivotTest; +GO + + +------------------------------------------------------------------------ +---- 6. Datatype Conversion +------------------------------------------------------------------------ +---- Conversion using CAST() + +-- BIT to Money types +SELECT 'BIT to Money Types Conversion' AS test_description; +GO + +-- BIT -> MONEY +SELECT CAST(0 AS MONEY) AS [BIT_0_TO_MONEY], CAST(1 AS MONEY) AS [BIT_1_TO_MONEY]; +GO + +-- BIT -> SMALLMONEY +SELECT CAST(0 AS SMALLMONEY) AS [BIT_0_TO_SMALLMONEY], CAST(1 AS SMALLMONEY) AS [BIT_1_TO_SMALLMONEY]; +GO + +-- Integer types to Money types +SELECT 'Integer Types to Money Types Conversion' AS test_description; +GO + +-- TINYINT -> MONEY +SELECT CAST(CAST(0 AS TINYINT) AS MONEY) AS [TINYINT_MIN_TO_MONEY], + CAST(CAST(255 AS TINYINT) AS MONEY) AS [TINYINT_MAX_TO_MONEY], + CAST(CAST(128 AS TINYINT) AS MONEY) AS [TINYINT_MID_TO_MONEY]; +GO + +-- TINYINT -> SMALLMONEY +SELECT CAST(CAST(0 AS TINYINT) AS SMALLMONEY) AS [TINYINT_MIN_TO_SMALLMONEY], + CAST(CAST(255 AS TINYINT) AS SMALLMONEY) AS [TINYINT_MAX_TO_SMALLMONEY], + CAST(CAST(128 AS TINYINT) AS SMALLMONEY) AS [TINYINT_MID_TO_SMALLMONEY]; +GO + +-- SMALLINT -> MONEY +SELECT CAST(CAST(-32768 AS SMALLINT) AS MONEY) AS [SMALLINT_MIN_TO_MONEY], + CAST(CAST(32767 AS SMALLINT) AS MONEY) AS [SMALLINT_MAX_TO_MONEY], + CAST(CAST(0 AS SMALLINT) AS MONEY) AS [SMALLINT_ZERO_TO_MONEY]; +GO + +-- SMALLINT -> SMALLMONEY +SELECT CAST(CAST(-32768 AS SMALLINT) AS SMALLMONEY) AS [SMALLINT_MIN_TO_SMALLMONEY], + CAST(CAST(32767 AS SMALLINT) AS SMALLMONEY) AS [SMALLINT_MAX_TO_SMALLMONEY], + CAST(CAST(0 AS SMALLINT) AS SMALLMONEY) AS [SMALLINT_ZERO_TO_SMALLMONEY]; +GO + +-- INT -> MONEY +SELECT CAST(CAST(-2147483648 AS INT) AS MONEY) AS [INT_MIN_TO_MONEY], + CAST(CAST(2147483647 AS INT) AS MONEY) AS [INT_MAX_TO_MONEY], + CAST(CAST(0 AS INT) AS MONEY) AS [INT_ZERO_TO_MONEY]; +GO + +-- INT -> SMALLMONEY +SELECT TRY_CAST(CAST(-2147483648 AS INT) AS SMALLMONEY) AS [INT_MIN_TO_SMALLMONEY], + TRY_CAST(CAST(2147483647 AS INT) AS SMALLMONEY) AS [INT_MAX_TO_SMALLMONEY], + CAST(CAST(0 AS INT) AS SMALLMONEY) AS [INT_ZERO_TO_SMALLMONEY]; +GO + +-- BIGINT -> MONEY +SELECT CAST(CAST(-9223372036854775808 AS BIGINT) AS MONEY) AS [BIGINT_MIN_TO_MONEY], + CAST(CAST(9223372036854775807 AS BIGINT) AS MONEY) AS [BIGINT_MAX_TO_MONEY], + CAST(CAST(0 AS BIGINT) AS MONEY) AS [BIGINT_ZERO_TO_MONEY]; +GO + +-- BIGINT -> SMALLMONEY +SELECT TRY_CAST(CAST(-9223372036854775808 AS BIGINT) AS SMALLMONEY) AS [BIGINT_MIN_TO_SMALLMONEY], + TRY_CAST(CAST(9223372036854775807 AS BIGINT) AS SMALLMONEY) AS [BIGINT_MAX_TO_SMALLMONEY], + CAST(CAST(0 AS BIGINT) AS SMALLMONEY) AS [BIGINT_ZERO_TO_SMALLMONEY]; +GO + +-- Floating point types to Money types +-- FLOAT -> MONEY +SELECT CAST(CAST(-1234.56789 AS FLOAT) AS MONEY) AS [FLOAT_NEG_TO_MONEY], + CAST(CAST(1234.56789 AS FLOAT) AS MONEY) AS [FLOAT_POS_TO_MONEY], + CAST(CAST(0.0 AS FLOAT) AS MONEY) AS [FLOAT_ZERO_TO_MONEY], + CAST(CAST(922337203685477.5807 AS FLOAT) AS MONEY) AS [FLOAT_MAX_TO_MONEY], + CAST(CAST(-922337203685477.5808 AS FLOAT) AS MONEY) AS [FLOAT_MIN_TO_MONEY]; +GO + +-- FLOAT -> SMALLMONEY +SELECT CAST(CAST(-214748.3648 AS FLOAT) AS SMALLMONEY) AS [FLOAT_NEG_TO_SMALLMONEY], + CAST(CAST(214748.3647 AS FLOAT) AS SMALLMONEY) AS [FLOAT_POS_TO_SMALLMONEY], + CAST(CAST(0.0 AS FLOAT) AS SMALLMONEY) AS [FLOAT_ZERO_TO_SMALLMONEY]; +GO + +-- String types to Money types +-- CHAR -> MONEY +SELECT CAST(CAST('123.45' AS CHAR(40)) AS MONEY) AS [CHAR_POS_TO_MONEY], + CAST(CAST('-123.45' AS CHAR(40)) AS MONEY) AS [CHAR_NEG_TO_MONEY], + CAST(CAST('0' AS CHAR(40)) AS MONEY) AS [CHAR_ZERO_TO_MONEY], + CAST(CAST('922337203685477.5807' AS CHAR(40)) AS MONEY) AS [CHAR_MAX_TO_MONEY], + CAST(CAST('-922337203685477.5808' AS CHAR(40)) AS MONEY) AS [CHAR_MIN_TO_MONEY]; +GO + +-- CHAR -> SMALLMONEY +SELECT CAST(CAST('214748.3647' AS CHAR(40)) AS SMALLMONEY) AS [CHAR_POS_TO_SMALLMONEY], + CAST(CAST('-214748.3648' AS CHAR(40)) AS SMALLMONEY) AS [CHAR_NEG_TO_SMALLMONEY], + CAST(CAST('0' AS CHAR(40)) AS SMALLMONEY) AS [CHAR_ZERO_TO_SMALLMONEY]; +GO + +-- VARCHAR -> MONEY +SELECT CAST(CAST('123.45' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_POS_TO_MONEY], + CAST(CAST('-123.45' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_NEG_TO_MONEY], + CAST(CAST('0' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_ZERO_TO_MONEY], + CAST(CAST('922337203685477.5807' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_MAX_TO_MONEY], + CAST(CAST('-922337203685477.5808' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_MIN_TO_MONEY], + CAST(CAST('$123.45' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_CURRENCY_TO_MONEY], + CAST(CAST('1,234.56' AS VARCHAR(40)) AS MONEY) AS [VARCHAR_COMMA_TO_MONEY]; +GO + +-- VARCHAR -> SMALLMONEY +SELECT CAST(CAST('214748.3647' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_POS_TO_SMALLMONEY], + CAST(CAST('-214748.3648' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_NEG_TO_SMALLMONEY], + CAST(CAST('0' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_ZERO_TO_SMALLMONEY], + CAST(CAST('$123.45' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_CURRENCY_TO_SMALLMONEY], + CAST(CAST('1,234.56' AS VARCHAR(40)) AS SMALLMONEY) AS [VARCHAR_COMMA_TO_SMALLMONEY]; +GO + +-- NCHAR -> MONEY +SELECT CAST(CAST(N'123.45' AS NCHAR(40)) AS MONEY) AS [NCHAR_POS_TO_MONEY], + CAST(CAST(N'-123.45' AS NCHAR(40)) AS MONEY) AS [NCHAR_NEG_TO_MONEY], + CAST(CAST(N'0' AS NCHAR(40)) AS MONEY) AS [NCHAR_ZERO_TO_MONEY], + CAST(CAST(N'922337203685477.5807' AS NCHAR(40)) AS MONEY) AS [NCHAR_MAX_TO_MONEY], + CAST(CAST(N'-922337203685477.5808' AS NCHAR(40)) AS MONEY) AS [NCHAR_MIN_TO_MONEY], + CAST(CAST(N'$123.45' AS NCHAR(40)) AS MONEY) AS [NCHAR_CURRENCY_TO_MONEY], + CAST(CAST(N'1,234.56' AS NCHAR(40)) AS MONEY) AS [NCHAR_COMMA_TO_MONEY]; +GO + +-- NCHAR -> SMALLMONEY +SELECT CAST(CAST(N'214748.3647' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_POS_TO_SMALLMONEY], + CAST(CAST(N'-214748.3648' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_NEG_TO_SMALLMONEY], + CAST(CAST(N'0' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_ZERO_TO_SMALLMONEY], + CAST(CAST(N'$123.45' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_CURRENCY_TO_SMALLMONEY], + CAST(CAST(N'1,234.56' AS NCHAR(40)) AS SMALLMONEY) AS [NCHAR_COMMA_TO_SMALLMONEY]; +GO + +-- NVARCHAR -> MONEY +SELECT CAST(CAST(N'123.45' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_POS_TO_MONEY], + CAST(CAST(N'-123.45' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_NEG_TO_MONEY], + CAST(CAST(N'0' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_ZERO_TO_MONEY], + CAST(CAST(N'922337203685477.5807' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_MAX_TO_MONEY], + CAST(CAST(N'-922337203685477.5808' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_MIN_TO_MONEY], + CAST(CAST(N'$123.45' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_CURRENCY_TO_MONEY], + CAST(CAST(N'1,234.56' AS NVARCHAR(40)) AS MONEY) AS [NVARCHAR_COMMA_TO_MONEY]; +GO + +-- NVARCHAR -> SMALLMONEY +SELECT CAST(CAST(N'214748.3647' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_POS_TO_SMALLMONEY], + CAST(CAST(N'-214748.3648' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_NEG_TO_SMALLMONEY], + CAST(CAST(N'0' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_ZERO_TO_SMALLMONEY], + CAST(CAST(N'$123.45' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_CURRENCY_TO_SMALLMONEY], + CAST(CAST(N'1,234.56' AS NVARCHAR(40)) AS SMALLMONEY) AS [NVARCHAR_COMMA_TO_SMALLMONEY]; +GO diff --git a/test/JDBC/input/money_smallmoney_arith_edge.sql b/test/JDBC/input/money_smallmoney_arith_edge.sql new file mode 100644 index 00000000000..f4081cfbe36 --- /dev/null +++ b/test/JDBC/input/money_smallmoney_arith_edge.sql @@ -0,0 +1,608 @@ +SELECT CAST(214748 AS INT) * CAST(0.5 AS SMALLMONEY); +GO + +SELECT CAST(214748 AS INT) / CAST(0.5 AS SMALLMONEY); +GO + +SELECT CAST(214748 AS INT) * CAST(-0.05 AS SMALLMONEY); +GO + +SELECT CAST(214748 AS INT) / CAST(-0.05 AS SMALLMONEY); +GO + +SELECT CAST(-214748 AS INT) * CAST(0.5 AS SMALLMONEY); +GO + +SELECT CAST(-214748 AS INT) / CAST(0.5 AS SMALLMONEY); +GO + +SELECT CAST(-214748 AS INT) * CAST(-0.05 AS SMALLMONEY); +GO + +SELECT CAST(-214748 AS INT) / CAST(-0.05 AS SMALLMONEY); +GO + +SELECT CAST(214749 AS INT) * CAST(0.5 AS SMALLMONEY); +GO + +SELECT CAST(214749 AS INT) / CAST(0.5 AS SMALLMONEY); +GO + +SELECT CAST(214749 AS INT) * CAST(-0.05 AS SMALLMONEY); +GO + +SELECT CAST(214749 AS INT) / CAST(-0.05 AS SMALLMONEY); +GO + +SELECT CAST(214747 AS INT) * CAST(0.5 AS SMALLMONEY); +GO + +SELECT CAST(214747 AS INT) / CAST(0.5 AS SMALLMONEY); +GO + +SELECT CAST(214747 AS INT) * CAST(-0.05 AS SMALLMONEY); +GO + +SELECT CAST(214747 AS INT) / CAST(-0.05 AS SMALLMONEY); +GO + +SELECT CAST(922337203685476 AS BIGINT) * CAST(0.05 AS MONEY); +GO + +SELECT CAST(922337203685476 AS BIGINT) / CAST(0.05 AS MONEY); +GO + +SELECT CAST(922337203685476 AS BIGINT) * CAST(-0.5 AS MONEY); +GO + +SELECT CAST(922337203685476 AS BIGINT) / CAST(-0.5 AS MONEY); +GO + +SELECT CAST(-922337203685476 AS BIGINT) * CAST(0.05 AS MONEY); +GO + +SELECT CAST(-922337203685476 AS BIGINT) / CAST(0.05 AS MONEY); +GO + +SELECT CAST(-922337203685476 AS BIGINT) * CAST(-0.5 AS MONEY); +GO + +SELECT CAST(-922337203685476 AS BIGINT) / CAST(-0.5 AS MONEY); +GO + +SELECT CAST(922337203685478 AS BIGINT) * CAST(0.05 AS MONEY); +GO + +SELECT CAST(922337203685478 AS BIGINT) / CAST(0.05 AS MONEY); +GO + +SELECT CAST(922337203685478 AS BIGINT) * CAST(-0.5 AS MONEY); +GO + +SELECT CAST(922337203685478 AS BIGINT) / CAST(-0.5 AS MONEY); +GO + +SELECT CAST(-922337203685478 AS BIGINT) * CAST(0.05 AS MONEY); +GO + +SELECT CAST(-922337203685478 AS BIGINT) / CAST(0.05 AS MONEY); +GO + +SELECT CAST(-922337203685478 AS BIGINT) * CAST(-0.5 AS MONEY); +GO + +SELECT CAST(-922337203685478 AS BIGINT) / CAST(-0.5 AS MONEY); +GO + +SELECT CAST(922337203685477 AS BIGINT) * CAST(0.05 AS MONEY); +GO + +SELECT CAST(922337203685477 AS BIGINT) / CAST(0.05 AS MONEY); +GO + +SELECT CAST(922337203685477 AS BIGINT) * CAST(-0.5 AS MONEY); +GO + +SELECT CAST(922337203685477 AS BIGINT) / CAST(-0.5 AS MONEY); +GO + +SELECT CAST(-922337203685477 AS BIGINT) * CAST(0.05 AS MONEY); +GO + +SELECT CAST(-922337203685477 AS BIGINT) / CAST(0.05 AS MONEY); +GO + +SELECT CAST(-922337203685477 AS BIGINT) * CAST(-0.5 AS MONEY); +GO + +SELECT CAST(-922337203685477 AS BIGINT) / CAST(-0.5 AS MONEY); +GO + +SELECT CAST(214748 AS INT) + CAST(-5 AS SMALLMONEY); +GO + +SELECT CAST(214748 AS INT) - CAST(-5 AS SMALLMONEY); +GO + +SELECT CAST(214748 AS INT) + CAST(-50 AS SMALLMONEY); +GO + +SELECT CAST(214748 AS INT) - CAST(-50 AS SMALLMONEY); +GO + +SELECT CAST(-214748 AS INT) + CAST(5 AS SMALLMONEY); +GO + +SELECT CAST(-214748 AS INT) - CAST(5 AS SMALLMONEY); +GO + +SELECT CAST(214749 AS INT) + CAST(5 AS SMALLMONEY); +GO + +SELECT CAST(214749 AS INT) - CAST(5 AS SMALLMONEY); +GO + +SELECT CAST(214749 AS INT) + CAST(-5 AS SMALLMONEY); +GO + +SELECT CAST(214749 AS INT) - CAST(-5 AS SMALLMONEY); +GO + +SELECT CAST(214749 AS INT) + CAST(50 AS SMALLMONEY); +GO + +SELECT CAST(214749 AS INT) - CAST(50 AS SMALLMONEY); +GO + +SELECT CAST(214749 AS INT) + CAST(-50 AS SMALLMONEY); +GO + +SELECT CAST(214749 AS INT) - CAST(-50 AS SMALLMONEY); +GO + +SELECT CAST(214747 AS INT) + CAST(5 AS SMALLMONEY); +GO + +SELECT CAST(214747 AS INT) - CAST(5 AS SMALLMONEY); +GO + +SELECT CAST(214747 AS INT) + CAST(-5 AS SMALLMONEY); +GO + +SELECT CAST(214747 AS INT) - CAST(-5 AS SMALLMONEY); +GO + +SELECT CAST(-214749 AS INT) + CAST(50 AS SMALLMONEY); +GO + +SELECT CAST(-214749 AS INT) - CAST(50 AS SMALLMONEY); +GO + +SELECT CAST(-214749 AS INT) + CAST(-50 AS SMALLMONEY); +GO + +SELECT CAST(-214749 AS INT) - CAST(-50 AS SMALLMONEY); +GO + +SELECT CAST(-214747 AS INT) + CAST(5 AS SMALLMONEY); +GO + +SELECT CAST(-214747 AS INT) - CAST(5 AS SMALLMONEY); +GO + +SELECT CAST(-214747 AS INT) + CAST(-5 AS SMALLMONEY); +GO + +SELECT CAST(-214747 AS INT) - CAST(-5 AS SMALLMONEY); +GO + +SELECT CAST(-214747 AS INT) + CAST(50 AS SMALLMONEY); +GO + +SELECT CAST(-214747 AS INT) - CAST(50 AS SMALLMONEY); +GO + +SELECT CAST(-214747 AS INT) + CAST(-50 AS SMALLMONEY); +GO + +SELECT CAST(-214747 AS INT) - CAST(-50 AS SMALLMONEY); +GO + +SELECT CAST(922337203685476 AS BIGINT) + CAST(5 AS MONEY); +GO + +SELECT CAST(922337203685476 AS BIGINT) - CAST(5 AS MONEY); +GO + +SELECT CAST(922337203685476 AS BIGINT) + CAST(-50 AS MONEY); +GO + +SELECT CAST(922337203685476 AS BIGINT) - CAST(-50 AS MONEY); +GO + +SELECT CAST(922337203685476 AS BIGINT) + CAST(50 AS MONEY); +GO + +SELECT CAST(922337203685476 AS BIGINT) - CAST(50 AS MONEY); +GO + +SELECT CAST(922337203685476 AS BIGINT) + CAST(-5 AS MONEY); +GO + +SELECT CAST(922337203685476 AS BIGINT) - CAST(-5 AS MONEY); +GO + +SELECT CAST(-922337203685476 AS BIGINT) + CAST(5 AS MONEY); +GO + +SELECT CAST(-922337203685476 AS BIGINT) - CAST(5 AS MONEY); +GO + +SELECT CAST(-922337203685476 AS BIGINT) + CAST(-50 AS MONEY); +GO + +SELECT CAST(-922337203685476 AS BIGINT) - CAST(-50 AS MONEY); +GO + +SELECT CAST(-922337203685476 AS BIGINT) + CAST(50 AS MONEY); +GO + +SELECT CAST(-922337203685476 AS BIGINT) - CAST(50 AS MONEY); +GO + +SELECT CAST(-922337203685476 AS BIGINT) + CAST(-5 AS MONEY); +GO + +SELECT CAST(-922337203685476 AS BIGINT) - CAST(-5 AS MONEY); +GO + +SELECT CAST(922337203685478 AS BIGINT) + CAST(5 AS MONEY); +GO + +SELECT CAST(922337203685478 AS BIGINT) - CAST(5 AS MONEY); +GO + +SELECT CAST(922337203685478 AS BIGINT) + CAST(-50 AS MONEY); +GO + +SELECT CAST(922337203685478 AS BIGINT) - CAST(-50 AS MONEY); +GO + +SELECT CAST(922337203685478 AS BIGINT) + CAST(50 AS MONEY); +GO + +SELECT CAST(922337203685478 AS BIGINT) - CAST(50 AS MONEY); +GO + +SELECT CAST(922337203685478 AS BIGINT) + CAST(-5 AS MONEY); +GO + +SELECT CAST(922337203685478 AS BIGINT) - CAST(-5 AS MONEY); +GO + +SELECT CAST(-922337203685478 AS BIGINT) + CAST(5 AS MONEY); +GO + +SELECT CAST(-922337203685478 AS BIGINT) - CAST(5 AS MONEY); +GO + +SELECT CAST(-922337203685478 AS BIGINT) + CAST(-50 AS MONEY); +GO + +SELECT CAST(-922337203685478 AS BIGINT) - CAST(-50 AS MONEY); +GO + +SELECT CAST(-922337203685478 AS BIGINT) + CAST(50 AS MONEY); +GO + +SELECT CAST(-922337203685478 AS BIGINT) - CAST(50 AS MONEY); +GO + +SELECT CAST(-922337203685478 AS BIGINT) + CAST(-5 AS MONEY); +GO + +SELECT CAST(-922337203685478 AS BIGINT) - CAST(-5 AS MONEY); +GO + +SELECT CAST(922337203685477 AS BIGINT) + CAST(5 AS MONEY); +GO + +SELECT CAST(922337203685477 AS BIGINT) - CAST(5 AS MONEY); +GO + +SELECT CAST(922337203685477 AS BIGINT) + CAST(-50 AS MONEY); +GO + +SELECT CAST(922337203685477 AS BIGINT) - CAST(-50 AS MONEY); +GO + +SELECT CAST(922337203685477 AS BIGINT) + CAST(50 AS MONEY); +GO + +SELECT CAST(922337203685477 AS BIGINT) - CAST(50 AS MONEY); +GO + +SELECT CAST(922337203685477 AS BIGINT) + CAST(-5 AS MONEY); +GO + +SELECT CAST(922337203685477 AS BIGINT) - CAST(-5 AS MONEY); +GO + +SELECT CAST(-922337203685477 AS BIGINT) + CAST(5 AS MONEY); +GO + +SELECT CAST(-922337203685477 AS BIGINT) - CAST(5 AS MONEY); +GO + +SELECT CAST(-922337203685477 AS BIGINT) + CAST(-50 AS MONEY); +GO + +SELECT CAST(-922337203685477 AS BIGINT) - CAST(-50 AS MONEY); +GO + +SELECT CAST(-922337203685477 AS BIGINT) + CAST(50 AS MONEY); +GO + +SELECT CAST(-922337203685477 AS BIGINT) - CAST(50 AS MONEY); +GO + +SELECT CAST(-922337203685477 AS BIGINT) + CAST(-5 AS MONEY); +GO + +SELECT CAST(-922337203685477 AS BIGINT) - CAST(-5 AS MONEY); +GO + +SELECT CAST(5 AS MONEY) - CAST(922337203685478 AS BIGINT); +GO + +SELECT CAST(5 AS MONEY) + CAST(-922337203685478 AS BIGINT); +GO + +SELECT CAST(5 AS MONEY) - CAST(-922337203685478 AS BIGINT); +GO + +SELECT CAST(5 AS MONEY) + CAST(922337203685477 AS BIGINT); +GO + +SELECT CAST(5 AS MONEY) - CAST(922337203685477 AS BIGINT); +GO + +SELECT CAST(5 AS MONEY) + CAST(-922337203685477 AS BIGINT); +GO + +SELECT CAST(5 AS MONEY) - CAST(-922337203685477 AS BIGINT); +GO + +SELECT CAST(-50 AS MONEY) + CAST(922337203685476 AS BIGINT); +GO + +SELECT CAST(-50 AS MONEY) - CAST(922337203685476 AS BIGINT); +GO + +SELECT CAST(-50 AS MONEY) + CAST(-922337203685476 AS BIGINT); +GO + +SELECT CAST(-50 AS MONEY) - CAST(-922337203685476 AS BIGINT); +GO + +SELECT CAST(-50 AS MONEY) + CAST(922337203685478 AS BIGINT); +GO + +SELECT CAST(-50 AS MONEY) - CAST(922337203685478 AS BIGINT); +GO + +SELECT CAST(-50 AS MONEY) + CAST(-922337203685478 AS BIGINT); +GO + +SELECT CAST(-50 AS MONEY) - CAST(-922337203685478 AS BIGINT); +GO + +SELECT CAST(-50 AS MONEY) + CAST(922337203685477 AS BIGINT); +GO + +SELECT CAST(-50 AS MONEY) - CAST(922337203685477 AS BIGINT); +GO + +SELECT CAST(-50 AS MONEY) + CAST(-922337203685477 AS BIGINT); +GO + +SELECT CAST(-50 AS MONEY) - CAST(-922337203685477 AS BIGINT); +GO + +SELECT CAST(50 AS MONEY) + CAST(922337203685476 AS BIGINT); +GO + +SELECT CAST(50 AS MONEY) - CAST(922337203685476 AS BIGINT); +GO + +SELECT CAST(50 AS MONEY) + CAST(-922337203685476 AS BIGINT); +GO + +SELECT CAST(50 AS MONEY) - CAST(922337203685477 AS BIGINT); +GO + +SELECT CAST(50 AS MONEY) + CAST(-922337203685477 AS BIGINT); +GO + +SELECT CAST(50 AS MONEY) - CAST(-922337203685477 AS BIGINT); +GO + +SELECT CAST(-5 AS MONEY) + CAST(922337203685476 AS BIGINT); +GO + +SELECT CAST(-5 AS MONEY) - CAST(922337203685476 AS BIGINT); +GO + +SELECT CAST(-5 AS MONEY) + CAST(-922337203685476 AS BIGINT); +GO + +SELECT CAST(-5 AS MONEY) - CAST(-922337203685476 AS BIGINT); +GO + +SELECT CAST(-5 AS MONEY) + CAST(922337203685478 AS BIGINT); +GO + +SELECT CAST(-5 AS MONEY) - CAST(922337203685478 AS BIGINT); +GO + +SELECT CAST(-5 AS MONEY) + CAST(-922337203685478 AS BIGINT); +GO + +SELECT CAST(-5 AS MONEY) - CAST(-922337203685478 AS BIGINT); +GO + +SELECT CAST(-5 AS MONEY) + CAST(922337203685477 AS BIGINT); +GO + +SELECT CAST(-5 AS MONEY) - CAST(922337203685477 AS BIGINT); +GO + +SELECT CAST(-5 AS MONEY) + CAST(-922337203685477 AS BIGINT); +GO + +SELECT CAST(-5 AS MONEY) - CAST(-922337203685477 AS BIGINT); +GO + +SELECT CAST(5 AS SMALLMONEY) + CAST(214748 AS INT); +GO + +SELECT CAST(5 AS SMALLMONEY) - CAST(214748 AS INT); +GO + +SELECT CAST(5 AS SMALLMONEY) + CAST(-214748 AS INT); +GO + +SELECT CAST(5 AS SMALLMONEY) - CAST(-214748 AS INT); +GO + +SELECT CAST(5 AS SMALLMONEY) + CAST(214749 AS INT); +GO + +SELECT CAST(5 AS SMALLMONEY) - CAST(214749 AS INT); +GO + +SELECT CAST(5 AS SMALLMONEY) + CAST(214747 AS INT); +GO + +SELECT CAST(5 AS SMALLMONEY) - CAST(214747 AS INT); +GO + +SELECT CAST(5 AS SMALLMONEY) + CAST(-214749 AS INT); +GO + +SELECT CAST(5 AS SMALLMONEY) - CAST(-214749 AS INT); +GO + +SELECT CAST(5 AS SMALLMONEY) + CAST(-214747 AS INT); +GO + +SELECT CAST(5 AS SMALLMONEY) - CAST(-214747 AS INT); +GO + +SELECT CAST(-5 AS SMALLMONEY) + CAST(214748 AS INT); +GO + +SELECT CAST(-5 AS SMALLMONEY) - CAST(214748 AS INT); +GO + +SELECT CAST(-5 AS SMALLMONEY) + CAST(-214748 AS INT); +GO + +SELECT CAST(-5 AS SMALLMONEY) - CAST(-214748 AS INT); +GO + +SELECT CAST(-5 AS SMALLMONEY) + CAST(214749 AS INT); +GO + +SELECT CAST(-5 AS SMALLMONEY) - CAST(214749 AS INT); +GO + +SELECT CAST(-5 AS SMALLMONEY) + CAST(214747 AS INT); +GO + +SELECT CAST(-5 AS SMALLMONEY) - CAST(214747 AS INT); +GO + +SELECT CAST(-5 AS SMALLMONEY) + CAST(-214749 AS INT); +GO + +SELECT CAST(-5 AS SMALLMONEY) - CAST(-214749 AS INT); +GO + +SELECT CAST(-5 AS SMALLMONEY) + CAST(-214747 AS INT); +GO + +SELECT CAST(-5 AS SMALLMONEY) - CAST(-214747 AS INT); +GO + +SELECT CAST(50 AS SMALLMONEY) + CAST(214748 AS INT); +GO + +SELECT CAST(50 AS SMALLMONEY) - CAST(214748 AS INT); +GO + +SELECT CAST(50 AS SMALLMONEY) + CAST(-214748 AS INT); +GO + +SELECT CAST(50 AS SMALLMONEY) - CAST(-214748 AS INT); +GO + +SELECT CAST(50 AS SMALLMONEY) + CAST(214749 AS INT); +GO + +SELECT CAST(50 AS SMALLMONEY) - CAST(214749 AS INT); +GO + +SELECT CAST(50 AS SMALLMONEY) + CAST(214747 AS INT); +GO + +SELECT CAST(50 AS SMALLMONEY) - CAST(214747 AS INT); +GO + +SELECT CAST(50 AS SMALLMONEY) + CAST(-214749 AS INT); +GO + +SELECT CAST(50 AS SMALLMONEY) - CAST(-214749 AS INT); +GO + +SELECT CAST(50 AS SMALLMONEY) + CAST(-214747 AS INT); +GO + +SELECT CAST(50 AS SMALLMONEY) - CAST(-214747 AS INT); +GO + +SELECT CAST(-50 AS SMALLMONEY) + CAST(214748 AS INT); +GO + +SELECT CAST(-50 AS SMALLMONEY) - CAST(214748 AS INT); +GO + +SELECT CAST(-50 AS SMALLMONEY) + CAST(-214748 AS INT); +GO + +SELECT CAST(-50 AS SMALLMONEY) - CAST(-214748 AS INT); +GO + +SELECT CAST(-50 AS SMALLMONEY) + CAST(214749 AS INT); +GO + +SELECT CAST(-50 AS SMALLMONEY) - CAST(214749 AS INT); +GO + +SELECT CAST(-50 AS SMALLMONEY) + CAST(214747 AS INT); +GO + +SELECT CAST(-50 AS SMALLMONEY) - CAST(214747 AS INT); +GO + +SELECT CAST(-50 AS SMALLMONEY) + CAST(-214749 AS INT); +GO + +SELECT CAST(-50 AS SMALLMONEY) - CAST(-214749 AS INT); +GO + +SELECT CAST(-50 AS SMALLMONEY) + CAST(-214747 AS INT); +GO + +SELECT CAST(-50 AS SMALLMONEY) - CAST(-214747 AS INT); +GO \ No newline at end of file diff --git a/test/JDBC/upgrade/latest/schedule b/test/JDBC/upgrade/latest/schedule index 233c270ccc2..3a980d6a053 100644 --- a/test/JDBC/upgrade/latest/schedule +++ b/test/JDBC/upgrade/latest/schedule @@ -626,5 +626,7 @@ babel_test_numeric_int4_oper babel_test_numeric_int8_oper numeric_money MONEY_OBJECT +money_smallmoney +bit_arith user_token-dep Test_cast_binary_bytea diff --git a/test/python/expected/upgrade_validation/expected_dependency.out b/test/python/expected/upgrade_validation/expected_dependency.out index 73b97a89f4b..6cbe2f8b971 100644 --- a/test/python/expected/upgrade_validation/expected_dependency.out +++ b/test/python/expected/upgrade_validation/expected_dependency.out @@ -241,8 +241,6 @@ Function sys.binaryint8(sys.bbf_binary) Function sys.binaryrowversion(sys.bbf_binary,integer,boolean) Function sys.bit2fixeddec(sys."bit") Function sys.bit2int4(sys."bit") -Function sys.bit2int8(sys."bit") -Function sys.bit2numeric(sys."bit") Function sys.bit_cmp(sys."bit",sys."bit") Function sys.bit_sqlvariant(sys."bit") Function sys.bit_unsupported_avg(sys."bit",sys."bit") @@ -798,12 +796,9 @@ Operator sys.*(sys.smallmoney,bigint) Operator sys.*(sys.smallmoney,integer) Operator sys.*(sys.smallmoney,smallint) Operator sys.*(sys.smallmoney,sys.tinyint) -Operator sys.*(sys.tinyint,sys.smallmoney) Operator sys.*(sys.tinyint,sys.tinyint) Operator sys.+(bigint,sys.fixeddecimal) -Operator sys.+(bigint,sys.smallmoney) Operator sys.+(integer,sys.fixeddecimal) -Operator sys.+(integer,sys.smallmoney) Operator sys.+(interval,sys.datetimeoffset) Operator sys.+(smallint,sys.fixeddecimal) Operator sys.+(smallint,sys.smallmoney) @@ -815,12 +810,8 @@ Operator sys.+(sys.fixeddecimal,bigint) Operator sys.+(sys.fixeddecimal,integer) Operator sys.+(sys.fixeddecimal,smallint) Operator sys.+(sys.fixeddecimal,sys.fixeddecimal) -Operator sys.+(sys.smallmoney,bigint) -Operator sys.+(sys.smallmoney,integer) Operator sys.+(sys.smallmoney,smallint) Operator sys.+(sys.smallmoney,sys.smallmoney) -Operator sys.+(sys.smallmoney,sys.tinyint) -Operator sys.+(sys.tinyint,sys.smallmoney) Operator sys.+(sys.tinyint,sys.tinyint) Operator sys.-(NONE,sys."bit") Operator sys.-(NONE,sys.fixeddecimal)