This is an automated email from the ASF dual-hosted git repository.
gurwls223 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/spark.git
The following commit(s) were added to refs/heads/master by this push:
new f74ad3d [SPARK-28129][SQL][TEST] Port float8.sql
f74ad3d is described below
commit f74ad3d7004e833b6dbc07d6281407ab89ef2d32
Author: Yuming Wang <yumw...@ebay.com>
AuthorDate: Tue Jul 16 19:31:20 2019 +0900
[SPARK-28129][SQL][TEST] Port float8.sql
## What changes were proposed in this pull request?
This PR is to port float8.sql from PostgreSQL regression tests.
https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/float8.sql
The expected results can be found in the link:
https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/expected/float8.out
When porting the test cases, found six PostgreSQL specific features that do
not exist in Spark SQL:
[SPARK-28060](https://issues.apache.org/jira/browse/SPARK-28060): Double
type can not accept some special inputs
[SPARK-28027](https://issues.apache.org/jira/browse/SPARK-28027): Spark SQL
does not support prefix operator `` and `|/`
[SPARK-28061](https://issues.apache.org/jira/browse/SPARK-28061): Support
for converting float to binary format
[SPARK-23906](https://issues.apache.org/jira/browse/SPARK-23906): Support
Truncate number
[SPARK-28134](https://issues.apache.org/jira/browse/SPARK-28134): Missing
Trigonometric Functions
Also, found two bug:
[SPARK-28024](https://issues.apache.org/jira/browse/SPARK-28024): Incorrect
value when out of range
[SPARK-28135](https://issues.apache.org/jira/browse/SPARK-28135):
ceil/ceiling/floor/power returns incorrect values
Also, found four inconsistent behavior:
[SPARK-27923](https://issues.apache.org/jira/browse/SPARK-27923): Spark SQL
insert bad inputs to NULL
[SPARK-28028](https://issues.apache.org/jira/browse/SPARK-28028): Cast
numeric to integral type need round
[SPARK-27923](https://issues.apache.org/jira/browse/SPARK-27923): Spark SQL
returns NULL when dividing by zero
[SPARK-28007](https://issues.apache.org/jira/browse/SPARK-28007): Caret
operator (^) means bitwise XOR in Spark/Hive and exponentiation in Postgres
## How was this patch tested?
N/A
Closes #24931 from wangyum/SPARK-28129.
Authored-by: Yuming Wang <yumw...@ebay.com>
Signed-off-by: HyukjinKwon <gurwls...@apache.org>
---
.../resources/sql-tests/inputs/pgSQL/float8.sql | 500 ++++++++++++
.../sql-tests/results/pgSQL/float8.sql.out | 839 +++++++++++++++++++++
2 files changed, 1339 insertions(+)
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 0000000..6f8e3b5
--- /dev/null
+++ b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/float8.sql
@@ -0,0 +1,500 @@
+--
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+--
+-- FLOAT8
+--
https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/float8.sql
+
+CREATE TABLE FLOAT8_TBL(f1 double) USING parquet;
+
+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 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);
+
+-- [SPARK-27923] Spark SQL insert there bad inputs to NULL
+-- bad input
+-- 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 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 double('N A N');
+SELECT double('NaN x');
+SELECT double(' INFINITY x');
+
+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;
+
+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';
+-- [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';
+
+-- [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;
+
+-- [SPARK-23906] Support Truncate number
+-- 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;
+
+-- [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;
+
+-- 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(double('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';
+
+-- power
+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 '' 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 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;
+
+-- [SPARK-27923] Out of range, Spark SQL returns Infinity
+SELECT '' AS bad, f.f1 * '1e200' from UPDATED_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;
+
+-- [SPARK-27923] Cannot take logarithm of zero
+-- SELECT '' AS bad, ln(f.f1) from UPDATED_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' ;
+
+-- [SPARK-28024] Incorrect numeric values when out of range
+-- SELECT '' AS bad, exp(f.f1) from UPDATED_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 UPDATED_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(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(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(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;
+
+-- [SPARK-28024] Incorrect numeric values when out of range
+-- test for over- and underflow
+-- INSERT INTO FLOAT8_TBL VALUES ('10e400');
+
+-- INSERT INTO FLOAT8_TBL VALUES ('-10e400');
+
+-- INSERT INTO FLOAT8_TBL VALUES ('10e-400');
+
+-- INSERT INTO FLOAT8_TBL VALUES ('-10e-400');
+
+-- maintain external table consistency across platforms
+-- delete all values and reinsert well-behaved ones
+
+TRUNCATE TABLE FLOAT8_TBL;
+
+INSERT INTO FLOAT8_TBL VALUES ('0.0');
+
+INSERT INTO FLOAT8_TBL VALUES ('-34.84');
+
+INSERT INTO FLOAT8_TBL VALUES ('-1004.30');
+
+INSERT INTO FLOAT8_TBL 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 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);
+
+-- 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;
+
+-- 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;
+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 0000000..3e3f24d
--- /dev/null
+++ b/sql/core/src/test/resources/sql-tests/results/pgSQL/float8.sql.out
@@ -0,0 +1,839 @@
+-- Automatically generated by SQLQueryTestSuite
+-- Number of queries: 95
+
+
+-- !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<CAST(10e400 AS DOUBLE):double>
+-- !query 6 output
+Infinity
+
+
+-- !query 7
+SELECT double('-10e400')
+-- !query 7 schema
+struct<CAST(-10e400 AS DOUBLE):double>
+-- !query 7 output
+-Infinity
+
+
+-- !query 8
+SELECT double('10e-400')
+-- !query 8 schema
+struct<CAST(10e-400 AS DOUBLE):double>
+-- !query 8 output
+0.0
+
+
+-- !query 9
+SELECT double('-10e-400')
+-- !query 9 schema
+struct<CAST(-10e-400 AS DOUBLE):double>
+-- !query 9 output
+-0.0
+
+
+-- !query 10
+SELECT double('NaN')
+-- !query 10 schema
+struct<CAST(NaN AS DOUBLE):double>
+-- !query 10 output
+NaN
+
+
+-- !query 11
+SELECT double('nan')
+-- !query 11 schema
+struct<CAST(nan AS DOUBLE):double>
+-- !query 11 output
+NULL
+
+
+-- !query 12
+SELECT double(' NAN ')
+-- !query 12 schema
+struct<CAST( NAN AS DOUBLE):double>
+-- !query 12 output
+NULL
+
+
+-- !query 13
+SELECT double('infinity')
+-- !query 13 schema
+struct<CAST(infinity AS DOUBLE):double>
+-- !query 13 output
+NULL
+
+
+-- !query 14
+SELECT double(' -INFINiTY ')
+-- !query 14 schema
+struct<CAST( -INFINiTY AS DOUBLE):double>
+-- !query 14 output
+NULL
+
+
+-- !query 15
+SELECT double('N A N')
+-- !query 15 schema
+struct<CAST(N A N AS DOUBLE):double>
+-- !query 15 output
+NULL
+
+
+-- !query 16
+SELECT double('NaN x')
+-- !query 16 schema
+struct<CAST(NaN x AS DOUBLE):double>
+-- !query 16 output
+NULL
+
+
+-- !query 17
+SELECT double(' INFINITY x')
+-- !query 17 schema
+struct<CAST( INFINITY x AS DOUBLE):double>
+-- !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
+NaN
+
+
+-- !query 21
+SELECT double(decimal('nan'))
+-- !query 21 schema
+struct<CAST(CAST(nan AS DECIMAL(10,0)) AS DOUBLE):double>
+-- !query 21 output
+NULL
+
+
+-- !query 22
+SELECT '' AS five, * FROM FLOAT8_TBL
+-- !query 22 schema
+struct<five:string,f1:double>
+-- !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<four:string,f1:double>
+-- !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<one:string,f1:double>
+-- !query 24 output
+1004.3
+
+
+-- !query 25
+SELECT '' AS three, f.* FROM FLOAT8_TBL f WHERE '1004.3' > f.f1
+-- !query 25 schema
+struct<three:string,f1:double>
+-- !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<three:string,f1:double>
+-- !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<four:string,f1:double>
+-- !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<four:string,f1:double>
+-- !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<three:string,f1:double,x:double>
+-- !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<three:string,f1:double,x:double>
+-- !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<three:string,f1:double,x:double>
+-- !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<three:string,f1:double,x:double>
+-- !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<five:string,f1:double,round_f1:double>
+-- !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<ceil_f1:bigint>
+-- !query 34 output
+-34
+0
+1
+1005
+9223372036854775807
+
+
+-- !query 35
+select ceiling(f1) as ceiling_f1 from float8_tbl f
+-- !query 35 schema
+struct<ceiling_f1:bigint>
+-- !query 35 output
+-34
+0
+1
+1005
+9223372036854775807
+
+
+-- !query 36
+select floor(f1) as floor_f1 from float8_tbl f
+-- !query 36 schema
+struct<floor_f1:bigint>
+-- !query 36 output
+-35
+0
+0
+1004
+9223372036854775807
+
+
+-- !query 37
+select sign(f1) as sign_f1 from float8_tbl f
+-- !query 37 schema
+struct<sign_f1:double>
+-- !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<eight:double>
+-- !query 38 output
+8.0
+
+
+-- !query 39
+SELECT power(double('144'), double('0.5'))
+-- !query 39 schema
+struct<POWER(CAST(144 AS DOUBLE), CAST(0.5 AS DOUBLE)):double>
+-- !query 39 output
+12.0
+
+
+-- !query 40
+SELECT power(double('NaN'), double('0.5'))
+-- !query 40 schema
+struct<POWER(CAST(NaN AS DOUBLE), CAST(0.5 AS DOUBLE)):double>
+-- !query 40 output
+NaN
+
+
+-- !query 41
+SELECT power(double('144'), double('NaN'))
+-- !query 41 schema
+struct<POWER(CAST(144 AS DOUBLE), CAST(NaN AS DOUBLE)):double>
+-- !query 41 output
+NaN
+
+
+-- !query 42
+SELECT power(double('NaN'), double('NaN'))
+-- !query 42 schema
+struct<POWER(CAST(NaN AS DOUBLE), CAST(NaN AS DOUBLE)):double>
+-- !query 42 output
+NaN
+
+
+-- !query 43
+SELECT power(double('-1'), double('NaN'))
+-- !query 43 schema
+struct<POWER(CAST(-1 AS DOUBLE), CAST(NaN AS DOUBLE)):double>
+-- !query 43 output
+NaN
+
+
+-- !query 44
+SELECT power(double('1'), double('NaN'))
+-- !query 44 schema
+struct<POWER(CAST(1 AS DOUBLE), CAST(NaN AS DOUBLE)):double>
+-- !query 44 output
+NaN
+
+
+-- !query 45
+SELECT power(double('NaN'), double('0'))
+-- !query 45 schema
+struct<POWER(CAST(NaN AS DOUBLE), CAST(0 AS DOUBLE)):double>
+-- !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<three:string,f1:double,exp_ln_f1:double>
+-- !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<five:string,f1:double>
+-- !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<bad:string,(f1 * CAST(1e200 AS DOUBLE)):double>
+-- !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<five:string,f1:double>
+-- !query 50 output
+-1.2345678901234E-200
+ -1.2345678901234E200
+ -1004.3
+ -34.84
+ 0.0
+
+
+-- !query 51
+SELECT sinh(double('1'))
+-- !query 51 schema
+struct<SINH(CAST(1 AS DOUBLE)):double>
+-- !query 51 output
+1.1752011936438014
+
+
+-- !query 52
+SELECT cosh(double('1'))
+-- !query 52 schema
+struct<COSH(CAST(1 AS DOUBLE)):double>
+-- !query 52 output
+1.543080634815244
+
+
+-- !query 53
+SELECT tanh(double('1'))
+-- !query 53 schema
+struct<TANH(CAST(1 AS DOUBLE)):double>
+-- !query 53 output
+0.7615941559557649
+
+
+-- !query 54
+SELECT asinh(double('1'))
+-- !query 54 schema
+struct<ASINH(CAST(1 AS DOUBLE)):double>
+-- !query 54 output
+0.8813735870195429
+
+
+-- !query 55
+SELECT acosh(double('2'))
+-- !query 55 schema
+struct<ACOSH(CAST(2 AS DOUBLE)):double>
+-- !query 55 output
+1.3169578969248166
+
+
+-- !query 56
+SELECT atanh(double('0.5'))
+-- !query 56 schema
+struct<ATANH(CAST(0.5 AS DOUBLE)):double>
+-- !query 56 output
+0.5493061443340549
+
+
+-- !query 57
+SELECT sinh(double('Infinity'))
+-- !query 57 schema
+struct<SINH(CAST(Infinity AS DOUBLE)):double>
+-- !query 57 output
+Infinity
+
+
+-- !query 58
+SELECT sinh(double('-Infinity'))
+-- !query 58 schema
+struct<SINH(CAST(-Infinity AS DOUBLE)):double>
+-- !query 58 output
+-Infinity
+
+
+-- !query 59
+SELECT sinh(double('NaN'))
+-- !query 59 schema
+struct<SINH(CAST(NaN AS DOUBLE)):double>
+-- !query 59 output
+NaN
+
+
+-- !query 60
+SELECT cosh(double('Infinity'))
+-- !query 60 schema
+struct<COSH(CAST(Infinity AS DOUBLE)):double>
+-- !query 60 output
+Infinity
+
+
+-- !query 61
+SELECT cosh(double('-Infinity'))
+-- !query 61 schema
+struct<COSH(CAST(-Infinity AS DOUBLE)):double>
+-- !query 61 output
+Infinity
+
+
+-- !query 62
+SELECT cosh(double('NaN'))
+-- !query 62 schema
+struct<COSH(CAST(NaN AS DOUBLE)):double>
+-- !query 62 output
+NaN
+
+
+-- !query 63
+SELECT tanh(double('Infinity'))
+-- !query 63 schema
+struct<TANH(CAST(Infinity AS DOUBLE)):double>
+-- !query 63 output
+1.0
+
+
+-- !query 64
+SELECT tanh(double('-Infinity'))
+-- !query 64 schema
+struct<TANH(CAST(-Infinity AS DOUBLE)):double>
+-- !query 64 output
+-1.0
+
+
+-- !query 65
+SELECT tanh(double('NaN'))
+-- !query 65 schema
+struct<TANH(CAST(NaN AS DOUBLE)):double>
+-- !query 65 output
+NaN
+
+
+-- !query 66
+SELECT asinh(double('Infinity'))
+-- !query 66 schema
+struct<ASINH(CAST(Infinity AS DOUBLE)):double>
+-- !query 66 output
+Infinity
+
+
+-- !query 67
+SELECT asinh(double('-Infinity'))
+-- !query 67 schema
+struct<ASINH(CAST(-Infinity AS DOUBLE)):double>
+-- !query 67 output
+-Infinity
+
+
+-- !query 68
+SELECT asinh(double('NaN'))
+-- !query 68 schema
+struct<ASINH(CAST(NaN AS DOUBLE)):double>
+-- !query 68 output
+NaN
+
+
+-- !query 69
+SELECT acosh(double('Infinity'))
+-- !query 69 schema
+struct<ACOSH(CAST(Infinity AS DOUBLE)):double>
+-- !query 69 output
+Infinity
+
+
+-- !query 70
+SELECT acosh(double('-Infinity'))
+-- !query 70 schema
+struct<ACOSH(CAST(-Infinity AS DOUBLE)):double>
+-- !query 70 output
+NaN
+
+
+-- !query 71
+SELECT acosh(double('NaN'))
+-- !query 71 schema
+struct<ACOSH(CAST(NaN AS DOUBLE)):double>
+-- !query 71 output
+NaN
+
+
+-- !query 72
+SELECT atanh(double('Infinity'))
+-- !query 72 schema
+struct<ATANH(CAST(Infinity AS DOUBLE)):double>
+-- !query 72 output
+NaN
+
+
+-- !query 73
+SELECT atanh(double('-Infinity'))
+-- !query 73 schema
+struct<ATANH(CAST(-Infinity AS DOUBLE)):double>
+-- !query 73 output
+NaN
+
+
+-- !query 74
+SELECT atanh(double('NaN'))
+-- !query 74 schema
+struct<ATANH(CAST(NaN AS DOUBLE)):double>
+-- !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<five:string,f1:double>
+-- !query 81 output
+-1.2345678901234E-200
+ -1.2345678901234E200
+ -1004.3
+ -34.84
+ 0.0
+
+
+-- !query 82
+SELECT smallint(double('32767.4'))
+-- !query 82 schema
+struct<CAST(CAST(32767.4 AS DOUBLE) AS SMALLINT):smallint>
+-- !query 82 output
+32767
+
+
+-- !query 83
+SELECT smallint(double('32767.6'))
+-- !query 83 schema
+struct<CAST(CAST(32767.6 AS DOUBLE) AS SMALLINT):smallint>
+-- !query 83 output
+32767
+
+
+-- !query 84
+SELECT smallint(double('-32768.4'))
+-- !query 84 schema
+struct<CAST(CAST(-32768.4 AS DOUBLE) AS SMALLINT):smallint>
+-- !query 84 output
+-32768
+
+
+-- !query 85
+SELECT smallint(double('-32768.6'))
+-- !query 85 schema
+struct<CAST(CAST(-32768.6 AS DOUBLE) AS SMALLINT):smallint>
+-- !query 85 output
+-32768
+
+
+-- !query 86
+SELECT int(double('2147483647.4'))
+-- !query 86 schema
+struct<CAST(CAST(2147483647.4 AS DOUBLE) AS INT):int>
+-- !query 86 output
+2147483647
+
+
+-- !query 87
+SELECT int(double('2147483647.6'))
+-- !query 87 schema
+struct<CAST(CAST(2147483647.6 AS DOUBLE) AS INT):int>
+-- !query 87 output
+2147483647
+
+
+-- !query 88
+SELECT int(double('-2147483648.4'))
+-- !query 88 schema
+struct<CAST(CAST(-2147483648.4 AS DOUBLE) AS INT):int>
+-- !query 88 output
+-2147483648
+
+
+-- !query 89
+SELECT int(double('-2147483648.6'))
+-- !query 89 schema
+struct<CAST(CAST(-2147483648.6 AS DOUBLE) AS INT):int>
+-- !query 89 output
+-2147483648
+
+
+-- !query 90
+SELECT bigint(double('9223372036854773760'))
+-- !query 90 schema
+struct<CAST(CAST(9223372036854773760 AS DOUBLE) AS BIGINT):bigint>
+-- !query 90 output
+9223372036854773760
+
+
+-- !query 91
+SELECT bigint(double('9223372036854775807'))
+-- !query 91 schema
+struct<CAST(CAST(9223372036854775807 AS DOUBLE) AS BIGINT):bigint>
+-- !query 91 output
+9223372036854775807
+
+
+-- !query 92
+SELECT bigint(double('-9223372036854775808.5'))
+-- !query 92 schema
+struct<CAST(CAST(-9223372036854775808.5 AS DOUBLE) AS BIGINT):bigint>
+-- !query 92 output
+-9223372036854775808
+
+
+-- !query 93
+SELECT bigint(double('-9223372036854780000'))
+-- !query 93 schema
+struct<CAST(CAST(-9223372036854780000 AS DOUBLE) AS BIGINT):bigint>
+-- !query 93 output
+-9223372036854775808
+
+
+-- !query 94
+DROP TABLE FLOAT8_TBL
+-- !query 94 schema
+struct<>
+-- !query 94 output
+
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@spark.apache.org
For additional commands, e-mail: commits-h...@spark.apache.org
