Merge pull request #11788 from ydb-platform/mergelibs-241120-1113

Library import 241120-1113

1 files changed, 1188 insertions, 0 deletions

diff --git a/yql/essentials/tests/postgresql/cases/float8.err b/yql/essentials/tests/postgresql/cases/float8.err
new file mode 100644
index 0000000000..ca1be732fc
--- /dev/null
+++ b/yql/essentials/tests/postgresql/cases/float8.err
@@ -0,0 +1,1188 @@
+<sql-statement>
+--
+-- FLOAT8
+--
+CREATE TABLE FLOAT8_TBL(f1 float8);
+</sql-statement>
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('    0.0   ');
+</sql-statement>
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('1004.30  ');
+</sql-statement>
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('   -34.84');
+</sql-statement>
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('1.2345678901234e+200');
+</sql-statement>
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('1.2345678901234e-200');
+</sql-statement>
+<sql-statement>
+-- test for underflow and overflow handling
+SELECT '10e400'::float8;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	-- test for underflow and overflow handling
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  "10e400" is out of range for type double precision
+
+        	-- test for underflow and overflow handling
+	^
+<sql-statement>
+SELECT '-10e400'::float8;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT '-10e400'::float8;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  "-10e400" is out of range for type double precision
+
+        	SELECT '-10e400'::float8;
+	^
+<sql-statement>
+SELECT '10e-400'::float8;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT '10e-400'::float8;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  "10e-400" is out of range for type double precision
+
+        	SELECT '10e-400'::float8;
+	^
+<sql-statement>
+SELECT '-10e-400'::float8;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT '-10e-400'::float8;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  "-10e-400" is out of range for type double precision
+
+        	SELECT '-10e-400'::float8;
+	^
+<sql-statement>
+-- test smallest normalized input
+SELECT float8send('2.2250738585072014E-308'::float8);
+</sql-statement>
+<sql-statement>
+-- bad input
+INSERT INTO FLOAT8_TBL(f1) VALUES ('');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtFill!
+    	-- bad input
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  invalid input syntax for type double precision: ""
+
+        	-- bad input
+	^
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('     ');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtFill!
+    	INSERT INTO FLOAT8_TBL(f1) VALUES ('     ');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  invalid input syntax for type double precision: "     "
+
+        	INSERT INTO FLOAT8_TBL(f1) VALUES ('     ');
+	^
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('xyz');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtFill!
+    	INSERT INTO FLOAT8_TBL(f1) VALUES ('xyz');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  invalid input syntax for type double precision: "xyz"
+
+        	INSERT INTO FLOAT8_TBL(f1) VALUES ('xyz');
+	^
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('5.0.0');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtFill!
+    	INSERT INTO FLOAT8_TBL(f1) VALUES ('5.0.0');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  invalid input syntax for type double precision: "5.0.0"
+
+        	INSERT INTO FLOAT8_TBL(f1) VALUES ('5.0.0');
+	^
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('5 . 0');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtFill!
+    	INSERT INTO FLOAT8_TBL(f1) VALUES ('5 . 0');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  invalid input syntax for type double precision: "5 . 0"
+
+        	INSERT INTO FLOAT8_TBL(f1) VALUES ('5 . 0');
+	^
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('5.   0');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtFill!
+    	INSERT INTO FLOAT8_TBL(f1) VALUES ('5.   0');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  invalid input syntax for type double precision: "5.   0"
+
+        	INSERT INTO FLOAT8_TBL(f1) VALUES ('5.   0');
+	^
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('    - 3');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtFill!
+    	INSERT INTO FLOAT8_TBL(f1) VALUES ('    - 3');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  invalid input syntax for type double precision: "    - 3"
+
+        	INSERT INTO FLOAT8_TBL(f1) VALUES ('    - 3');
+	^
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('123           5');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtFill!
+    	INSERT INTO FLOAT8_TBL(f1) VALUES ('123           5');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  invalid input syntax for type double precision: "123           5"
+
+        	INSERT INTO FLOAT8_TBL(f1) VALUES ('123           5');
+	^
+<sql-statement>
+-- special inputs
+SELECT 'NaN'::float8;
+</sql-statement>
+<sql-statement>
+SELECT 'nan'::float8;
+</sql-statement>
+<sql-statement>
+SELECT '   NAN  '::float8;
+</sql-statement>
+<sql-statement>
+SELECT 'infinity'::float8;
+</sql-statement>
+<sql-statement>
+SELECT '          -INFINiTY   '::float8;
+</sql-statement>
+<sql-statement>
+-- bad special inputs
+SELECT 'N A N'::float8;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	-- bad special inputs
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  invalid input syntax for type double precision: "N A N"
+
+        	-- bad special inputs
+	^
+<sql-statement>
+SELECT 'NaN x'::float8;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT 'NaN x'::float8;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  invalid input syntax for type double precision: "NaN x"
+
+        	SELECT 'NaN x'::float8;
+	^
+<sql-statement>
+SELECT ' INFINITY    x'::float8;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT ' INFINITY    x'::float8;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  invalid input syntax for type double precision: " INFINITY    x"
+
+        	SELECT ' INFINITY    x'::float8;
+	^
+<sql-statement>
+SELECT 'Infinity'::float8 + 100.0;
+</sql-statement>
+<sql-statement>
+SELECT 'Infinity'::float8 / 'Infinity'::float8;
+</sql-statement>
+<sql-statement>
+SELECT '42'::float8 / 'Infinity'::float8;
+</sql-statement>
+<sql-statement>
+SELECT 'nan'::float8 / 'nan'::float8;
+</sql-statement>
+<sql-statement>
+SELECT 'nan'::float8 / '0'::float8;
+</sql-statement>
+<sql-statement>
+SELECT 'nan'::numeric::float8;
+</sql-statement>
+<sql-statement>
+SELECT * FROM FLOAT8_TBL;
+</sql-statement>
+<sql-statement>
+SELECT f.* FROM FLOAT8_TBL f WHERE f.f1 <> '1004.3';
+</sql-statement>
+<sql-statement>
+SELECT f.* FROM FLOAT8_TBL f WHERE f.f1 = '1004.3';
+</sql-statement>
+<sql-statement>
+SELECT f.* FROM FLOAT8_TBL f WHERE '1004.3' > f.f1;
+</sql-statement>
+<sql-statement>
+SELECT f.* FROM FLOAT8_TBL f WHERE  f.f1 < '1004.3';
+</sql-statement>
+<sql-statement>
+SELECT f.* FROM FLOAT8_TBL f WHERE '1004.3' >= f.f1;
+</sql-statement>
+<sql-statement>
+SELECT f.* FROM FLOAT8_TBL f WHERE  f.f1 <= '1004.3';
+</sql-statement>
+<sql-statement>
+SELECT f.f1, f.f1 * '-10' AS x
+   FROM FLOAT8_TBL f
+   WHERE f.f1 > '0.0';
+</sql-statement>
+<sql-statement>
+SELECT f.f1, f.f1 + '-10' AS x
+   FROM FLOAT8_TBL f
+   WHERE f.f1 > '0.0';
+</sql-statement>
+<sql-statement>
+SELECT f.f1, f.f1 / '-10' AS x
+   FROM FLOAT8_TBL f
+   WHERE f.f1 > '0.0';
+</sql-statement>
+<sql-statement>
+SELECT f.f1, f.f1 - '-10' AS x
+   FROM FLOAT8_TBL f
+   WHERE f.f1 > '0.0';
+</sql-statement>
+<sql-statement>
+SELECT f.f1 ^ '2.0' AS square_f1
+   FROM FLOAT8_TBL f where f.f1 = '1004.3';
+</sql-statement>
+<sql-statement>
+-- absolute value
+SELECT f.f1, @f.f1 AS abs_f1
+   FROM FLOAT8_TBL f;
+</sql-statement>
+<sql-statement>
+-- truncate
+SELECT f.f1, trunc(f.f1) AS trunc_f1
+   FROM FLOAT8_TBL f;
+</sql-statement>
+<sql-statement>
+-- round
+SELECT f.f1, round(f.f1) AS round_f1
+   FROM FLOAT8_TBL f;
+</sql-statement>
+<sql-statement>
+-- ceil / ceiling
+select ceil(f1) as ceil_f1 from float8_tbl f;
+</sql-statement>
+-stdin-:<main>: Fatal: Table metadata loading
+
+    -stdin-:<main>: Fatal: ydb/library/yql/providers/yt/gateway/file/yql_yt_file_services.cpp:44: Table not found: plato.float8_tbl
+    
+<sql-statement>
+select ceiling(f1) as ceiling_f1 from float8_tbl f;
+</sql-statement>
+-stdin-:<main>: Fatal: Table metadata loading
+
+    -stdin-:<main>: Fatal: ydb/library/yql/providers/yt/gateway/file/yql_yt_file_services.cpp:44: Table not found: plato.float8_tbl
+    
+<sql-statement>
+-- floor
+select floor(f1) as floor_f1 from float8_tbl f;
+</sql-statement>
+-stdin-:<main>: Fatal: Table metadata loading
+
+    -stdin-:<main>: Fatal: ydb/library/yql/providers/yt/gateway/file/yql_yt_file_services.cpp:44: Table not found: plato.float8_tbl
+    
+<sql-statement>
+-- sign
+select sign(f1) as sign_f1 from float8_tbl f;
+</sql-statement>
+-stdin-:<main>: Fatal: Table metadata loading
+
+    -stdin-:<main>: Fatal: ydb/library/yql/providers/yt/gateway/file/yql_yt_file_services.cpp:44: Table not found: plato.float8_tbl
+    
+<sql-statement>
+-- avoid bit-exact output here because operations may not be bit-exact.
+SET extra_float_digits = 0;
+</sql-statement>
+<sql-statement>
+-- square root
+SELECT sqrt(float8 '64') AS eight;
+</sql-statement>
+<sql-statement>
+SELECT |/ float8 '64' AS eight;
+</sql-statement>
+<sql-statement>
+SELECT f.f1, |/f.f1 AS sqrt_f1
+   FROM FLOAT8_TBL f
+   WHERE f.f1 > '0.0';
+</sql-statement>
+<sql-statement>
+-- power
+SELECT power(float8 '144', float8 '0.5');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 'NaN', float8 '0.5');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '144', float8 'NaN');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 'NaN', float8 'NaN');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '-1', float8 'NaN');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '1', float8 'NaN');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 'NaN', float8 '0');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 'inf', float8 '0');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '-inf', float8 '0');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '0', float8 'inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '0', float8 '-inf');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT power(float8 '0', float8 '-inf');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  zero raised to a negative power is undefined
+
+        	SELECT power(float8 '0', float8 '-inf');
+	^
+<sql-statement>
+SELECT power(float8 '1', float8 'inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '1', float8 '-inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '-1', float8 'inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '-1', float8 '-inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '0.1', float8 'inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '-0.1', float8 'inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '1.1', float8 'inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '-1.1', float8 'inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '0.1', float8 '-inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '-0.1', float8 '-inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '1.1', float8 '-inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '-1.1', float8 '-inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 'inf', float8 '-2');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 'inf', float8 '2');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 'inf', float8 'inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 'inf', float8 '-inf');
+</sql-statement>
+<sql-statement>
+-- Intel's icc misoptimizes the code that controls the sign of this result,
+-- even with -mp1.  Pending a fix for that, only test for "is it zero".
+SELECT power(float8 '-inf', float8 '-2') = '0';
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '-inf', float8 '-3');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '-inf', float8 '2');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '-inf', float8 '3');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '-inf', float8 '3.5');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT power(float8 '-inf', float8 '3.5');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  a negative number raised to a non-integer power yields a complex result
+
+        	SELECT power(float8 '-inf', float8 '3.5');
+	^
+<sql-statement>
+SELECT power(float8 '-inf', float8 'inf');
+</sql-statement>
+<sql-statement>
+SELECT power(float8 '-inf', float8 '-inf');
+</sql-statement>
+<sql-statement>
+-- take exp of ln(f.f1)
+SELECT f.f1, exp(ln(f.f1)) AS exp_ln_f1
+   FROM FLOAT8_TBL f
+   WHERE f.f1 > '0.0';
+</sql-statement>
+<sql-statement>
+-- check edge cases for exp
+SELECT exp('inf'::float8), exp('-inf'::float8), exp('nan'::float8);
+</sql-statement>
+-stdin-:<main>: Error: Type annotation
+
+    -stdin-:<main>:1:1: Error: At function: RemovePrefixMembers, At function: PgSelect, At function: PgSetItem
+    	-- check edge cases for exp
+	^
+        -stdin-:<main>:1:1: Error: Duplicated member: exp
+        	-- check edge cases for exp
+	^
+<sql-statement>
+-- cube root
+SELECT ||/ float8 '27' AS three;
+</sql-statement>
+<sql-statement>
+SELECT f.f1, ||/f.f1 AS cbrt_f1 FROM FLOAT8_TBL f;
+</sql-statement>
+<sql-statement>
+SELECT * FROM FLOAT8_TBL;
+</sql-statement>
+<sql-statement>
+UPDATE FLOAT8_TBL
+   SET f1 = FLOAT8_TBL.f1 * '-1'
+   WHERE FLOAT8_TBL.f1 > '0.0';
+</sql-statement>
+-stdin-:<main>: Fatal: Pre type annotation
+
+    -stdin-:<main>: Fatal: tools/enum_parser/enum_serialization_runtime/enum_runtime.cpp:70: Key 'pg_update' not found in enum NYql::EYtSettingType. Valid options are: 'initial', 'infer_scheme', 'force_infer_schema', 'do_not_fail_on_invalid_schema', 'direct_read', 'view', 'mode', 'scheme', 'weak_concat', 'anonymous', 'with_qb', 'inline', 'sample', 'joinLabel', 'ignore_non_existing', 'warn_non_existing', 'xlock', 'unordered', 'nonUnique', 'userschema', 'usercolumns', 'statcolumns', 'syscolumns', 'ignoretypev3', 'memUsage', 'itemsCount', 'rowFactor', 'ordered', 'keyFilter', 'keyFilter2', 'take', 'skip', 'limit', 'sortLimitBy', 'sortBy', 'reduceBy', 'reduceFilterBy', 'forceTransform', 'weakFields', 'sharded', 'combineChunks', 'jobCount', 'joinReduce', 'firstAsPrimary', 'flow', 'keepSorted', 'keySwitch', 'uniqueBy', 'opHash', 'mapOutputType', 'reduceInputType', 'noDq', 'split', 'compression_codec', 'erasure_codec', 'expiration', 'replication_factor', 'user_attrs', 'media', 'primary_medium', 'keep_meta', 'monotonic_keys', 'mutationid'. 
+    
+<sql-statement>
+SELECT f.f1 * '1e200' from FLOAT8_TBL f;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtMap!
+    	SELECT f.f1 * '1e200' from FLOAT8_TBL f;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  value out of range: overflow
+
+        	SELECT f.f1 * '1e200' from FLOAT8_TBL f;
+	^
+<sql-statement>
+SELECT f.f1 ^ '1e200' from FLOAT8_TBL f;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtMap!
+    	SELECT f.f1 ^ '1e200' from FLOAT8_TBL f;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  value out of range: overflow
+
+        	SELECT f.f1 ^ '1e200' from FLOAT8_TBL f;
+	^
+<sql-statement>
+SELECT 0 ^ 0 + 0 ^ 1 + 0 ^ 0.0 + 0 ^ 0.5;
+</sql-statement>
+<sql-statement>
+SELECT ln(f.f1) from FLOAT8_TBL f where f.f1 = '0.0' ;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtMap!
+    	SELECT ln(f.f1) from FLOAT8_TBL f where f.f1 = '0.0' ;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  cannot take logarithm of zero
+
+        	SELECT ln(f.f1) from FLOAT8_TBL f where f.f1 = '0.0' ;
+	^
+<sql-statement>
+SELECT ln(f.f1) from FLOAT8_TBL f where f.f1 < '0.0' ;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtMap!
+    	SELECT ln(f.f1) from FLOAT8_TBL f where f.f1 < '0.0' ;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  cannot take logarithm of a negative number
+
+        	SELECT ln(f.f1) from FLOAT8_TBL f where f.f1 < '0.0' ;
+	^
+<sql-statement>
+SELECT exp(f.f1) from FLOAT8_TBL f;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtMap!
+    	SELECT exp(f.f1) from FLOAT8_TBL f;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  value out of range: overflow
+
+        	SELECT exp(f.f1) from FLOAT8_TBL f;
+	^
+<sql-statement>
+SELECT f.f1 / '0.0' from FLOAT8_TBL f;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtMap!
+    	SELECT f.f1 / '0.0' from FLOAT8_TBL f;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  division by zero
+
+        	SELECT f.f1 / '0.0' from FLOAT8_TBL f;
+	^
+<sql-statement>
+SELECT * FROM FLOAT8_TBL;
+</sql-statement>
+<sql-statement>
+-- 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');
+</sql-statement>
+<sql-statement>
+SELECT cosh(float8 '1');
+</sql-statement>
+<sql-statement>
+SELECT tanh(float8 '1');
+</sql-statement>
+<sql-statement>
+SELECT asinh(float8 '1');
+</sql-statement>
+<sql-statement>
+SELECT acosh(float8 '2');
+</sql-statement>
+<sql-statement>
+SELECT atanh(float8 '0.5');
+</sql-statement>
+<sql-statement>
+-- test Inf/NaN cases for hyperbolic functions
+SELECT sinh(float8 'infinity');
+</sql-statement>
+<sql-statement>
+SELECT sinh(float8 '-infinity');
+</sql-statement>
+<sql-statement>
+SELECT sinh(float8 'nan');
+</sql-statement>
+<sql-statement>
+SELECT cosh(float8 'infinity');
+</sql-statement>
+<sql-statement>
+SELECT cosh(float8 '-infinity');
+</sql-statement>
+<sql-statement>
+SELECT cosh(float8 'nan');
+</sql-statement>
+<sql-statement>
+SELECT tanh(float8 'infinity');
+</sql-statement>
+<sql-statement>
+SELECT tanh(float8 '-infinity');
+</sql-statement>
+<sql-statement>
+SELECT tanh(float8 'nan');
+</sql-statement>
+<sql-statement>
+SELECT asinh(float8 'infinity');
+</sql-statement>
+<sql-statement>
+SELECT asinh(float8 '-infinity');
+</sql-statement>
+<sql-statement>
+SELECT asinh(float8 'nan');
+</sql-statement>
+<sql-statement>
+-- acosh(Inf) should be Inf, but some mingw versions produce NaN, so skip test
+-- SELECT acosh(float8 'infinity');
+SELECT acosh(float8 '-infinity');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	-- acosh(Inf) should be Inf, but some mingw versions produce NaN, so skip test
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  input is out of range
+
+        	-- acosh(Inf) should be Inf, but some mingw versions produce NaN, so skip test
+	^
+<sql-statement>
+SELECT acosh(float8 'nan');
+</sql-statement>
+<sql-statement>
+SELECT atanh(float8 'infinity');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT atanh(float8 'infinity');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  input is out of range
+
+        	SELECT atanh(float8 'infinity');
+	^
+<sql-statement>
+SELECT atanh(float8 '-infinity');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT atanh(float8 '-infinity');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  input is out of range
+
+        	SELECT atanh(float8 '-infinity');
+	^
+<sql-statement>
+SELECT atanh(float8 'nan');
+</sql-statement>
+<sql-statement>
+RESET extra_float_digits;
+</sql-statement>
+<sql-statement>
+-- test for over- and underflow
+INSERT INTO FLOAT8_TBL(f1) VALUES ('10e400');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtFill!
+    	-- test for over- and underflow
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  "10e400" is out of range for type double precision
+
+        	-- test for over- and underflow
+	^
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('-10e400');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtFill!
+    	INSERT INTO FLOAT8_TBL(f1) VALUES ('-10e400');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  "-10e400" is out of range for type double precision
+
+        	INSERT INTO FLOAT8_TBL(f1) VALUES ('-10e400');
+	^
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('10e-400');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtFill!
+    	INSERT INTO FLOAT8_TBL(f1) VALUES ('10e-400');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  "10e-400" is out of range for type double precision
+
+        	INSERT INTO FLOAT8_TBL(f1) VALUES ('10e-400');
+	^
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('-10e-400');
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: YtFill!
+    	INSERT INTO FLOAT8_TBL(f1) VALUES ('-10e-400');
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  "-10e-400" is out of range for type double precision
+
+        	INSERT INTO FLOAT8_TBL(f1) VALUES ('-10e-400');
+	^
+<sql-statement>
+-- maintain external table consistency across platforms
+-- delete all values and reinsert well-behaved ones
+DELETE FROM FLOAT8_TBL;
+</sql-statement>
+-stdin-:<main>: Fatal: Pre type annotation
+
+    -stdin-:<main>: Fatal: tools/enum_parser/enum_serialization_runtime/enum_runtime.cpp:70: Key 'pg_delete' not found in enum NYql::EYtSettingType. Valid options are: 'initial', 'infer_scheme', 'force_infer_schema', 'do_not_fail_on_invalid_schema', 'direct_read', 'view', 'mode', 'scheme', 'weak_concat', 'anonymous', 'with_qb', 'inline', 'sample', 'joinLabel', 'ignore_non_existing', 'warn_non_existing', 'xlock', 'unordered', 'nonUnique', 'userschema', 'usercolumns', 'statcolumns', 'syscolumns', 'ignoretypev3', 'memUsage', 'itemsCount', 'rowFactor', 'ordered', 'keyFilter', 'keyFilter2', 'take', 'skip', 'limit', 'sortLimitBy', 'sortBy', 'reduceBy', 'reduceFilterBy', 'forceTransform', 'weakFields', 'sharded', 'combineChunks', 'jobCount', 'joinReduce', 'firstAsPrimary', 'flow', 'keepSorted', 'keySwitch', 'uniqueBy', 'opHash', 'mapOutputType', 'reduceInputType', 'noDq', 'split', 'compression_codec', 'erasure_codec', 'expiration', 'replication_factor', 'user_attrs', 'media', 'primary_medium', 'keep_meta', 'monotonic_keys', 'mutationid'. 
+    
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('0.0');
+</sql-statement>
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('-34.84');
+</sql-statement>
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('-1004.30');
+</sql-statement>
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('-1.2345678901234e+200');
+</sql-statement>
+<sql-statement>
+INSERT INTO FLOAT8_TBL(f1) VALUES ('-1.2345678901234e-200');
+</sql-statement>
+<sql-statement>
+SELECT * FROM FLOAT8_TBL;
+</sql-statement>
+<sql-statement>
+-- test edge-case coercions to integer
+SELECT '32767.4'::float8::int2;
+</sql-statement>
+<sql-statement>
+SELECT '32767.6'::float8::int2;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT '32767.6'::float8::int2;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  smallint out of range
+
+        	SELECT '32767.6'::float8::int2;
+	^
+<sql-statement>
+SELECT '-32768.4'::float8::int2;
+</sql-statement>
+<sql-statement>
+SELECT '-32768.6'::float8::int2;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT '-32768.6'::float8::int2;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  smallint out of range
+
+        	SELECT '-32768.6'::float8::int2;
+	^
+<sql-statement>
+SELECT '2147483647.4'::float8::int4;
+</sql-statement>
+<sql-statement>
+SELECT '2147483647.6'::float8::int4;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT '2147483647.6'::float8::int4;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  integer out of range
+
+        	SELECT '2147483647.6'::float8::int4;
+	^
+<sql-statement>
+SELECT '-2147483648.4'::float8::int4;
+</sql-statement>
+<sql-statement>
+SELECT '-2147483648.6'::float8::int4;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT '-2147483648.6'::float8::int4;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  integer out of range
+
+        	SELECT '-2147483648.6'::float8::int4;
+	^
+<sql-statement>
+SELECT '9223372036854773760'::float8::int8;
+</sql-statement>
+<sql-statement>
+SELECT '9223372036854775807'::float8::int8;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT '9223372036854775807'::float8::int8;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  bigint out of range
+
+        	SELECT '9223372036854775807'::float8::int8;
+	^
+<sql-statement>
+SELECT '-9223372036854775808.5'::float8::int8;
+</sql-statement>
+<sql-statement>
+SELECT '-9223372036854780000'::float8::int8;
+</sql-statement>
+-stdin-:<main>: Fatal: Execution
+
+    -stdin-:<main>:1:1: Fatal: Execution of node: Result
+    	SELECT '-9223372036854780000'::float8::int8;
+	^
+        -stdin-:<main>:1:1: Fatal: ERROR:  bigint out of range
+
+        	SELECT '-9223372036854780000'::float8::int8;
+	^
+<sql-statement>
+-- 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);
+</sql-statement>
+<sql-statement>
+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);
+</sql-statement>
+<sql-statement>
+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);
+</sql-statement>
+<sql-statement>
+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);
+</sql-statement>
+<sql-statement>
+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);
+</sql-statement>
+<sql-statement>
+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);
+</sql-statement>
+<sql-statement>
+--
+-- 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;
+</sql-statement>
+-stdin-:<main>: Error: Parse Sql
+
+    -stdin-:<main>:1:1: Error: RawStmt: alternative is not implemented yet : 255
+    	--
+	^
+<sql-statement>
+create function xfloat8in(cstring) returns xfloat8 immutable strict
+  language internal as 'int8in';
+</sql-statement>
+-stdin-:<main>: Error: Parse Sql
+
+    -stdin-:<main>:1:1: Error: RawStmt: alternative is not implemented yet : 261
+    	create function xfloat8in(cstring) returns xfloat8 immutable strict
+	^
+<sql-statement>
+create function xfloat8out(xfloat8) returns cstring immutable strict
+  language internal as 'int8out';
+</sql-statement>
+-stdin-:<main>: Error: Parse Sql
+
+    -stdin-:<main>:1:1: Error: RawStmt: alternative is not implemented yet : 261
+    	create function xfloat8out(xfloat8) returns cstring immutable strict
+	^
+<sql-statement>
+create type xfloat8 (input = xfloat8in, output = xfloat8out, like = float8);
+</sql-statement>
+-stdin-:<main>: Error: Parse Sql
+
+    -stdin-:<main>:1:1: Error: RawStmt: alternative is not implemented yet : 255
+    	create type xfloat8 (input = xfloat8in, output = xfloat8out, like = float8);
+	^
+<sql-statement>
+create cast (xfloat8 as float8) without function;
+</sql-statement>
+-stdin-:<main>: Error: Parse Sql
+
+    -stdin-:<main>:1:1: Error: RawStmt: alternative is not implemented yet : 297
+    	create cast (xfloat8 as float8) without function;
+	^
+<sql-statement>
+create cast (float8 as xfloat8) without function;
+</sql-statement>
+-stdin-:<main>: Error: Parse Sql
+
+    -stdin-:<main>:1:1: Error: RawStmt: alternative is not implemented yet : 297
+    	create cast (float8 as xfloat8) without function;
+	^
+<sql-statement>
+create cast (xfloat8 as bigint) without function;
+</sql-statement>
+-stdin-:<main>: Error: Parse Sql
+
+    -stdin-:<main>:1:1: Error: RawStmt: alternative is not implemented yet : 297
+    	create cast (xfloat8 as bigint) without function;
+	^
+<sql-statement>
+create cast (bigint as xfloat8) without function;
+</sql-statement>
+-stdin-:<main>: Error: Parse Sql
+
+    -stdin-:<main>:1:1: Error: RawStmt: alternative is not implemented yet : 297
+    	create cast (bigint as xfloat8) without function;
+	^
+<sql-statement>
+-- 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;
+</sql-statement>
+-stdin-:<main>: Error: Parse Sql
+
+    -stdin-:<main>:22:30: Error: Unknown type: xfloat8
+    	  from (select bits::bigint::xfloat8::float8 as flt
+	                             ^
+-stdin-:<main>: Error: Type annotation
+
+    -stdin-:<main>:1:1: Error: At function: RemovePrefixMembers, At function: PgSelect
+    	-- float8: seeeeeee eeeeeeee eeeeeeee mmmmmmmm mmmmmmmm(x4)
+	^
+        -stdin-:<main>:1:1: Error: Recursive query does not have the form non-recursive-term UNION [ALL] recursive-term
+        	-- float8: seeeeeee eeeeeeee eeeeeeee mmmmmmmm mmmmmmmm(x4)
+	^
+<sql-statement>
+-- 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;
+</sql-statement>
+-stdin-:<main>: Error: Parse Sql
+
+    -stdin-:<main>:145:30: Error: Unknown type: xfloat8
+    	  from (select bits::bigint::xfloat8::float8 as flt
+	                             ^
+-stdin-:<main>: Error: Type annotation
+
+    -stdin-:<main>:1:1: Error: At function: RemovePrefixMembers, At function: PgSelect
+    	-- round-trip tests
+	^
+        -stdin-:<main>:1:1: Error: Recursive query does not have the form non-recursive-term UNION [ALL] recursive-term
+        	-- round-trip tests
+	^
+<sql-statement>
+-- clean up, lest opr_sanity complain
+drop type xfloat8 cascade;
+</sql-statement>
+-stdin-:<main>: Error: Parse Sql
+
+    -stdin-:<main>:1:1: Error: DropStmt: alternative is not implemented yet : 373
+    	-- clean up, lest opr_sanity complain
+	^