From 9db68d010ec87f994b073562deac840d82762de6 Mon Sep 17 00:00:00 2001 From: Yuming Wang Date: Thu, 20 Jun 2019 22:36:52 +0800 Subject: [PATCH 1/6] Add float8.sql --- .../sql-tests/inputs/pgSQL/float8.sql | 469 ++++++++++++++++++ 1 file changed, 469 insertions(+) create mode 100644 sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql diff --git a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql new file mode 100644 index 0000000000000..98eeff2837b40 --- /dev/null +++ b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql @@ -0,0 +1,469 @@ +-- +-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group +-- +-- +-- FLOAT8 +-- https://github.com/postgres/postgres/blob/REL_12_BETA1/src/test/regress/sql/float8.sql + +CREATE TABLE FLOAT8_TBL(f1 float8); + +INSERT INTO FLOAT8_TBL(f1) VALUES (' 0.0 '); +INSERT INTO FLOAT8_TBL(f1) VALUES ('1004.30 '); +INSERT INTO FLOAT8_TBL(f1) VALUES (' -34.84'); +INSERT INTO FLOAT8_TBL(f1) VALUES ('1.2345678901234e+200'); +INSERT INTO FLOAT8_TBL(f1) VALUES ('1.2345678901234e-200'); + +-- test for underflow and overflow handling +SELECT '10e400'::float8; +SELECT '-10e400'::float8; +SELECT '10e-400'::float8; +SELECT '-10e-400'::float8; + +-- test smallest normalized input +SELECT float8send('2.2250738585072014E-308'::float8); + +-- bad input +INSERT INTO FLOAT8_TBL(f1) VALUES (''); +INSERT INTO FLOAT8_TBL(f1) VALUES (' '); +INSERT INTO FLOAT8_TBL(f1) VALUES ('xyz'); +INSERT INTO FLOAT8_TBL(f1) VALUES ('5.0.0'); +INSERT INTO FLOAT8_TBL(f1) VALUES ('5 . 0'); +INSERT INTO FLOAT8_TBL(f1) VALUES ('5. 0'); +INSERT INTO FLOAT8_TBL(f1) VALUES (' - 3'); +INSERT INTO FLOAT8_TBL(f1) VALUES ('123 5'); + +-- special inputs +SELECT 'NaN'::float8; +SELECT 'nan'::float8; +SELECT ' NAN '::float8; +SELECT 'infinity'::float8; +SELECT ' -INFINiTY '::float8; +-- bad special inputs +SELECT 'N A N'::float8; +SELECT 'NaN x'::float8; +SELECT ' INFINITY x'::float8; + +SELECT 'Infinity'::float8 + 100.0; +SELECT 'Infinity'::float8 / 'Infinity'::float8; +SELECT 'nan'::float8 / 'nan'::float8; +SELECT 'nan'::numeric::float8; + +SELECT '' AS five, * FROM FLOAT8_TBL; + +SELECT '' AS four, f.* FROM FLOAT8_TBL f WHERE f.f1 <> '1004.3'; + +SELECT '' AS one, f.* FROM FLOAT8_TBL f WHERE f.f1 = '1004.3'; + +SELECT '' AS three, f.* FROM FLOAT8_TBL f WHERE '1004.3' > f.f1; + +SELECT '' AS three, f.* FROM FLOAT8_TBL f WHERE f.f1 < '1004.3'; + +SELECT '' AS four, f.* FROM FLOAT8_TBL f WHERE '1004.3' >= f.f1; + +SELECT '' AS four, f.* FROM FLOAT8_TBL f WHERE f.f1 <= '1004.3'; + +SELECT '' AS three, f.f1, f.f1 * '-10' AS x + FROM FLOAT8_TBL f + WHERE f.f1 > '0.0'; + +SELECT '' AS three, f.f1, f.f1 + '-10' AS x + FROM FLOAT8_TBL f + WHERE f.f1 > '0.0'; + +SELECT '' AS three, f.f1, f.f1 / '-10' AS x + FROM FLOAT8_TBL f + WHERE f.f1 > '0.0'; + +SELECT '' AS three, f.f1, f.f1 - '-10' AS x + FROM FLOAT8_TBL f + WHERE f.f1 > '0.0'; + +SELECT '' AS one, f.f1 ^ '2.0' AS square_f1 + FROM FLOAT8_TBL f where f.f1 = '1004.3'; + +-- absolute value +SELECT '' AS five, f.f1, @f.f1 AS abs_f1 + FROM FLOAT8_TBL f; + +-- truncate +SELECT '' AS five, f.f1, trunc(f.f1) AS trunc_f1 + FROM FLOAT8_TBL f; + +-- round +SELECT '' AS five, f.f1, round(f.f1) AS round_f1 + FROM FLOAT8_TBL f; + +-- ceil / ceiling +select ceil(f1) as ceil_f1 from float8_tbl f; +select ceiling(f1) as ceiling_f1 from float8_tbl f; + +-- floor +select floor(f1) as floor_f1 from float8_tbl f; + +-- sign +select sign(f1) as sign_f1 from float8_tbl f; + +-- avoid bit-exact output here because operations may not be bit-exact. +SET extra_float_digits = 0; + +-- square root +SELECT sqrt(float8 '64') AS eight; + +SELECT |/ float8 '64' AS eight; + +SELECT '' AS three, f.f1, |/f.f1 AS sqrt_f1 + FROM FLOAT8_TBL f + WHERE f.f1 > '0.0'; + +-- power +SELECT power(float8 '144', float8 '0.5'); +SELECT power(float8 'NaN', float8 '0.5'); +SELECT power(float8 '144', float8 'NaN'); +SELECT power(float8 'NaN', float8 'NaN'); +SELECT power(float8 '-1', float8 'NaN'); +SELECT power(float8 '1', float8 'NaN'); +SELECT power(float8 'NaN', float8 '0'); + +-- take exp of ln(f.f1) +SELECT '' AS three, f.f1, exp(ln(f.f1)) AS exp_ln_f1 + FROM FLOAT8_TBL f + WHERE f.f1 > '0.0'; + +-- cube root +SELECT ||/ float8 '27' AS three; + +SELECT '' AS five, f.f1, ||/f.f1 AS cbrt_f1 FROM FLOAT8_TBL f; + + +SELECT '' AS five, * FROM FLOAT8_TBL; + +UPDATE FLOAT8_TBL + SET f1 = FLOAT8_TBL.f1 * '-1' + WHERE FLOAT8_TBL.f1 > '0.0'; + +SELECT '' AS bad, f.f1 * '1e200' from FLOAT8_TBL f; + +SELECT '' AS bad, f.f1 ^ '1e200' from FLOAT8_TBL f; + +SELECT 0 ^ 0 + 0 ^ 1 + 0 ^ 0.0 + 0 ^ 0.5; + +SELECT '' AS bad, ln(f.f1) from FLOAT8_TBL f where f.f1 = '0.0' ; + +SELECT '' AS bad, ln(f.f1) from FLOAT8_TBL f where f.f1 < '0.0' ; + +SELECT '' AS bad, exp(f.f1) from FLOAT8_TBL f; + +SELECT '' AS bad, f.f1 / '0.0' from FLOAT8_TBL f; + +SELECT '' AS five, * FROM FLOAT8_TBL; + +-- hyperbolic functions +-- we run these with extra_float_digits = 0 too, since different platforms +-- tend to produce results that vary in the last place. +SELECT sinh(float8 '1'); +SELECT cosh(float8 '1'); +SELECT tanh(float8 '1'); +SELECT asinh(float8 '1'); +SELECT acosh(float8 '2'); +SELECT atanh(float8 '0.5'); +-- test Inf/NaN cases for hyperbolic functions +SELECT sinh(float8 'infinity'); +SELECT sinh(float8 '-infinity'); +SELECT sinh(float8 'nan'); +SELECT cosh(float8 'infinity'); +SELECT cosh(float8 '-infinity'); +SELECT cosh(float8 'nan'); +SELECT tanh(float8 'infinity'); +SELECT tanh(float8 '-infinity'); +SELECT tanh(float8 'nan'); +SELECT asinh(float8 'infinity'); +SELECT asinh(float8 '-infinity'); +SELECT asinh(float8 'nan'); +-- acosh(Inf) should be Inf, but some mingw versions produce NaN, so skip test +-- SELECT acosh(float8 'infinity'); +SELECT acosh(float8 '-infinity'); +SELECT acosh(float8 'nan'); +SELECT atanh(float8 'infinity'); +SELECT atanh(float8 '-infinity'); +SELECT atanh(float8 'nan'); + +RESET extra_float_digits; + +-- test for over- and underflow +INSERT INTO FLOAT8_TBL(f1) VALUES ('10e400'); + +INSERT INTO FLOAT8_TBL(f1) VALUES ('-10e400'); + +INSERT INTO FLOAT8_TBL(f1) VALUES ('10e-400'); + +INSERT INTO FLOAT8_TBL(f1) VALUES ('-10e-400'); + +-- maintain external table consistency across platforms +-- delete all values and reinsert well-behaved ones + +DELETE FROM FLOAT8_TBL; + +INSERT INTO FLOAT8_TBL(f1) VALUES ('0.0'); + +INSERT INTO FLOAT8_TBL(f1) VALUES ('-34.84'); + +INSERT INTO FLOAT8_TBL(f1) VALUES ('-1004.30'); + +INSERT INTO FLOAT8_TBL(f1) VALUES ('-1.2345678901234e+200'); + +INSERT INTO FLOAT8_TBL(f1) VALUES ('-1.2345678901234e-200'); + +SELECT '' AS five, * FROM FLOAT8_TBL; + +-- test edge-case coercions to integer +SELECT '32767.4'::float8::int2; +SELECT '32767.6'::float8::int2; +SELECT '-32768.4'::float8::int2; +SELECT '-32768.6'::float8::int2; +SELECT '2147483647.4'::float8::int4; +SELECT '2147483647.6'::float8::int4; +SELECT '-2147483648.4'::float8::int4; +SELECT '-2147483648.6'::float8::int4; +SELECT '9223372036854773760'::float8::int8; +SELECT '9223372036854775807'::float8::int8; +SELECT '-9223372036854775808.5'::float8::int8; +SELECT '-9223372036854780000'::float8::int8; + +-- test exact cases for trigonometric functions in degrees + +SELECT x, + sind(x), + sind(x) IN (-1,-0.5,0,0.5,1) AS sind_exact +FROM (VALUES (0), (30), (90), (150), (180), + (210), (270), (330), (360)) AS t(x); + +SELECT x, + cosd(x), + cosd(x) IN (-1,-0.5,0,0.5,1) AS cosd_exact +FROM (VALUES (0), (60), (90), (120), (180), + (240), (270), (300), (360)) AS t(x); + +SELECT x, + tand(x), + tand(x) IN ('-Infinity'::float8,-1,0, + 1,'Infinity'::float8) AS tand_exact, + cotd(x), + cotd(x) IN ('-Infinity'::float8,-1,0, + 1,'Infinity'::float8) AS cotd_exact +FROM (VALUES (0), (45), (90), (135), (180), + (225), (270), (315), (360)) AS t(x); + +SELECT x, + asind(x), + asind(x) IN (-90,-30,0,30,90) AS asind_exact, + acosd(x), + acosd(x) IN (0,60,90,120,180) AS acosd_exact +FROM (VALUES (-1), (-0.5), (0), (0.5), (1)) AS t(x); + +SELECT x, + atand(x), + atand(x) IN (-90,-45,0,45,90) AS atand_exact +FROM (VALUES ('-Infinity'::float8), (-1), (0), (1), + ('Infinity'::float8)) AS t(x); + +SELECT x, y, + atan2d(y, x), + atan2d(y, x) IN (-90,0,90,180) AS atan2d_exact +FROM (SELECT 10*cosd(a), 10*sind(a) + FROM generate_series(0, 360, 90) AS t(a)) AS t(x,y); + +-- +-- test output (and round-trip safety) of various values. +-- To ensure we're testing what we think we're testing, start with +-- float values specified by bit patterns (as a useful side effect, +-- this means we'll fail on non-IEEE platforms). + +create type xfloat8; +create function xfloat8in(cstring) returns xfloat8 immutable strict + language internal as 'int8in'; +create function xfloat8out(xfloat8) returns cstring immutable strict + language internal as 'int8out'; +create type xfloat8 (input = xfloat8in, output = xfloat8out, like = float8); +create cast (xfloat8 as float8) without function; +create cast (float8 as xfloat8) without function; +create cast (xfloat8 as bigint) without function; +create cast (bigint as xfloat8) without function; + +-- float8: seeeeeee eeeeeeee eeeeeeee mmmmmmmm mmmmmmmm(x4) + +-- we don't care to assume the platform's strtod() handles subnormals +-- correctly; those are "use at your own risk". However we do test +-- subnormal outputs, since those are under our control. + +with testdata(bits) as (values + -- small subnormals + (x'0000000000000001'), + (x'0000000000000002'), (x'0000000000000003'), + (x'0000000000001000'), (x'0000000100000000'), + (x'0000010000000000'), (x'0000010100000000'), + (x'0000400000000000'), (x'0000400100000000'), + (x'0000800000000000'), (x'0000800000000001'), + -- these values taken from upstream testsuite + (x'00000000000f4240'), + (x'00000000016e3600'), + (x'0000008cdcdea440'), + -- borderline between subnormal and normal + (x'000ffffffffffff0'), (x'000ffffffffffff1'), + (x'000ffffffffffffe'), (x'000fffffffffffff')) +select float8send(flt) as ibits, + flt + from (select bits::bigint::xfloat8::float8 as flt + from testdata + offset 0) s; + +-- round-trip tests + +with testdata(bits) as (values + (x'0000000000000000'), + -- smallest normal values + (x'0010000000000000'), (x'0010000000000001'), + (x'0010000000000002'), (x'0018000000000000'), + -- + (x'3ddb7cdfd9d7bdba'), (x'3ddb7cdfd9d7bdbb'), (x'3ddb7cdfd9d7bdbc'), + (x'3e112e0be826d694'), (x'3e112e0be826d695'), (x'3e112e0be826d696'), + (x'3e45798ee2308c39'), (x'3e45798ee2308c3a'), (x'3e45798ee2308c3b'), + (x'3e7ad7f29abcaf47'), (x'3e7ad7f29abcaf48'), (x'3e7ad7f29abcaf49'), + (x'3eb0c6f7a0b5ed8c'), (x'3eb0c6f7a0b5ed8d'), (x'3eb0c6f7a0b5ed8e'), + (x'3ee4f8b588e368ef'), (x'3ee4f8b588e368f0'), (x'3ee4f8b588e368f1'), + (x'3f1a36e2eb1c432c'), (x'3f1a36e2eb1c432d'), (x'3f1a36e2eb1c432e'), + (x'3f50624dd2f1a9fb'), (x'3f50624dd2f1a9fc'), (x'3f50624dd2f1a9fd'), + (x'3f847ae147ae147a'), (x'3f847ae147ae147b'), (x'3f847ae147ae147c'), + (x'3fb9999999999999'), (x'3fb999999999999a'), (x'3fb999999999999b'), + -- values very close to 1 + (x'3feffffffffffff0'), (x'3feffffffffffff1'), (x'3feffffffffffff2'), + (x'3feffffffffffff3'), (x'3feffffffffffff4'), (x'3feffffffffffff5'), + (x'3feffffffffffff6'), (x'3feffffffffffff7'), (x'3feffffffffffff8'), + (x'3feffffffffffff9'), (x'3feffffffffffffa'), (x'3feffffffffffffb'), + (x'3feffffffffffffc'), (x'3feffffffffffffd'), (x'3feffffffffffffe'), + (x'3fefffffffffffff'), + (x'3ff0000000000000'), + (x'3ff0000000000001'), (x'3ff0000000000002'), (x'3ff0000000000003'), + (x'3ff0000000000004'), (x'3ff0000000000005'), (x'3ff0000000000006'), + (x'3ff0000000000007'), (x'3ff0000000000008'), (x'3ff0000000000009'), + -- + (x'3ff921fb54442d18'), + (x'4005bf0a8b14576a'), + (x'400921fb54442d18'), + -- + (x'4023ffffffffffff'), (x'4024000000000000'), (x'4024000000000001'), + (x'4058ffffffffffff'), (x'4059000000000000'), (x'4059000000000001'), + (x'408f3fffffffffff'), (x'408f400000000000'), (x'408f400000000001'), + (x'40c387ffffffffff'), (x'40c3880000000000'), (x'40c3880000000001'), + (x'40f869ffffffffff'), (x'40f86a0000000000'), (x'40f86a0000000001'), + (x'412e847fffffffff'), (x'412e848000000000'), (x'412e848000000001'), + (x'416312cfffffffff'), (x'416312d000000000'), (x'416312d000000001'), + (x'4197d783ffffffff'), (x'4197d78400000000'), (x'4197d78400000001'), + (x'41cdcd64ffffffff'), (x'41cdcd6500000000'), (x'41cdcd6500000001'), + (x'4202a05f1fffffff'), (x'4202a05f20000000'), (x'4202a05f20000001'), + (x'42374876e7ffffff'), (x'42374876e8000000'), (x'42374876e8000001'), + (x'426d1a94a1ffffff'), (x'426d1a94a2000000'), (x'426d1a94a2000001'), + (x'42a2309ce53fffff'), (x'42a2309ce5400000'), (x'42a2309ce5400001'), + (x'42d6bcc41e8fffff'), (x'42d6bcc41e900000'), (x'42d6bcc41e900001'), + (x'430c6bf52633ffff'), (x'430c6bf526340000'), (x'430c6bf526340001'), + (x'4341c37937e07fff'), (x'4341c37937e08000'), (x'4341c37937e08001'), + (x'4376345785d89fff'), (x'4376345785d8a000'), (x'4376345785d8a001'), + (x'43abc16d674ec7ff'), (x'43abc16d674ec800'), (x'43abc16d674ec801'), + (x'43e158e460913cff'), (x'43e158e460913d00'), (x'43e158e460913d01'), + (x'4415af1d78b58c3f'), (x'4415af1d78b58c40'), (x'4415af1d78b58c41'), + (x'444b1ae4d6e2ef4f'), (x'444b1ae4d6e2ef50'), (x'444b1ae4d6e2ef51'), + (x'4480f0cf064dd591'), (x'4480f0cf064dd592'), (x'4480f0cf064dd593'), + (x'44b52d02c7e14af5'), (x'44b52d02c7e14af6'), (x'44b52d02c7e14af7'), + (x'44ea784379d99db3'), (x'44ea784379d99db4'), (x'44ea784379d99db5'), + (x'45208b2a2c280290'), (x'45208b2a2c280291'), (x'45208b2a2c280292'), + -- + (x'7feffffffffffffe'), (x'7fefffffffffffff'), + -- round to even tests (+ve) + (x'4350000000000002'), + (x'4350000000002e06'), + (x'4352000000000003'), + (x'4352000000000004'), + (x'4358000000000003'), + (x'4358000000000004'), + (x'435f000000000020'), + -- round to even tests (-ve) + (x'c350000000000002'), + (x'c350000000002e06'), + (x'c352000000000003'), + (x'c352000000000004'), + (x'c358000000000003'), + (x'c358000000000004'), + (x'c35f000000000020'), + -- exercise fixed-point memmoves + (x'42dc12218377de66'), + (x'42a674e79c5fe51f'), + (x'4271f71fb04cb74c'), + (x'423cbe991a145879'), + (x'4206fee0e1a9e061'), + (x'41d26580b487e6b4'), + (x'419d6f34540ca453'), + (x'41678c29dcd6e9dc'), + (x'4132d687e3df217d'), + (x'40fe240c9fcb68c8'), + (x'40c81cd6e63c53d3'), + (x'40934a4584fd0fdc'), + (x'405edd3c07fb4c93'), + (x'4028b0fcd32f7076'), + (x'3ff3c0ca428c59f8'), + -- these cases come from the upstream's testsuite + -- LotsOfTrailingZeros) + (x'3e60000000000000'), + -- Regression + (x'c352bd2668e077c4'), + (x'434018601510c000'), + (x'43d055dc36f24000'), + (x'43e052961c6f8000'), + (x'3ff3c0ca2a5b1d5d'), + -- LooksLikePow5 + (x'4830f0cf064dd592'), + (x'4840f0cf064dd592'), + (x'4850f0cf064dd592'), + -- OutputLength + (x'3ff3333333333333'), + (x'3ff3ae147ae147ae'), + (x'3ff3be76c8b43958'), + (x'3ff3c083126e978d'), + (x'3ff3c0c1fc8f3238'), + (x'3ff3c0c9539b8887'), + (x'3ff3c0ca2a5b1d5d'), + (x'3ff3c0ca4283de1b'), + (x'3ff3c0ca43db770a'), + (x'3ff3c0ca428abd53'), + (x'3ff3c0ca428c1d2b'), + (x'3ff3c0ca428c51f2'), + (x'3ff3c0ca428c58fc'), + (x'3ff3c0ca428c59dd'), + (x'3ff3c0ca428c59f8'), + (x'3ff3c0ca428c59fb'), + -- 32-bit chunking + (x'40112e0be8047a7d'), + (x'40112e0be815a889'), + (x'40112e0be826d695'), + (x'40112e0be83804a1'), + (x'40112e0be84932ad'), + -- MinMaxShift + (x'0040000000000000'), + (x'007fffffffffffff'), + (x'0290000000000000'), + (x'029fffffffffffff'), + (x'4350000000000000'), + (x'435fffffffffffff'), + (x'1330000000000000'), + (x'133fffffffffffff'), + (x'3a6fa7161a4d6e0c') +) +select float8send(flt) as ibits, + flt, + flt::text::float8 as r_flt, + float8send(flt::text::float8) as obits, + float8send(flt::text::float8) = float8send(flt) as correct + from (select bits::bigint::xfloat8::float8 as flt + from testdata + offset 0) s; + +-- clean up, lest opr_sanity complain +drop type xfloat8 cascade; From 46a300e5bcc2d86ea62eb840a2e5745ac9ea43b4 Mon Sep 17 00:00:00 2001 From: Yuming Wang Date: Fri, 21 Jun 2019 17:19:10 +0800 Subject: [PATCH 2/6] Add result --- .../sql-tests/inputs/pgSQL/float8.sql | 688 +++++++++--------- .../sql-tests/results/pgSQL/float8.sql.out | 647 ++++++++++++++++ 2 files changed, 1006 insertions(+), 329 deletions(-) create mode 100644 sql/core/src/test/resources/sql-tests/results/pgSQL/float8.sql.out diff --git a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql index 98eeff2837b40..efd506293426f 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql @@ -5,48 +5,54 @@ -- FLOAT8 -- https://github.com/postgres/postgres/blob/REL_12_BETA1/src/test/regress/sql/float8.sql -CREATE TABLE FLOAT8_TBL(f1 float8); +CREATE TABLE FLOAT8_TBL(f1 double) USING parquet; -INSERT INTO FLOAT8_TBL(f1) VALUES (' 0.0 '); -INSERT INTO FLOAT8_TBL(f1) VALUES ('1004.30 '); -INSERT INTO FLOAT8_TBL(f1) VALUES (' -34.84'); -INSERT INTO FLOAT8_TBL(f1) VALUES ('1.2345678901234e+200'); -INSERT INTO FLOAT8_TBL(f1) VALUES ('1.2345678901234e-200'); +INSERT INTO FLOAT8_TBL VALUES (' 0.0 '); +INSERT INTO FLOAT8_TBL VALUES ('1004.30 '); +INSERT INTO FLOAT8_TBL VALUES (' -34.84'); +INSERT INTO FLOAT8_TBL VALUES ('1.2345678901234e+200'); +INSERT INTO FLOAT8_TBL VALUES ('1.2345678901234e-200'); +-- [SPARK-28024] Incorrect numeric values when out of range -- test for underflow and overflow handling -SELECT '10e400'::float8; -SELECT '-10e400'::float8; -SELECT '10e-400'::float8; -SELECT '-10e-400'::float8; +SELECT double('10e400'); +SELECT double('-10e400'); +SELECT double('10e-400'); +SELECT double('-10e-400'); +-- [SPARK-28061] Support for converting float to binary format -- test smallest normalized input -SELECT float8send('2.2250738585072014E-308'::float8); +-- SELECT float8send('2.2250738585072014E-308'::float8); +-- [SPARK-27923] Spark SQL insert there bad inputs to NULL -- bad input -INSERT INTO FLOAT8_TBL(f1) VALUES (''); -INSERT INTO FLOAT8_TBL(f1) VALUES (' '); -INSERT INTO FLOAT8_TBL(f1) VALUES ('xyz'); -INSERT INTO FLOAT8_TBL(f1) VALUES ('5.0.0'); -INSERT INTO FLOAT8_TBL(f1) VALUES ('5 . 0'); -INSERT INTO FLOAT8_TBL(f1) VALUES ('5. 0'); -INSERT INTO FLOAT8_TBL(f1) VALUES (' - 3'); -INSERT INTO FLOAT8_TBL(f1) VALUES ('123 5'); +-- INSERT INTO FLOAT8_TBL VALUES (''); +-- INSERT INTO FLOAT8_TBL VALUES (' '); +-- INSERT INTO FLOAT8_TBL VALUES ('xyz'); +-- INSERT INTO FLOAT8_TBL VALUES ('5.0.0'); +-- INSERT INTO FLOAT8_TBL VALUES ('5 . 0'); +-- INSERT INTO FLOAT8_TBL VALUES ('5. 0'); +-- INSERT INTO FLOAT8_TBL VALUES (' - 3'); +-- INSERT INTO FLOAT8_TBL VALUES ('123 5'); -- special inputs -SELECT 'NaN'::float8; -SELECT 'nan'::float8; -SELECT ' NAN '::float8; -SELECT 'infinity'::float8; -SELECT ' -INFINiTY '::float8; +SELECT double('NaN'); +-- [SPARK-28060] Double type can not accept some special inputs +SELECT double('nan'); +SELECT double(' NAN '); +SELECT double('infinity'); +SELECT double(' -INFINiTY '); +-- [SPARK-27923] Spark SQL insert there bad special inputs to NULL -- bad special inputs -SELECT 'N A N'::float8; -SELECT 'NaN x'::float8; -SELECT ' INFINITY x'::float8; +SELECT double('N A N'); +SELECT double('NaN x'); +SELECT double(' INFINITY x'); -SELECT 'Infinity'::float8 + 100.0; -SELECT 'Infinity'::float8 / 'Infinity'::float8; -SELECT 'nan'::float8 / 'nan'::float8; -SELECT 'nan'::numeric::float8; +-- [SPARK-28060] Double type can not accept some special inputs +SELECT double('Infinity') + 100.0; +SELECT double('Infinity') / double('Infinity'); +SELECT double('nan') / double('nan'); +SELECT double(decimal('nan')); SELECT '' AS five, * FROM FLOAT8_TBL; @@ -77,22 +83,25 @@ SELECT '' AS three, f.f1, f.f1 / '-10' AS x SELECT '' AS three, f.f1, f.f1 - '-10' AS x FROM FLOAT8_TBL f WHERE f.f1 > '0.0'; +-- [SPARK-28007] Caret operator (^) means bitwise XOR in Spark/Hive and exponentiation in Postgres +-- SELECT '' AS one, f.f1 ^ '2.0' AS square_f1 +-- FROM FLOAT8_TBL f where f.f1 = '1004.3'; -SELECT '' AS one, f.f1 ^ '2.0' AS square_f1 - FROM FLOAT8_TBL f where f.f1 = '1004.3'; - +-- [SPARK-28027] Spark SQL does not support prefix operator @ -- absolute value -SELECT '' AS five, f.f1, @f.f1 AS abs_f1 - FROM FLOAT8_TBL f; +-- SELECT '' AS five, f.f1, @f.f1 AS abs_f1 +-- FROM FLOAT8_TBL f; +-- [SPARK-23906] Support Truncate number -- truncate -SELECT '' AS five, f.f1, trunc(f.f1) AS trunc_f1 - FROM FLOAT8_TBL f; +-- SELECT '' AS five, f.f1, trunc(f.f1) AS trunc_f1 +-- FROM FLOAT8_TBL f; -- round SELECT '' AS five, f.f1, round(f.f1) AS round_f1 FROM FLOAT8_TBL f; +-- [SPARK-28135] ceil/ceiling/floor returns incorrect values -- ceil / ceiling select ceil(f1) as ceil_f1 from float8_tbl f; select ceiling(f1) as ceiling_f1 from float8_tbl f; @@ -104,190 +113,210 @@ select floor(f1) as floor_f1 from float8_tbl f; select sign(f1) as sign_f1 from float8_tbl f; -- avoid bit-exact output here because operations may not be bit-exact. -SET extra_float_digits = 0; +-- SET extra_float_digits = 0; -- square root -SELECT sqrt(float8 '64') AS eight; +SELECT sqrt(double('64')) AS eight; -SELECT |/ float8 '64' AS eight; +-- [SPARK-28027] Spark SQL does not support prefix operator |/ +-- SELECT |/ float8 '64' AS eight; -SELECT '' AS three, f.f1, |/f.f1 AS sqrt_f1 - FROM FLOAT8_TBL f - WHERE f.f1 > '0.0'; +-- SELECT '' AS three, f.f1, |/f.f1 AS sqrt_f1 +-- FROM FLOAT8_TBL f +-- WHERE f.f1 > '0.0'; -- power -SELECT power(float8 '144', float8 '0.5'); -SELECT power(float8 'NaN', float8 '0.5'); -SELECT power(float8 '144', float8 'NaN'); -SELECT power(float8 'NaN', float8 'NaN'); -SELECT power(float8 '-1', float8 'NaN'); -SELECT power(float8 '1', float8 'NaN'); -SELECT power(float8 'NaN', float8 '0'); +SELECT power(double('144'), double('0.5')); +SELECT power(double('NaN'), double('0.5')); +SELECT power(double('144'), double('NaN')); +SELECT power(double('NaN'), double('NaN')); +SELECT power(double('-1'), double('NaN')); +-- [SPARK-28135] power returns incorrect values +SELECT power(double('1'), double('NaN')); +SELECT power(double('NaN'), double('0')); -- take exp of ln(f.f1) SELECT '' AS three, f.f1, exp(ln(f.f1)) AS exp_ln_f1 FROM FLOAT8_TBL f WHERE f.f1 > '0.0'; +-- [SPARK-28027] Spark SQL does not support prefix operator ||/ -- cube root -SELECT ||/ float8 '27' AS three; +-- SELECT ||/ float8 '27' AS three; -SELECT '' AS five, f.f1, ||/f.f1 AS cbrt_f1 FROM FLOAT8_TBL f; +-- SELECT '' AS five, f.f1, ||/f.f1 AS cbrt_f1 FROM FLOAT8_TBL f; SELECT '' AS five, * FROM FLOAT8_TBL; -UPDATE FLOAT8_TBL - SET f1 = FLOAT8_TBL.f1 * '-1' - WHERE FLOAT8_TBL.f1 > '0.0'; +-- UPDATE FLOAT8_TBL +-- SET f1 = FLOAT8_TBL.f1 * '-1' +-- WHERE FLOAT8_TBL.f1 > '0.0'; +-- Update the FLOAT8_TBL to UPDATED_FLOAT8_TBL +CREATE TEMPORARY VIEW UPDATED_FLOAT8_TBL as +SELECT + CASE WHEN FLOAT8_TBL.f1 > '0.0' THEN FLOAT8_TBL.f1 * '-1' ELSE FLOAT8_TBL.f1 END AS f1 +FROM FLOAT8_TBL; -SELECT '' AS bad, f.f1 * '1e200' from FLOAT8_TBL f; +-- [SPARK-27923] Out of range, Spark SQL returns Infinity +SELECT '' AS bad, f.f1 * '1e200' from UPDATED_FLOAT8_TBL f; -SELECT '' AS bad, f.f1 ^ '1e200' from FLOAT8_TBL f; +-- [SPARK-28007] Caret operator (^) means bitwise XOR in Spark/Hive and exponentiation in Postgres +-- SELECT '' AS bad, f.f1 ^ '1e200' from UPDATED_FLOAT8_TBL f; -SELECT 0 ^ 0 + 0 ^ 1 + 0 ^ 0.0 + 0 ^ 0.5; +-- SELECT 0 ^ 0 + 0 ^ 1 + 0 ^ 0.0 + 0 ^ 0.5; -SELECT '' AS bad, ln(f.f1) from FLOAT8_TBL f where f.f1 = '0.0' ; +-- [SPARK-27923] Cannot take logarithm of zero +-- SELECT '' AS bad, ln(f.f1) from UPDATED_FLOAT8_TBL f where f.f1 = '0.0' ; -SELECT '' AS bad, ln(f.f1) from FLOAT8_TBL f where f.f1 < '0.0' ; +-- [SPARK-27923] Cannot take logarithm of a negative number +-- SELECT '' AS bad, ln(f.f1) from UPDATED_FLOAT8_TBL f where f.f1 < '0.0' ; -SELECT '' AS bad, exp(f.f1) from FLOAT8_TBL f; +-- [SPARK-28024] Incorrect numeric values when out of range +-- SELECT '' AS bad, exp(f.f1) from UPDATED_FLOAT8_TBL f; -SELECT '' AS bad, f.f1 / '0.0' from FLOAT8_TBL f; +-- [SPARK-27923] Divide by zero, Spark SQL returns NULL +-- SELECT '' AS bad, f.f1 / '0.0' from UPDATED_FLOAT8_TBL f; -SELECT '' AS five, * FROM FLOAT8_TBL; +SELECT '' AS five, * FROM UPDATED_FLOAT8_TBL; +-- [SPARK-28133] Missing hyperbolic functions -- hyperbolic functions -- we run these with extra_float_digits = 0 too, since different platforms -- tend to produce results that vary in the last place. -SELECT sinh(float8 '1'); -SELECT cosh(float8 '1'); -SELECT tanh(float8 '1'); -SELECT asinh(float8 '1'); -SELECT acosh(float8 '2'); -SELECT atanh(float8 '0.5'); +-- SELECT sinh(float8 '1'); +-- SELECT cosh(float8 '1'); +-- SELECT tanh(float8 '1'); +-- SELECT asinh(float8 '1'); +-- SELECT acosh(float8 '2'); +-- SELECT atanh(float8 '0.5'); -- test Inf/NaN cases for hyperbolic functions -SELECT sinh(float8 'infinity'); -SELECT sinh(float8 '-infinity'); -SELECT sinh(float8 'nan'); -SELECT cosh(float8 'infinity'); -SELECT cosh(float8 '-infinity'); -SELECT cosh(float8 'nan'); -SELECT tanh(float8 'infinity'); -SELECT tanh(float8 '-infinity'); -SELECT tanh(float8 'nan'); -SELECT asinh(float8 'infinity'); -SELECT asinh(float8 '-infinity'); -SELECT asinh(float8 'nan'); +-- SELECT sinh(float8 'infinity'); +-- SELECT sinh(float8 '-infinity'); +-- SELECT sinh(float8 'nan'); +-- SELECT cosh(float8 'infinity'); +-- SELECT cosh(float8 '-infinity'); +-- SELECT cosh(float8 'nan'); +-- SELECT tanh(float8 'infinity'); +-- SELECT tanh(float8 '-infinity'); +-- SELECT tanh(float8 'nan'); +-- SELECT asinh(float8 'infinity'); +-- SELECT asinh(float8 '-infinity'); +-- SELECT asinh(float8 'nan'); -- acosh(Inf) should be Inf, but some mingw versions produce NaN, so skip test -- SELECT acosh(float8 'infinity'); -SELECT acosh(float8 '-infinity'); -SELECT acosh(float8 'nan'); -SELECT atanh(float8 'infinity'); -SELECT atanh(float8 '-infinity'); -SELECT atanh(float8 'nan'); +-- SELECT acosh(float8 '-infinity'); +-- SELECT acosh(float8 'nan'); +-- SELECT atanh(float8 'infinity'); +-- SELECT atanh(float8 '-infinity'); +-- SELECT atanh(float8 'nan'); -RESET extra_float_digits; +-- RESET extra_float_digits; +-- [SPARK-28024] Incorrect numeric values when out of range -- test for over- and underflow -INSERT INTO FLOAT8_TBL(f1) VALUES ('10e400'); +-- INSERT INTO FLOAT8_TBL VALUES ('10e400'); -INSERT INTO FLOAT8_TBL(f1) VALUES ('-10e400'); +-- INSERT INTO FLOAT8_TBL VALUES ('-10e400'); -INSERT INTO FLOAT8_TBL(f1) VALUES ('10e-400'); +-- INSERT INTO FLOAT8_TBL VALUES ('10e-400'); -INSERT INTO FLOAT8_TBL(f1) VALUES ('-10e-400'); +-- INSERT INTO FLOAT8_TBL VALUES ('-10e-400'); -- maintain external table consistency across platforms -- delete all values and reinsert well-behaved ones -DELETE FROM FLOAT8_TBL; +TRUNCATE TABLE FLOAT8_TBL; -INSERT INTO FLOAT8_TBL(f1) VALUES ('0.0'); +INSERT INTO FLOAT8_TBL VALUES ('0.0'); -INSERT INTO FLOAT8_TBL(f1) VALUES ('-34.84'); +INSERT INTO FLOAT8_TBL VALUES ('-34.84'); -INSERT INTO FLOAT8_TBL(f1) VALUES ('-1004.30'); +INSERT INTO FLOAT8_TBL VALUES ('-1004.30'); -INSERT INTO FLOAT8_TBL(f1) VALUES ('-1.2345678901234e+200'); +INSERT INTO FLOAT8_TBL VALUES ('-1.2345678901234e+200'); -INSERT INTO FLOAT8_TBL(f1) VALUES ('-1.2345678901234e-200'); +INSERT INTO FLOAT8_TBL VALUES ('-1.2345678901234e-200'); SELECT '' AS five, * FROM FLOAT8_TBL; +-- [SPARK-28028] Cast numeric to integral type need round +-- [SPARK-28024] Incorrect numeric values when out of range -- test edge-case coercions to integer -SELECT '32767.4'::float8::int2; -SELECT '32767.6'::float8::int2; -SELECT '-32768.4'::float8::int2; -SELECT '-32768.6'::float8::int2; -SELECT '2147483647.4'::float8::int4; -SELECT '2147483647.6'::float8::int4; -SELECT '-2147483648.4'::float8::int4; -SELECT '-2147483648.6'::float8::int4; -SELECT '9223372036854773760'::float8::int8; -SELECT '9223372036854775807'::float8::int8; -SELECT '-9223372036854775808.5'::float8::int8; -SELECT '-9223372036854780000'::float8::int8; - +SELECT smallint(double('32767.4')); +SELECT smallint(double('32767.6')); +SELECT smallint(double('-32768.4')); +SELECT smallint(double('-32768.6')); +SELECT int(double('2147483647.4')); +SELECT int(double('2147483647.6')); +SELECT int(double('-2147483648.4')); +SELECT int(double('-2147483648.6')); +SELECT bigint(double('9223372036854773760')); +SELECT bigint(double('9223372036854775807')); +SELECT bigint(double('-9223372036854775808.5')); +SELECT bigint(double('-9223372036854780000')); + +-- [SPARK-28134] Missing Trigonometric Functions -- test exact cases for trigonometric functions in degrees -SELECT x, - sind(x), - sind(x) IN (-1,-0.5,0,0.5,1) AS sind_exact -FROM (VALUES (0), (30), (90), (150), (180), - (210), (270), (330), (360)) AS t(x); - -SELECT x, - cosd(x), - cosd(x) IN (-1,-0.5,0,0.5,1) AS cosd_exact -FROM (VALUES (0), (60), (90), (120), (180), - (240), (270), (300), (360)) AS t(x); - -SELECT x, - tand(x), - tand(x) IN ('-Infinity'::float8,-1,0, - 1,'Infinity'::float8) AS tand_exact, - cotd(x), - cotd(x) IN ('-Infinity'::float8,-1,0, - 1,'Infinity'::float8) AS cotd_exact -FROM (VALUES (0), (45), (90), (135), (180), - (225), (270), (315), (360)) AS t(x); - -SELECT x, - asind(x), - asind(x) IN (-90,-30,0,30,90) AS asind_exact, - acosd(x), - acosd(x) IN (0,60,90,120,180) AS acosd_exact -FROM (VALUES (-1), (-0.5), (0), (0.5), (1)) AS t(x); - -SELECT x, - atand(x), - atand(x) IN (-90,-45,0,45,90) AS atand_exact -FROM (VALUES ('-Infinity'::float8), (-1), (0), (1), - ('Infinity'::float8)) AS t(x); - -SELECT x, y, - atan2d(y, x), - atan2d(y, x) IN (-90,0,90,180) AS atan2d_exact -FROM (SELECT 10*cosd(a), 10*sind(a) - FROM generate_series(0, 360, 90) AS t(a)) AS t(x,y); - +-- SELECT x, +-- sind(x), +-- sind(x) IN (-1,-0.5,0,0.5,1) AS sind_exact +-- FROM (VALUES (0), (30), (90), (150), (180), +-- (210), (270), (330), (360)) AS t(x); + +-- SELECT x, +-- cosd(x), +-- cosd(x) IN (-1,-0.5,0,0.5,1) AS cosd_exact +-- FROM (VALUES (0), (60), (90), (120), (180), +-- (240), (270), (300), (360)) AS t(x); + +-- SELECT x, +-- tand(x), +-- tand(x) IN ('-Infinity'::float8,-1,0, +-- 1,'Infinity'::float8) AS tand_exact, +-- cotd(x), +-- cotd(x) IN ('-Infinity'::float8,-1,0, +-- 1,'Infinity'::float8) AS cotd_exact +-- FROM (VALUES (0), (45), (90), (135), (180), +-- (225), (270), (315), (360)) AS t(x); + +-- SELECT x, +-- asind(x), +-- asind(x) IN (-90,-30,0,30,90) AS asind_exact, +-- acosd(x), +-- acosd(x) IN (0,60,90,120,180) AS acosd_exact +-- FROM (VALUES (-1), (-0.5), (0), (0.5), (1)) AS t(x); + +-- SELECT x, +-- atand(x), +-- atand(x) IN (-90,-45,0,45,90) AS atand_exact +-- FROM (VALUES ('-Infinity'::float8), (-1), (0), (1), +-- ('Infinity'::float8)) AS t(x); + +-- SELECT x, y, +-- atan2d(y, x), +-- atan2d(y, x) IN (-90,0,90,180) AS atan2d_exact +-- FROM (SELECT 10*cosd(a), 10*sind(a) +-- FROM generate_series(0, 360, 90) AS t(a)) AS t(x,y); + +-- We do not support creating types, skip the test below -- -- test output (and round-trip safety) of various values. -- To ensure we're testing what we think we're testing, start with -- float values specified by bit patterns (as a useful side effect, -- this means we'll fail on non-IEEE platforms). -create type xfloat8; -create function xfloat8in(cstring) returns xfloat8 immutable strict - language internal as 'int8in'; -create function xfloat8out(xfloat8) returns cstring immutable strict - language internal as 'int8out'; -create type xfloat8 (input = xfloat8in, output = xfloat8out, like = float8); -create cast (xfloat8 as float8) without function; -create cast (float8 as xfloat8) without function; -create cast (xfloat8 as bigint) without function; -create cast (bigint as xfloat8) without function; +-- create type xfloat8; +-- create function xfloat8in(cstring) returns xfloat8 immutable strict +-- language internal as 'int8in'; +-- create function xfloat8out(xfloat8) returns cstring immutable strict +-- language internal as 'int8out'; +-- create type xfloat8 (input = xfloat8in, output = xfloat8out, like = float8); +-- create cast (xfloat8 as float8) without function; +-- create cast (float8 as xfloat8) without function; +-- create cast (xfloat8 as bigint) without function; +-- create cast (bigint as xfloat8) without function; -- float8: seeeeeee eeeeeeee eeeeeeee mmmmmmmm mmmmmmmm(x4) @@ -295,175 +324,176 @@ create cast (bigint as xfloat8) without function; -- correctly; those are "use at your own risk". However we do test -- subnormal outputs, since those are under our control. -with testdata(bits) as (values - -- small subnormals - (x'0000000000000001'), - (x'0000000000000002'), (x'0000000000000003'), - (x'0000000000001000'), (x'0000000100000000'), - (x'0000010000000000'), (x'0000010100000000'), - (x'0000400000000000'), (x'0000400100000000'), - (x'0000800000000000'), (x'0000800000000001'), - -- these values taken from upstream testsuite - (x'00000000000f4240'), - (x'00000000016e3600'), - (x'0000008cdcdea440'), - -- borderline between subnormal and normal - (x'000ffffffffffff0'), (x'000ffffffffffff1'), - (x'000ffffffffffffe'), (x'000fffffffffffff')) -select float8send(flt) as ibits, - flt - from (select bits::bigint::xfloat8::float8 as flt - from testdata - offset 0) s; +-- with testdata(bits) as (values +-- -- small subnormals +-- (x'0000000000000001'), +-- (x'0000000000000002'), (x'0000000000000003'), +-- (x'0000000000001000'), (x'0000000100000000'), +-- (x'0000010000000000'), (x'0000010100000000'), +-- (x'0000400000000000'), (x'0000400100000000'), +-- (x'0000800000000000'), (x'0000800000000001'), +-- -- these values taken from upstream testsuite +-- (x'00000000000f4240'), +-- (x'00000000016e3600'), +-- (x'0000008cdcdea440'), +-- -- borderline between subnormal and normal +-- (x'000ffffffffffff0'), (x'000ffffffffffff1'), +-- (x'000ffffffffffffe'), (x'000fffffffffffff')) +-- select float8send(flt) as ibits, +-- flt +-- from (select bits::bigint::xfloat8::float8 as flt +-- from testdata +-- offset 0) s; -- round-trip tests -with testdata(bits) as (values - (x'0000000000000000'), - -- smallest normal values - (x'0010000000000000'), (x'0010000000000001'), - (x'0010000000000002'), (x'0018000000000000'), - -- - (x'3ddb7cdfd9d7bdba'), (x'3ddb7cdfd9d7bdbb'), (x'3ddb7cdfd9d7bdbc'), - (x'3e112e0be826d694'), (x'3e112e0be826d695'), (x'3e112e0be826d696'), - (x'3e45798ee2308c39'), (x'3e45798ee2308c3a'), (x'3e45798ee2308c3b'), - (x'3e7ad7f29abcaf47'), (x'3e7ad7f29abcaf48'), (x'3e7ad7f29abcaf49'), - (x'3eb0c6f7a0b5ed8c'), (x'3eb0c6f7a0b5ed8d'), (x'3eb0c6f7a0b5ed8e'), - (x'3ee4f8b588e368ef'), (x'3ee4f8b588e368f0'), (x'3ee4f8b588e368f1'), - (x'3f1a36e2eb1c432c'), (x'3f1a36e2eb1c432d'), (x'3f1a36e2eb1c432e'), - (x'3f50624dd2f1a9fb'), (x'3f50624dd2f1a9fc'), (x'3f50624dd2f1a9fd'), - (x'3f847ae147ae147a'), (x'3f847ae147ae147b'), (x'3f847ae147ae147c'), - (x'3fb9999999999999'), (x'3fb999999999999a'), (x'3fb999999999999b'), - -- values very close to 1 - (x'3feffffffffffff0'), (x'3feffffffffffff1'), (x'3feffffffffffff2'), - (x'3feffffffffffff3'), (x'3feffffffffffff4'), (x'3feffffffffffff5'), - (x'3feffffffffffff6'), (x'3feffffffffffff7'), (x'3feffffffffffff8'), - (x'3feffffffffffff9'), (x'3feffffffffffffa'), (x'3feffffffffffffb'), - (x'3feffffffffffffc'), (x'3feffffffffffffd'), (x'3feffffffffffffe'), - (x'3fefffffffffffff'), - (x'3ff0000000000000'), - (x'3ff0000000000001'), (x'3ff0000000000002'), (x'3ff0000000000003'), - (x'3ff0000000000004'), (x'3ff0000000000005'), (x'3ff0000000000006'), - (x'3ff0000000000007'), (x'3ff0000000000008'), (x'3ff0000000000009'), - -- - (x'3ff921fb54442d18'), - (x'4005bf0a8b14576a'), - (x'400921fb54442d18'), - -- - (x'4023ffffffffffff'), (x'4024000000000000'), (x'4024000000000001'), - (x'4058ffffffffffff'), (x'4059000000000000'), (x'4059000000000001'), - (x'408f3fffffffffff'), (x'408f400000000000'), (x'408f400000000001'), - (x'40c387ffffffffff'), (x'40c3880000000000'), (x'40c3880000000001'), - (x'40f869ffffffffff'), (x'40f86a0000000000'), (x'40f86a0000000001'), - (x'412e847fffffffff'), (x'412e848000000000'), (x'412e848000000001'), - (x'416312cfffffffff'), (x'416312d000000000'), (x'416312d000000001'), - (x'4197d783ffffffff'), (x'4197d78400000000'), (x'4197d78400000001'), - (x'41cdcd64ffffffff'), (x'41cdcd6500000000'), (x'41cdcd6500000001'), - (x'4202a05f1fffffff'), (x'4202a05f20000000'), (x'4202a05f20000001'), - (x'42374876e7ffffff'), (x'42374876e8000000'), (x'42374876e8000001'), - (x'426d1a94a1ffffff'), (x'426d1a94a2000000'), (x'426d1a94a2000001'), - (x'42a2309ce53fffff'), (x'42a2309ce5400000'), (x'42a2309ce5400001'), - (x'42d6bcc41e8fffff'), (x'42d6bcc41e900000'), (x'42d6bcc41e900001'), - (x'430c6bf52633ffff'), (x'430c6bf526340000'), (x'430c6bf526340001'), - (x'4341c37937e07fff'), (x'4341c37937e08000'), (x'4341c37937e08001'), - (x'4376345785d89fff'), (x'4376345785d8a000'), (x'4376345785d8a001'), - (x'43abc16d674ec7ff'), (x'43abc16d674ec800'), (x'43abc16d674ec801'), - (x'43e158e460913cff'), (x'43e158e460913d00'), (x'43e158e460913d01'), - (x'4415af1d78b58c3f'), (x'4415af1d78b58c40'), (x'4415af1d78b58c41'), - (x'444b1ae4d6e2ef4f'), (x'444b1ae4d6e2ef50'), (x'444b1ae4d6e2ef51'), - (x'4480f0cf064dd591'), (x'4480f0cf064dd592'), (x'4480f0cf064dd593'), - (x'44b52d02c7e14af5'), (x'44b52d02c7e14af6'), (x'44b52d02c7e14af7'), - (x'44ea784379d99db3'), (x'44ea784379d99db4'), (x'44ea784379d99db5'), - (x'45208b2a2c280290'), (x'45208b2a2c280291'), (x'45208b2a2c280292'), - -- - (x'7feffffffffffffe'), (x'7fefffffffffffff'), - -- round to even tests (+ve) - (x'4350000000000002'), - (x'4350000000002e06'), - (x'4352000000000003'), - (x'4352000000000004'), - (x'4358000000000003'), - (x'4358000000000004'), - (x'435f000000000020'), - -- round to even tests (-ve) - (x'c350000000000002'), - (x'c350000000002e06'), - (x'c352000000000003'), - (x'c352000000000004'), - (x'c358000000000003'), - (x'c358000000000004'), - (x'c35f000000000020'), - -- exercise fixed-point memmoves - (x'42dc12218377de66'), - (x'42a674e79c5fe51f'), - (x'4271f71fb04cb74c'), - (x'423cbe991a145879'), - (x'4206fee0e1a9e061'), - (x'41d26580b487e6b4'), - (x'419d6f34540ca453'), - (x'41678c29dcd6e9dc'), - (x'4132d687e3df217d'), - (x'40fe240c9fcb68c8'), - (x'40c81cd6e63c53d3'), - (x'40934a4584fd0fdc'), - (x'405edd3c07fb4c93'), - (x'4028b0fcd32f7076'), - (x'3ff3c0ca428c59f8'), - -- these cases come from the upstream's testsuite - -- LotsOfTrailingZeros) - (x'3e60000000000000'), - -- Regression - (x'c352bd2668e077c4'), - (x'434018601510c000'), - (x'43d055dc36f24000'), - (x'43e052961c6f8000'), - (x'3ff3c0ca2a5b1d5d'), - -- LooksLikePow5 - (x'4830f0cf064dd592'), - (x'4840f0cf064dd592'), - (x'4850f0cf064dd592'), - -- OutputLength - (x'3ff3333333333333'), - (x'3ff3ae147ae147ae'), - (x'3ff3be76c8b43958'), - (x'3ff3c083126e978d'), - (x'3ff3c0c1fc8f3238'), - (x'3ff3c0c9539b8887'), - (x'3ff3c0ca2a5b1d5d'), - (x'3ff3c0ca4283de1b'), - (x'3ff3c0ca43db770a'), - (x'3ff3c0ca428abd53'), - (x'3ff3c0ca428c1d2b'), - (x'3ff3c0ca428c51f2'), - (x'3ff3c0ca428c58fc'), - (x'3ff3c0ca428c59dd'), - (x'3ff3c0ca428c59f8'), - (x'3ff3c0ca428c59fb'), - -- 32-bit chunking - (x'40112e0be8047a7d'), - (x'40112e0be815a889'), - (x'40112e0be826d695'), - (x'40112e0be83804a1'), - (x'40112e0be84932ad'), - -- MinMaxShift - (x'0040000000000000'), - (x'007fffffffffffff'), - (x'0290000000000000'), - (x'029fffffffffffff'), - (x'4350000000000000'), - (x'435fffffffffffff'), - (x'1330000000000000'), - (x'133fffffffffffff'), - (x'3a6fa7161a4d6e0c') -) -select float8send(flt) as ibits, - flt, - flt::text::float8 as r_flt, - float8send(flt::text::float8) as obits, - float8send(flt::text::float8) = float8send(flt) as correct - from (select bits::bigint::xfloat8::float8 as flt - from testdata - offset 0) s; +-- with testdata(bits) as (values +-- (x'0000000000000000'), +-- -- smallest normal values +-- (x'0010000000000000'), (x'0010000000000001'), +-- (x'0010000000000002'), (x'0018000000000000'), +-- -- +-- (x'3ddb7cdfd9d7bdba'), (x'3ddb7cdfd9d7bdbb'), (x'3ddb7cdfd9d7bdbc'), +-- (x'3e112e0be826d694'), (x'3e112e0be826d695'), (x'3e112e0be826d696'), +-- (x'3e45798ee2308c39'), (x'3e45798ee2308c3a'), (x'3e45798ee2308c3b'), +-- (x'3e7ad7f29abcaf47'), (x'3e7ad7f29abcaf48'), (x'3e7ad7f29abcaf49'), +-- (x'3eb0c6f7a0b5ed8c'), (x'3eb0c6f7a0b5ed8d'), (x'3eb0c6f7a0b5ed8e'), +-- (x'3ee4f8b588e368ef'), (x'3ee4f8b588e368f0'), (x'3ee4f8b588e368f1'), +-- (x'3f1a36e2eb1c432c'), (x'3f1a36e2eb1c432d'), (x'3f1a36e2eb1c432e'), +-- (x'3f50624dd2f1a9fb'), (x'3f50624dd2f1a9fc'), (x'3f50624dd2f1a9fd'), +-- (x'3f847ae147ae147a'), (x'3f847ae147ae147b'), (x'3f847ae147ae147c'), +-- (x'3fb9999999999999'), (x'3fb999999999999a'), (x'3fb999999999999b'), +-- -- values very close to 1 +-- (x'3feffffffffffff0'), (x'3feffffffffffff1'), (x'3feffffffffffff2'), +-- (x'3feffffffffffff3'), (x'3feffffffffffff4'), (x'3feffffffffffff5'), +-- (x'3feffffffffffff6'), (x'3feffffffffffff7'), (x'3feffffffffffff8'), +-- (x'3feffffffffffff9'), (x'3feffffffffffffa'), (x'3feffffffffffffb'), +-- (x'3feffffffffffffc'), (x'3feffffffffffffd'), (x'3feffffffffffffe'), +-- (x'3fefffffffffffff'), +-- (x'3ff0000000000000'), +-- (x'3ff0000000000001'), (x'3ff0000000000002'), (x'3ff0000000000003'), +-- (x'3ff0000000000004'), (x'3ff0000000000005'), (x'3ff0000000000006'), +-- (x'3ff0000000000007'), (x'3ff0000000000008'), (x'3ff0000000000009'), +-- -- +-- (x'3ff921fb54442d18'), +-- (x'4005bf0a8b14576a'), +-- (x'400921fb54442d18'), +-- -- +-- (x'4023ffffffffffff'), (x'4024000000000000'), (x'4024000000000001'), +-- (x'4058ffffffffffff'), (x'4059000000000000'), (x'4059000000000001'), +-- (x'408f3fffffffffff'), (x'408f400000000000'), (x'408f400000000001'), +-- (x'40c387ffffffffff'), (x'40c3880000000000'), (x'40c3880000000001'), +-- (x'40f869ffffffffff'), (x'40f86a0000000000'), (x'40f86a0000000001'), +-- (x'412e847fffffffff'), (x'412e848000000000'), (x'412e848000000001'), +-- (x'416312cfffffffff'), (x'416312d000000000'), (x'416312d000000001'), +-- (x'4197d783ffffffff'), (x'4197d78400000000'), (x'4197d78400000001'), +-- (x'41cdcd64ffffffff'), (x'41cdcd6500000000'), (x'41cdcd6500000001'), +-- (x'4202a05f1fffffff'), (x'4202a05f20000000'), (x'4202a05f20000001'), +-- (x'42374876e7ffffff'), (x'42374876e8000000'), (x'42374876e8000001'), +-- (x'426d1a94a1ffffff'), (x'426d1a94a2000000'), (x'426d1a94a2000001'), +-- (x'42a2309ce53fffff'), (x'42a2309ce5400000'), (x'42a2309ce5400001'), +-- (x'42d6bcc41e8fffff'), (x'42d6bcc41e900000'), (x'42d6bcc41e900001'), +-- (x'430c6bf52633ffff'), (x'430c6bf526340000'), (x'430c6bf526340001'), +-- (x'4341c37937e07fff'), (x'4341c37937e08000'), (x'4341c37937e08001'), +-- (x'4376345785d89fff'), (x'4376345785d8a000'), (x'4376345785d8a001'), +-- (x'43abc16d674ec7ff'), (x'43abc16d674ec800'), (x'43abc16d674ec801'), +-- (x'43e158e460913cff'), (x'43e158e460913d00'), (x'43e158e460913d01'), +-- (x'4415af1d78b58c3f'), (x'4415af1d78b58c40'), (x'4415af1d78b58c41'), +-- (x'444b1ae4d6e2ef4f'), (x'444b1ae4d6e2ef50'), (x'444b1ae4d6e2ef51'), +-- (x'4480f0cf064dd591'), (x'4480f0cf064dd592'), (x'4480f0cf064dd593'), +-- (x'44b52d02c7e14af5'), (x'44b52d02c7e14af6'), (x'44b52d02c7e14af7'), +-- (x'44ea784379d99db3'), (x'44ea784379d99db4'), (x'44ea784379d99db5'), +-- (x'45208b2a2c280290'), (x'45208b2a2c280291'), (x'45208b2a2c280292'), +-- -- +-- (x'7feffffffffffffe'), (x'7fefffffffffffff'), +-- -- round to even tests (+ve) +-- (x'4350000000000002'), +-- (x'4350000000002e06'), +-- (x'4352000000000003'), +-- (x'4352000000000004'), +-- (x'4358000000000003'), +-- (x'4358000000000004'), +-- (x'435f000000000020'), +-- -- round to even tests (-ve) +-- (x'c350000000000002'), +-- (x'c350000000002e06'), +-- (x'c352000000000003'), +-- (x'c352000000000004'), +-- (x'c358000000000003'), +-- (x'c358000000000004'), +-- (x'c35f000000000020'), +-- -- exercise fixed-point memmoves +-- (x'42dc12218377de66'), +-- (x'42a674e79c5fe51f'), +-- (x'4271f71fb04cb74c'), +-- (x'423cbe991a145879'), +-- (x'4206fee0e1a9e061'), +-- (x'41d26580b487e6b4'), +-- (x'419d6f34540ca453'), +-- (x'41678c29dcd6e9dc'), +-- (x'4132d687e3df217d'), +-- (x'40fe240c9fcb68c8'), +-- (x'40c81cd6e63c53d3'), +-- (x'40934a4584fd0fdc'), +-- (x'405edd3c07fb4c93'), +-- (x'4028b0fcd32f7076'), +-- (x'3ff3c0ca428c59f8'), +-- -- these cases come from the upstream's testsuite +-- -- LotsOfTrailingZeros) +-- (x'3e60000000000000'), +-- -- Regression +-- (x'c352bd2668e077c4'), +-- (x'434018601510c000'), +-- (x'43d055dc36f24000'), +-- (x'43e052961c6f8000'), +-- (x'3ff3c0ca2a5b1d5d'), +-- -- LooksLikePow5 +-- (x'4830f0cf064dd592'), +-- (x'4840f0cf064dd592'), +-- (x'4850f0cf064dd592'), +-- -- OutputLength +-- (x'3ff3333333333333'), +-- (x'3ff3ae147ae147ae'), +-- (x'3ff3be76c8b43958'), +-- (x'3ff3c083126e978d'), +-- (x'3ff3c0c1fc8f3238'), +-- (x'3ff3c0c9539b8887'), +-- (x'3ff3c0ca2a5b1d5d'), +-- (x'3ff3c0ca4283de1b'), +-- (x'3ff3c0ca43db770a'), +-- (x'3ff3c0ca428abd53'), +-- (x'3ff3c0ca428c1d2b'), +-- (x'3ff3c0ca428c51f2'), +-- (x'3ff3c0ca428c58fc'), +-- (x'3ff3c0ca428c59dd'), +-- (x'3ff3c0ca428c59f8'), +-- (x'3ff3c0ca428c59fb'), +-- -- 32-bit chunking +-- (x'40112e0be8047a7d'), +-- (x'40112e0be815a889'), +-- (x'40112e0be826d695'), +-- (x'40112e0be83804a1'), +-- (x'40112e0be84932ad'), +-- -- MinMaxShift +-- (x'0040000000000000'), +-- (x'007fffffffffffff'), +-- (x'0290000000000000'), +-- (x'029fffffffffffff'), +-- (x'4350000000000000'), +-- (x'435fffffffffffff'), +-- (x'1330000000000000'), +-- (x'133fffffffffffff'), +-- (x'3a6fa7161a4d6e0c') +-- ) +-- select float8send(flt) as ibits, +-- flt, +-- flt::text::float8 as r_flt, +-- float8send(flt::text::float8) as obits, +-- float8send(flt::text::float8) = float8send(flt) as correct +-- from (select bits::bigint::xfloat8::float8 as flt +-- from testdata +-- offset 0) s; -- clean up, lest opr_sanity complain -drop type xfloat8 cascade; +-- drop type xfloat8 cascade; +DROP TABLE FLOAT8_TBL; diff --git a/sql/core/src/test/resources/sql-tests/results/pgSQL/float8.sql.out b/sql/core/src/test/resources/sql-tests/results/pgSQL/float8.sql.out new file mode 100644 index 0000000000000..da60d13aa7b04 --- /dev/null +++ b/sql/core/src/test/resources/sql-tests/results/pgSQL/float8.sql.out @@ -0,0 +1,647 @@ +-- Automatically generated by SQLQueryTestSuite +-- Number of queries: 71 + + +-- !query 0 +CREATE TABLE FLOAT8_TBL(f1 double) USING parquet +-- !query 0 schema +struct<> +-- !query 0 output + + + +-- !query 1 +INSERT INTO FLOAT8_TBL VALUES (' 0.0 ') +-- !query 1 schema +struct<> +-- !query 1 output + + + +-- !query 2 +INSERT INTO FLOAT8_TBL VALUES ('1004.30 ') +-- !query 2 schema +struct<> +-- !query 2 output + + + +-- !query 3 +INSERT INTO FLOAT8_TBL VALUES (' -34.84') +-- !query 3 schema +struct<> +-- !query 3 output + + + +-- !query 4 +INSERT INTO FLOAT8_TBL VALUES ('1.2345678901234e+200') +-- !query 4 schema +struct<> +-- !query 4 output + + + +-- !query 5 +INSERT INTO FLOAT8_TBL VALUES ('1.2345678901234e-200') +-- !query 5 schema +struct<> +-- !query 5 output + + + +-- !query 6 +SELECT double('10e400') +-- !query 6 schema +struct +-- !query 6 output +Infinity + + +-- !query 7 +SELECT double('-10e400') +-- !query 7 schema +struct +-- !query 7 output +-Infinity + + +-- !query 8 +SELECT double('10e-400') +-- !query 8 schema +struct +-- !query 8 output +0.0 + + +-- !query 9 +SELECT double('-10e-400') +-- !query 9 schema +struct +-- !query 9 output +-0.0 + + +-- !query 10 +SELECT double('NaN') +-- !query 10 schema +struct +-- !query 10 output +NaN + + +-- !query 11 +SELECT double('nan') +-- !query 11 schema +struct +-- !query 11 output +NULL + + +-- !query 12 +SELECT double(' NAN ') +-- !query 12 schema +struct +-- !query 12 output +NULL + + +-- !query 13 +SELECT double('infinity') +-- !query 13 schema +struct +-- !query 13 output +NULL + + +-- !query 14 +SELECT double(' -INFINiTY ') +-- !query 14 schema +struct +-- !query 14 output +NULL + + +-- !query 15 +SELECT double('N A N') +-- !query 15 schema +struct +-- !query 15 output +NULL + + +-- !query 16 +SELECT double('NaN x') +-- !query 16 schema +struct +-- !query 16 output +NULL + + +-- !query 17 +SELECT double(' INFINITY x') +-- !query 17 schema +struct +-- !query 17 output +NULL + + +-- !query 18 +SELECT double('Infinity') + 100.0 +-- !query 18 schema +struct<(CAST(Infinity AS DOUBLE) + CAST(100.0 AS DOUBLE)):double> +-- !query 18 output +Infinity + + +-- !query 19 +SELECT double('Infinity') / double('Infinity') +-- !query 19 schema +struct<(CAST(Infinity AS DOUBLE) / CAST(Infinity AS DOUBLE)):double> +-- !query 19 output +NaN + + +-- !query 20 +SELECT double('nan') / double('nan') +-- !query 20 schema +struct<(CAST(nan AS DOUBLE) / CAST(nan AS DOUBLE)):double> +-- !query 20 output +NULL + + +-- !query 21 +SELECT double(decimal('nan')) +-- !query 21 schema +struct +-- !query 21 output +NULL + + +-- !query 22 +SELECT '' AS five, * FROM FLOAT8_TBL +-- !query 22 schema +struct +-- !query 22 output +-34.84 + 0.0 + 1.2345678901234E-200 + 1.2345678901234E200 + 1004.3 + + +-- !query 23 +SELECT '' AS four, f.* FROM FLOAT8_TBL f WHERE f.f1 <> '1004.3' +-- !query 23 schema +struct +-- !query 23 output +-34.84 + 0.0 + 1.2345678901234E-200 + 1.2345678901234E200 + + +-- !query 24 +SELECT '' AS one, f.* FROM FLOAT8_TBL f WHERE f.f1 = '1004.3' +-- !query 24 schema +struct +-- !query 24 output +1004.3 + + +-- !query 25 +SELECT '' AS three, f.* FROM FLOAT8_TBL f WHERE '1004.3' > f.f1 +-- !query 25 schema +struct +-- !query 25 output +-34.84 + 0.0 + 1.2345678901234E-200 + + +-- !query 26 +SELECT '' AS three, f.* FROM FLOAT8_TBL f WHERE f.f1 < '1004.3' +-- !query 26 schema +struct +-- !query 26 output +-34.84 + 0.0 + 1.2345678901234E-200 + + +-- !query 27 +SELECT '' AS four, f.* FROM FLOAT8_TBL f WHERE '1004.3' >= f.f1 +-- !query 27 schema +struct +-- !query 27 output +-34.84 + 0.0 + 1.2345678901234E-200 + 1004.3 + + +-- !query 28 +SELECT '' AS four, f.* FROM FLOAT8_TBL f WHERE f.f1 <= '1004.3' +-- !query 28 schema +struct +-- !query 28 output +-34.84 + 0.0 + 1.2345678901234E-200 + 1004.3 + + +-- !query 29 +SELECT '' AS three, f.f1, f.f1 * '-10' AS x + FROM FLOAT8_TBL f + WHERE f.f1 > '0.0' +-- !query 29 schema +struct +-- !query 29 output +1.2345678901234E-200 -1.2345678901234E-199 + 1.2345678901234E200 -1.2345678901234E201 + 1004.3 -10043.0 + + +-- !query 30 +SELECT '' AS three, f.f1, f.f1 + '-10' AS x + FROM FLOAT8_TBL f + WHERE f.f1 > '0.0' +-- !query 30 schema +struct +-- !query 30 output +1.2345678901234E-200 -10.0 + 1.2345678901234E200 1.2345678901234E200 + 1004.3 994.3 + + +-- !query 31 +SELECT '' AS three, f.f1, f.f1 / '-10' AS x + FROM FLOAT8_TBL f + WHERE f.f1 > '0.0' +-- !query 31 schema +struct +-- !query 31 output +1.2345678901234E-200 -1.2345678901234E-201 + 1.2345678901234E200 -1.2345678901234E199 + 1004.3 -100.42999999999999 + + +-- !query 32 +SELECT '' AS three, f.f1, f.f1 - '-10' AS x + FROM FLOAT8_TBL f + WHERE f.f1 > '0.0' +-- !query 32 schema +struct +-- !query 32 output +1.2345678901234E-200 10.0 + 1.2345678901234E200 1.2345678901234E200 + 1004.3 1014.3 + + +-- !query 33 +SELECT '' AS five, f.f1, round(f.f1) AS round_f1 + FROM FLOAT8_TBL f +-- !query 33 schema +struct +-- !query 33 output +-34.84 -35.0 + 0.0 0.0 + 1.2345678901234E-200 0.0 + 1.2345678901234E200 1.2345678901234E200 + 1004.3 1004.0 + + +-- !query 34 +select ceil(f1) as ceil_f1 from float8_tbl f +-- !query 34 schema +struct +-- !query 34 output +-34 +0 +1 +1005 +9223372036854775807 + + +-- !query 35 +select ceiling(f1) as ceiling_f1 from float8_tbl f +-- !query 35 schema +struct +-- !query 35 output +-34 +0 +1 +1005 +9223372036854775807 + + +-- !query 36 +select floor(f1) as floor_f1 from float8_tbl f +-- !query 36 schema +struct +-- !query 36 output +-35 +0 +0 +1004 +9223372036854775807 + + +-- !query 37 +select sign(f1) as sign_f1 from float8_tbl f +-- !query 37 schema +struct +-- !query 37 output +-1.0 +0.0 +1.0 +1.0 +1.0 + + +-- !query 38 +SELECT sqrt(double('64')) AS eight +-- !query 38 schema +struct +-- !query 38 output +8.0 + + +-- !query 39 +SELECT power(double('144'), double('0.5')) +-- !query 39 schema +struct +-- !query 39 output +12.0 + + +-- !query 40 +SELECT power(double('NaN'), double('0.5')) +-- !query 40 schema +struct +-- !query 40 output +NaN + + +-- !query 41 +SELECT power(double('144'), double('NaN')) +-- !query 41 schema +struct +-- !query 41 output +NaN + + +-- !query 42 +SELECT power(double('NaN'), double('NaN')) +-- !query 42 schema +struct +-- !query 42 output +NaN + + +-- !query 43 +SELECT power(double('-1'), double('NaN')) +-- !query 43 schema +struct +-- !query 43 output +NaN + + +-- !query 44 +SELECT power(double('1'), double('NaN')) +-- !query 44 schema +struct +-- !query 44 output +NaN + + +-- !query 45 +SELECT power(double('NaN'), double('0')) +-- !query 45 schema +struct +-- !query 45 output +1.0 + + +-- !query 46 +SELECT '' AS three, f.f1, exp(ln(f.f1)) AS exp_ln_f1 + FROM FLOAT8_TBL f + WHERE f.f1 > '0.0' +-- !query 46 schema +struct +-- !query 46 output +1.2345678901234E-200 1.2345678901233948E-200 + 1.2345678901234E200 1.234567890123379E200 + 1004.3 1004.3000000000004 + + +-- !query 47 +SELECT '' AS five, * FROM FLOAT8_TBL +-- !query 47 schema +struct +-- !query 47 output +-34.84 + 0.0 + 1.2345678901234E-200 + 1.2345678901234E200 + 1004.3 + + +-- !query 48 +CREATE TEMPORARY VIEW UPDATED_FLOAT8_TBL as +SELECT + CASE WHEN FLOAT8_TBL.f1 > '0.0' THEN FLOAT8_TBL.f1 * '-1' ELSE FLOAT8_TBL.f1 END AS f1 +FROM FLOAT8_TBL +-- !query 48 schema +struct<> +-- !query 48 output + + + +-- !query 49 +SELECT '' AS bad, f.f1 * '1e200' from UPDATED_FLOAT8_TBL f +-- !query 49 schema +struct +-- !query 49 output +-1.0042999999999999E203 + -1.2345678901234 + -3.484E201 + -Infinity + 0.0 + + +-- !query 50 +SELECT '' AS five, * FROM UPDATED_FLOAT8_TBL +-- !query 50 schema +struct +-- !query 50 output +-1.2345678901234E-200 + -1.2345678901234E200 + -1004.3 + -34.84 + 0.0 + + +-- !query 51 +TRUNCATE TABLE FLOAT8_TBL +-- !query 51 schema +struct<> +-- !query 51 output + + + +-- !query 52 +INSERT INTO FLOAT8_TBL VALUES ('0.0') +-- !query 52 schema +struct<> +-- !query 52 output + + + +-- !query 53 +INSERT INTO FLOAT8_TBL VALUES ('-34.84') +-- !query 53 schema +struct<> +-- !query 53 output + + + +-- !query 54 +INSERT INTO FLOAT8_TBL VALUES ('-1004.30') +-- !query 54 schema +struct<> +-- !query 54 output + + + +-- !query 55 +INSERT INTO FLOAT8_TBL VALUES ('-1.2345678901234e+200') +-- !query 55 schema +struct<> +-- !query 55 output + + + +-- !query 56 +INSERT INTO FLOAT8_TBL VALUES ('-1.2345678901234e-200') +-- !query 56 schema +struct<> +-- !query 56 output + + + +-- !query 57 +SELECT '' AS five, * FROM FLOAT8_TBL +-- !query 57 schema +struct +-- !query 57 output +-1.2345678901234E-200 + -1.2345678901234E200 + -1004.3 + -34.84 + 0.0 + + +-- !query 58 +SELECT smallint(double('32767.4')) +-- !query 58 schema +struct +-- !query 58 output +32767 + + +-- !query 59 +SELECT smallint(double('32767.6')) +-- !query 59 schema +struct +-- !query 59 output +32767 + + +-- !query 60 +SELECT smallint(double('-32768.4')) +-- !query 60 schema +struct +-- !query 60 output +-32768 + + +-- !query 61 +SELECT smallint(double('-32768.6')) +-- !query 61 schema +struct +-- !query 61 output +-32768 + + +-- !query 62 +SELECT int(double('2147483647.4')) +-- !query 62 schema +struct +-- !query 62 output +2147483647 + + +-- !query 63 +SELECT int(double('2147483647.6')) +-- !query 63 schema +struct +-- !query 63 output +2147483647 + + +-- !query 64 +SELECT int(double('-2147483648.4')) +-- !query 64 schema +struct +-- !query 64 output +-2147483648 + + +-- !query 65 +SELECT int(double('-2147483648.6')) +-- !query 65 schema +struct +-- !query 65 output +-2147483648 + + +-- !query 66 +SELECT bigint(double('9223372036854773760')) +-- !query 66 schema +struct +-- !query 66 output +9223372036854773760 + + +-- !query 67 +SELECT bigint(double('9223372036854775807')) +-- !query 67 schema +struct +-- !query 67 output +9223372036854775807 + + +-- !query 68 +SELECT bigint(double('-9223372036854775808.5')) +-- !query 68 schema +struct +-- !query 68 output +-9223372036854775808 + + +-- !query 69 +SELECT bigint(double('-9223372036854780000')) +-- !query 69 schema +struct +-- !query 69 output +-9223372036854775808 + + +-- !query 70 +DROP TABLE FLOAT8_TBL +-- !query 70 schema +struct<> +-- !query 70 output + From 4b4551fefe1e7d48b7a2181140fe6d0378ba0627 Mon Sep 17 00:00:00 2001 From: Yuming Wang Date: Wed, 10 Jul 2019 14:27:49 +0800 Subject: [PATCH 3/6] REL_12_BETA1 -> REL_12_BETA2 --- sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql index efd506293426f..ebd62b217fa35 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql @@ -3,7 +3,7 @@ -- -- -- FLOAT8 --- https://github.com/postgres/postgres/blob/REL_12_BETA1/src/test/regress/sql/float8.sql +-- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/float8.sql CREATE TABLE FLOAT8_TBL(f1 double) USING parquet; From cd5d6951fe64546bda8f3daeba02b1959cc6c71f Mon Sep 17 00:00:00 2001 From: Yuming Wang Date: Mon, 15 Jul 2019 17:13:27 +0800 Subject: [PATCH 4/6] Merge master since SPARK-28133 --- .../sql-tests/inputs/pgSQL/float8.sql | 18 +- .../sql-tests/results/pgSQL/float8.sql.out | 174 +++++++++++------- 2 files changed, 120 insertions(+), 72 deletions(-) diff --git a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql index ebd62b217fa35..49fd7de68b4fb 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql @@ -48,10 +48,10 @@ SELECT double('N A N'); SELECT double('NaN x'); SELECT double(' INFINITY x'); --- [SPARK-28060] Double type can not accept some special inputs SELECT double('Infinity') + 100.0; +-- [SPARK-27768] Infinity, -Infinity, NaN should be recognized in a case insensitive manner SELECT double('Infinity') / double('Infinity'); -SELECT double('nan') / double('nan'); +SELECT double('NaN') / double('NaN'); SELECT double(decimal('nan')); SELECT '' AS five, * FROM FLOAT8_TBL; @@ -180,16 +180,16 @@ SELECT '' AS bad, f.f1 * '1e200' from UPDATED_FLOAT8_TBL f; SELECT '' AS five, * FROM UPDATED_FLOAT8_TBL; --- [SPARK-28133] Missing hyperbolic functions -- hyperbolic functions -- we run these with extra_float_digits = 0 too, since different platforms -- tend to produce results that vary in the last place. --- SELECT sinh(float8 '1'); --- SELECT cosh(float8 '1'); --- SELECT tanh(float8 '1'); --- SELECT asinh(float8 '1'); --- SELECT acosh(float8 '2'); --- SELECT atanh(float8 '0.5'); +SELECT sinh(double('1')); +SELECT cosh(double('1')); +SELECT tanh(double('1')); +SELECT asinh(double('1')); +SELECT acosh(double('2')); +SELECT atanh(double('0.5')); +-- [SPARK-27768] Infinity, -Infinity, NaN should be recognized in a case insensitive manner -- test Inf/NaN cases for hyperbolic functions -- SELECT sinh(float8 'infinity'); -- SELECT sinh(float8 '-infinity'); diff --git a/sql/core/src/test/resources/sql-tests/results/pgSQL/float8.sql.out b/sql/core/src/test/resources/sql-tests/results/pgSQL/float8.sql.out index da60d13aa7b04..d4dc1ad28a744 100644 --- a/sql/core/src/test/resources/sql-tests/results/pgSQL/float8.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/pgSQL/float8.sql.out @@ -1,5 +1,5 @@ -- Automatically generated by SQLQueryTestSuite --- Number of queries: 71 +-- Number of queries: 77 -- !query 0 @@ -163,11 +163,11 @@ NaN -- !query 20 -SELECT double('nan') / double('nan') +SELECT double('NaN') / double('NaN') -- !query 20 schema -struct<(CAST(nan AS DOUBLE) / CAST(nan AS DOUBLE)):double> +struct<(CAST(NaN AS DOUBLE) / CAST(NaN AS DOUBLE)):double> -- !query 20 output -NULL +NaN -- !query 21 @@ -484,58 +484,106 @@ struct -- !query 51 -TRUNCATE TABLE FLOAT8_TBL +SELECT sinh(double('1')) -- !query 51 schema -struct<> +struct -- !query 51 output - +1.1752011936438014 -- !query 52 -INSERT INTO FLOAT8_TBL VALUES ('0.0') +SELECT cosh(double('1')) -- !query 52 schema -struct<> +struct -- !query 52 output - +1.543080634815244 -- !query 53 -INSERT INTO FLOAT8_TBL VALUES ('-34.84') +SELECT tanh(double('1')) -- !query 53 schema -struct<> +struct -- !query 53 output - +0.7615941559557649 -- !query 54 -INSERT INTO FLOAT8_TBL VALUES ('-1004.30') +SELECT asinh(double('1')) -- !query 54 schema -struct<> +struct -- !query 54 output - +0.8813735870195429 -- !query 55 -INSERT INTO FLOAT8_TBL VALUES ('-1.2345678901234e+200') +SELECT acosh(double('2')) -- !query 55 schema -struct<> +struct -- !query 55 output - +1.3169578969248166 -- !query 56 -INSERT INTO FLOAT8_TBL VALUES ('-1.2345678901234e-200') +SELECT atanh(double('0.5')) -- !query 56 schema -struct<> +struct -- !query 56 output - +0.5493061443340549 -- !query 57 -SELECT '' AS five, * FROM FLOAT8_TBL +TRUNCATE TABLE FLOAT8_TBL -- !query 57 schema -struct +struct<> -- !query 57 output + + + +-- !query 58 +INSERT INTO FLOAT8_TBL VALUES ('0.0') +-- !query 58 schema +struct<> +-- !query 58 output + + + +-- !query 59 +INSERT INTO FLOAT8_TBL VALUES ('-34.84') +-- !query 59 schema +struct<> +-- !query 59 output + + + +-- !query 60 +INSERT INTO FLOAT8_TBL VALUES ('-1004.30') +-- !query 60 schema +struct<> +-- !query 60 output + + + +-- !query 61 +INSERT INTO FLOAT8_TBL VALUES ('-1.2345678901234e+200') +-- !query 61 schema +struct<> +-- !query 61 output + + + +-- !query 62 +INSERT INTO FLOAT8_TBL VALUES ('-1.2345678901234e-200') +-- !query 62 schema +struct<> +-- !query 62 output + + + +-- !query 63 +SELECT '' AS five, * FROM FLOAT8_TBL +-- !query 63 schema +struct +-- !query 63 output -1.2345678901234E-200 -1.2345678901234E200 -1004.3 @@ -543,105 +591,105 @@ struct 0.0 --- !query 58 +-- !query 64 SELECT smallint(double('32767.4')) --- !query 58 schema +-- !query 64 schema struct --- !query 58 output +-- !query 64 output 32767 --- !query 59 +-- !query 65 SELECT smallint(double('32767.6')) --- !query 59 schema +-- !query 65 schema struct --- !query 59 output +-- !query 65 output 32767 --- !query 60 +-- !query 66 SELECT smallint(double('-32768.4')) --- !query 60 schema +-- !query 66 schema struct --- !query 60 output +-- !query 66 output -32768 --- !query 61 +-- !query 67 SELECT smallint(double('-32768.6')) --- !query 61 schema +-- !query 67 schema struct --- !query 61 output +-- !query 67 output -32768 --- !query 62 +-- !query 68 SELECT int(double('2147483647.4')) --- !query 62 schema +-- !query 68 schema struct --- !query 62 output +-- !query 68 output 2147483647 --- !query 63 +-- !query 69 SELECT int(double('2147483647.6')) --- !query 63 schema +-- !query 69 schema struct --- !query 63 output +-- !query 69 output 2147483647 --- !query 64 +-- !query 70 SELECT int(double('-2147483648.4')) --- !query 64 schema +-- !query 70 schema struct --- !query 64 output +-- !query 70 output -2147483648 --- !query 65 +-- !query 71 SELECT int(double('-2147483648.6')) --- !query 65 schema +-- !query 71 schema struct --- !query 65 output +-- !query 71 output -2147483648 --- !query 66 +-- !query 72 SELECT bigint(double('9223372036854773760')) --- !query 66 schema +-- !query 72 schema struct --- !query 66 output +-- !query 72 output 9223372036854773760 --- !query 67 +-- !query 73 SELECT bigint(double('9223372036854775807')) --- !query 67 schema +-- !query 73 schema struct --- !query 67 output +-- !query 73 output 9223372036854775807 --- !query 68 +-- !query 74 SELECT bigint(double('-9223372036854775808.5')) --- !query 68 schema +-- !query 74 schema struct --- !query 68 output +-- !query 74 output -9223372036854775808 --- !query 69 +-- !query 75 SELECT bigint(double('-9223372036854780000')) --- !query 69 schema +-- !query 75 schema struct --- !query 69 output +-- !query 75 output -9223372036854775808 --- !query 70 +-- !query 76 DROP TABLE FLOAT8_TBL --- !query 70 schema +-- !query 76 schema struct<> --- !query 70 output +-- !query 76 output From 532486a8d6a8044974be815b2c29bf27fa29a554 Mon Sep 17 00:00:00 2001 From: Yuming Wang Date: Tue, 16 Jul 2019 09:53:05 +0800 Subject: [PATCH 5/6] float8 'infinity' -> double('Infinity') --- .../sql-tests/inputs/pgSQL/float8.sql | 36 +-- .../sql-tests/results/pgSQL/float8.sql.out | 264 ++++++++++++++---- 2 files changed, 222 insertions(+), 78 deletions(-) diff --git a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql index 49fd7de68b4fb..7c8501aabe969 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql @@ -191,25 +191,25 @@ SELECT acosh(double('2')); SELECT atanh(double('0.5')); -- [SPARK-27768] Infinity, -Infinity, NaN should be recognized in a case insensitive manner -- test Inf/NaN cases for hyperbolic functions --- SELECT sinh(float8 'infinity'); --- SELECT sinh(float8 '-infinity'); --- SELECT sinh(float8 'nan'); --- SELECT cosh(float8 'infinity'); --- SELECT cosh(float8 '-infinity'); --- SELECT cosh(float8 'nan'); --- SELECT tanh(float8 'infinity'); --- SELECT tanh(float8 '-infinity'); --- SELECT tanh(float8 'nan'); --- SELECT asinh(float8 'infinity'); --- SELECT asinh(float8 '-infinity'); --- SELECT asinh(float8 'nan'); +SELECT sinh(double('Infinity')); +SELECT sinh(double('-Infinity')); +SELECT sinh(double('NaN')); +SELECT cosh(double('Infinity')); +SELECT cosh(double('-Infinity')); +SELECT cosh(double('NaN')); +SELECT tanh(double('Infinity')); +SELECT tanh(double('-Infinity')); +SELECT tanh(double('NaN')); +SELECT asinh(double('Infinity')); +SELECT asinh(double('-Infinity')); +SELECT asinh(double('NaN')); -- acosh(Inf) should be Inf, but some mingw versions produce NaN, so skip test --- SELECT acosh(float8 'infinity'); --- SELECT acosh(float8 '-infinity'); --- SELECT acosh(float8 'nan'); --- SELECT atanh(float8 'infinity'); --- SELECT atanh(float8 '-infinity'); --- SELECT atanh(float8 'nan'); +SELECT acosh(double('Infinity')); +SELECT acosh(double('-Infinity')); +SELECT acosh(double('NaN')); +SELECT atanh(double('Infinity')); +SELECT atanh(double('-Infinity')); +SELECT atanh(double('NaN')); -- RESET extra_float_digits; diff --git a/sql/core/src/test/resources/sql-tests/results/pgSQL/float8.sql.out b/sql/core/src/test/resources/sql-tests/results/pgSQL/float8.sql.out index d4dc1ad28a744..3e3f24d603ff0 100644 --- a/sql/core/src/test/resources/sql-tests/results/pgSQL/float8.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/pgSQL/float8.sql.out @@ -1,5 +1,5 @@ -- Automatically generated by SQLQueryTestSuite --- Number of queries: 77 +-- Number of queries: 95 -- !query 0 @@ -532,58 +532,202 @@ struct -- !query 57 -TRUNCATE TABLE FLOAT8_TBL +SELECT sinh(double('Infinity')) -- !query 57 schema -struct<> +struct -- !query 57 output - +Infinity -- !query 58 -INSERT INTO FLOAT8_TBL VALUES ('0.0') +SELECT sinh(double('-Infinity')) -- !query 58 schema -struct<> +struct -- !query 58 output - +-Infinity -- !query 59 -INSERT INTO FLOAT8_TBL VALUES ('-34.84') +SELECT sinh(double('NaN')) -- !query 59 schema -struct<> +struct -- !query 59 output - +NaN -- !query 60 -INSERT INTO FLOAT8_TBL VALUES ('-1004.30') +SELECT cosh(double('Infinity')) -- !query 60 schema -struct<> +struct -- !query 60 output - +Infinity -- !query 61 -INSERT INTO FLOAT8_TBL VALUES ('-1.2345678901234e+200') +SELECT cosh(double('-Infinity')) -- !query 61 schema -struct<> +struct -- !query 61 output - +Infinity -- !query 62 -INSERT INTO FLOAT8_TBL VALUES ('-1.2345678901234e-200') +SELECT cosh(double('NaN')) -- !query 62 schema -struct<> +struct -- !query 62 output - +NaN -- !query 63 -SELECT '' AS five, * FROM FLOAT8_TBL +SELECT tanh(double('Infinity')) -- !query 63 schema -struct +struct -- !query 63 output +1.0 + + +-- !query 64 +SELECT tanh(double('-Infinity')) +-- !query 64 schema +struct +-- !query 64 output +-1.0 + + +-- !query 65 +SELECT tanh(double('NaN')) +-- !query 65 schema +struct +-- !query 65 output +NaN + + +-- !query 66 +SELECT asinh(double('Infinity')) +-- !query 66 schema +struct +-- !query 66 output +Infinity + + +-- !query 67 +SELECT asinh(double('-Infinity')) +-- !query 67 schema +struct +-- !query 67 output +-Infinity + + +-- !query 68 +SELECT asinh(double('NaN')) +-- !query 68 schema +struct +-- !query 68 output +NaN + + +-- !query 69 +SELECT acosh(double('Infinity')) +-- !query 69 schema +struct +-- !query 69 output +Infinity + + +-- !query 70 +SELECT acosh(double('-Infinity')) +-- !query 70 schema +struct +-- !query 70 output +NaN + + +-- !query 71 +SELECT acosh(double('NaN')) +-- !query 71 schema +struct +-- !query 71 output +NaN + + +-- !query 72 +SELECT atanh(double('Infinity')) +-- !query 72 schema +struct +-- !query 72 output +NaN + + +-- !query 73 +SELECT atanh(double('-Infinity')) +-- !query 73 schema +struct +-- !query 73 output +NaN + + +-- !query 74 +SELECT atanh(double('NaN')) +-- !query 74 schema +struct +-- !query 74 output +NaN + + +-- !query 75 +TRUNCATE TABLE FLOAT8_TBL +-- !query 75 schema +struct<> +-- !query 75 output + + + +-- !query 76 +INSERT INTO FLOAT8_TBL VALUES ('0.0') +-- !query 76 schema +struct<> +-- !query 76 output + + + +-- !query 77 +INSERT INTO FLOAT8_TBL VALUES ('-34.84') +-- !query 77 schema +struct<> +-- !query 77 output + + + +-- !query 78 +INSERT INTO FLOAT8_TBL VALUES ('-1004.30') +-- !query 78 schema +struct<> +-- !query 78 output + + + +-- !query 79 +INSERT INTO FLOAT8_TBL VALUES ('-1.2345678901234e+200') +-- !query 79 schema +struct<> +-- !query 79 output + + + +-- !query 80 +INSERT INTO FLOAT8_TBL VALUES ('-1.2345678901234e-200') +-- !query 80 schema +struct<> +-- !query 80 output + + + +-- !query 81 +SELECT '' AS five, * FROM FLOAT8_TBL +-- !query 81 schema +struct +-- !query 81 output -1.2345678901234E-200 -1.2345678901234E200 -1004.3 @@ -591,105 +735,105 @@ struct 0.0 --- !query 64 +-- !query 82 SELECT smallint(double('32767.4')) --- !query 64 schema +-- !query 82 schema struct --- !query 64 output +-- !query 82 output 32767 --- !query 65 +-- !query 83 SELECT smallint(double('32767.6')) --- !query 65 schema +-- !query 83 schema struct --- !query 65 output +-- !query 83 output 32767 --- !query 66 +-- !query 84 SELECT smallint(double('-32768.4')) --- !query 66 schema +-- !query 84 schema struct --- !query 66 output +-- !query 84 output -32768 --- !query 67 +-- !query 85 SELECT smallint(double('-32768.6')) --- !query 67 schema +-- !query 85 schema struct --- !query 67 output +-- !query 85 output -32768 --- !query 68 +-- !query 86 SELECT int(double('2147483647.4')) --- !query 68 schema +-- !query 86 schema struct --- !query 68 output +-- !query 86 output 2147483647 --- !query 69 +-- !query 87 SELECT int(double('2147483647.6')) --- !query 69 schema +-- !query 87 schema struct --- !query 69 output +-- !query 87 output 2147483647 --- !query 70 +-- !query 88 SELECT int(double('-2147483648.4')) --- !query 70 schema +-- !query 88 schema struct --- !query 70 output +-- !query 88 output -2147483648 --- !query 71 +-- !query 89 SELECT int(double('-2147483648.6')) --- !query 71 schema +-- !query 89 schema struct --- !query 71 output +-- !query 89 output -2147483648 --- !query 72 +-- !query 90 SELECT bigint(double('9223372036854773760')) --- !query 72 schema +-- !query 90 schema struct --- !query 72 output +-- !query 90 output 9223372036854773760 --- !query 73 +-- !query 91 SELECT bigint(double('9223372036854775807')) --- !query 73 schema +-- !query 91 schema struct --- !query 73 output +-- !query 91 output 9223372036854775807 --- !query 74 +-- !query 92 SELECT bigint(double('-9223372036854775808.5')) --- !query 74 schema +-- !query 92 schema struct --- !query 74 output +-- !query 92 output -9223372036854775808 --- !query 75 +-- !query 93 SELECT bigint(double('-9223372036854780000')) --- !query 75 schema +-- !query 93 schema struct --- !query 75 output +-- !query 93 output -9223372036854775808 --- !query 76 +-- !query 94 DROP TABLE FLOAT8_TBL --- !query 76 schema +-- !query 94 schema struct<> --- !query 76 output +-- !query 94 output From f49cf432392118137a16fe5619b55dfa0520262c Mon Sep 17 00:00:00 2001 From: Yuming Wang Date: Tue, 16 Jul 2019 13:03:12 +0800 Subject: [PATCH 6/6] Add SPARK-28315 --- sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql | 1 + 1 file changed, 1 insertion(+) diff --git a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql index 7c8501aabe969..6f8e3b596e60e 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql @@ -52,6 +52,7 @@ SELECT double('Infinity') + 100.0; -- [SPARK-27768] Infinity, -Infinity, NaN should be recognized in a case insensitive manner SELECT double('Infinity') / double('Infinity'); SELECT double('NaN') / double('NaN'); +-- [SPARK-28315] Decimal can not accept NaN as input SELECT double(decimal('nan')); SELECT '' AS five, * FROM FLOAT8_TBL;