diff --git a/GNUmakefile.in b/GNUmakefile.in index 76e7de0857..a25b5c5ee8 100644 --- a/GNUmakefile.in +++ b/GNUmakefile.in @@ -43,6 +43,7 @@ ifeq ($(with_openssl), yes) $(MAKE) -C contrib/sslinfo all endif $(MAKE) -C contrib/tablefunc all + $(MAKE) -C contrib/try_convert all ifneq ($(with_uuid),no) $(MAKE) -C contrib/uuid-ossp all endif @@ -96,6 +97,7 @@ ifeq ($(with_openssl), yes) $(MAKE) -C contrib/sslinfo $@ endif $(MAKE) -C contrib/tablefunc $@ + $(MAKE) -C contrib/try_convert $@ ifneq ($(with_uuid),no) $(MAKE) -C contrib/uuid-ossp $@ endif diff --git a/contrib/Makefile b/contrib/Makefile index 80115232e7..63d47aac5e 100644 --- a/contrib/Makefile +++ b/contrib/Makefile @@ -43,6 +43,7 @@ SUBDIRS = \ test_decoding \ test_parser \ test_shm_mq \ + try_convert \ tsearch2 \ tablefunc \ unaccent diff --git a/contrib/try_convert/.gitignore b/contrib/try_convert/.gitignore new file mode 100644 index 0000000000..8b14087ac0 --- /dev/null +++ b/contrib/try_convert/.gitignore @@ -0,0 +1,4 @@ +# Generated subdirectories +/results/ +/sql/ +/expected/ \ No newline at end of file diff --git a/contrib/try_convert/Makefile b/contrib/try_convert/Makefile new file mode 100644 index 0000000000..b942c4e0fc --- /dev/null +++ b/contrib/try_convert/Makefile @@ -0,0 +1,20 @@ +# contrib/try_convert/Makefile + +MODULE_big = try_convert +OBJS = try_convert.o $(WIN32RES) + +EXTENSION = try_convert +DATA = try_convert--1.0.sql +PGFILEDESC = "try_convert - function for type cast" +REGRESS = try_convert + +ifdef USE_PGXS +PG_CONFIG = pg_config +PGXS := $(shell $(PG_CONFIG) --pgxs) +include $(PGXS) +else +subdir = contrib/try_convert +top_builddir = ../.. +include $(top_builddir)/src/Makefile.global +include $(top_srcdir)/contrib/contrib-global.mk +endif diff --git a/contrib/try_convert/data/tt_abstime.data b/contrib/try_convert/data/tt_abstime.data new file mode 100644 index 0000000000..5cf22efbee --- /dev/null +++ b/contrib/try_convert/data/tt_abstime.data @@ -0,0 +1,12 @@ +2015-10-28 16:35:45 +1974-02-15 15:52:07 +2019-07-22 23:19:33 +2024-06-24 23:02:00 +1986-12-03 12:16:50 +1982-12-11 19:01:59 +1979-07-17 08:59:54 +1982-06-27 18:52:43 +2001-06-25 20:23:38 +1975-02-17 19:50:17 +2007-06-14 13:50:09 +1973-06-11 12:06:52 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_bit.data b/contrib/try_convert/data/tt_bit.data new file mode 100644 index 0000000000..f6724da39a --- /dev/null +++ b/contrib/try_convert/data/tt_bit.data @@ -0,0 +1,11 @@ +1 +0 +1010101 +11001010 +1011011101111 +01001 +1111 +00000000000000000000000 +1111111111111111111 +0101001010101 +11101001000100 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_bool.data b/contrib/try_convert/data/tt_bool.data new file mode 100644 index 0000000000..78542aab4c --- /dev/null +++ b/contrib/try_convert/data/tt_bool.data @@ -0,0 +1,19 @@ +f +true +t +false +t +t +f +t +False +t +f +True +TRUE +f +f +1 +0 +f +FALSE \ No newline at end of file diff --git a/contrib/try_convert/data/tt_bpchar.data b/contrib/try_convert/data/tt_bpchar.data new file mode 100644 index 0000000000..ea621c8662 --- /dev/null +++ b/contrib/try_convert/data/tt_bpchar.data @@ -0,0 +1,70 @@ +All the world's a stage, +And all the men and women merely players; +They have their exits and their entrances, +And one man in his time plays many parts, +His acts being seven ages. At first, the infant, +Mewling and puking in the nurse's arms. +Then the whining schoolboy, with his satchel +And shining morning face, creeping like snail +Unwillingly to school. And then the lover, +Sighing like furnace, with a woeful ballad +Made to his mistress' eyebrow. Then a soldier, +Full of strange oaths and bearded like the pard, +Jealous in honor, sudden and quick in quarrel, +Seeking the bubble reputation +Even in the cannon's mouth. And then the justice, +In fair round belly with good capon lined, +With eyes severe and beard of formal cut, +Full of wise saws and modern instances; +And so he plays his part. The sixth age shifts +Into the lean and slippered pantaloon, +With spectacles on nose and pouch on side; +His youthful hose, well saved, a world too wide +For his shrunk shank, and his big manly voice, +Turning again toward childish treble, pipes +And whistles in his sound. Last scene of all, +That ends this strange eventful history, +Is second childishness and mere oblivion, +Sans teeth, sans eyes, sans taste, sans everything. + +std::to_string + C++ Strings library std::basic_string +Defined in header +std::string to_string( int value ); +std::string to_string( long value ); +std::string to_string( long long value ); +std::string to_string( unsigned value ); +std::string to_string( unsigned long value ); +std::string to_string( unsigned long long value ); +std::string to_string( float value ); +std::string to_string( double value ); +std::string to_string( long double value ); +Converts a numeric value to std::string. + +Let buf be an internal to the conversion functions buffer, sufficiently large to contain the result of conversion. + +1) Converts a signed integer to a string as if by std::sprintf(buf, "%d", value). +2) Converts a signed integer to a string as if by std::sprintf(buf, "%ld", value). +3) Converts a signed integer to a string as if by std::sprintf(buf, "%lld", value). +4) Converts an unsigned integer to a string as if by std::sprintf(buf, "%u", value). +5) Converts an unsigned integer to a string as if by std::sprintf(buf, "%lu", value). +6) Converts an unsigned integer to a string as if by std::sprintf(buf, "%llu", value). +7,8) Converts a floating point value to a string as if by std::sprintf(buf, "%f", value). +9) Converts a floating point value to a string as if by std::sprintf(buf, "%Lf", value). +(until C++26) +1-9) Converts a numeric value to a string as if by std::format("{}", value). +(since C++26) +Parameters +Return value +A string holding the converted value. + +Exceptions +May throw std::bad_alloc from the std::string constructor. + +Notes +With floating point types std::to_string may yield unexpected results as the number of significant digits in the returned string can be zero, see the example. +The return value may differ significantly from what std::cout prints by default, see the example. +std::to_string relies on the current C locale for formatting purposes, and therefore concurrent calls to std::to_string from multiple threads may result in partial serialization of calls. +The results of overloads for integer types do not rely on the current C locale, and thus implementations generally avoid access to the current C locale in these overloads for both correctness and performance. However, such avoidance is not guaranteed by the standard. +(until C++26) +C++17 provides std::to_chars as a higher-performance locale-independent alternative. diff --git a/contrib/try_convert/data/tt_char.data b/contrib/try_convert/data/tt_char.data new file mode 100644 index 0000000000..ea621c8662 --- /dev/null +++ b/contrib/try_convert/data/tt_char.data @@ -0,0 +1,70 @@ +All the world's a stage, +And all the men and women merely players; +They have their exits and their entrances, +And one man in his time plays many parts, +His acts being seven ages. At first, the infant, +Mewling and puking in the nurse's arms. +Then the whining schoolboy, with his satchel +And shining morning face, creeping like snail +Unwillingly to school. And then the lover, +Sighing like furnace, with a woeful ballad +Made to his mistress' eyebrow. Then a soldier, +Full of strange oaths and bearded like the pard, +Jealous in honor, sudden and quick in quarrel, +Seeking the bubble reputation +Even in the cannon's mouth. And then the justice, +In fair round belly with good capon lined, +With eyes severe and beard of formal cut, +Full of wise saws and modern instances; +And so he plays his part. The sixth age shifts +Into the lean and slippered pantaloon, +With spectacles on nose and pouch on side; +His youthful hose, well saved, a world too wide +For his shrunk shank, and his big manly voice, +Turning again toward childish treble, pipes +And whistles in his sound. Last scene of all, +That ends this strange eventful history, +Is second childishness and mere oblivion, +Sans teeth, sans eyes, sans taste, sans everything. + +std::to_string + C++ Strings library std::basic_string +Defined in header +std::string to_string( int value ); +std::string to_string( long value ); +std::string to_string( long long value ); +std::string to_string( unsigned value ); +std::string to_string( unsigned long value ); +std::string to_string( unsigned long long value ); +std::string to_string( float value ); +std::string to_string( double value ); +std::string to_string( long double value ); +Converts a numeric value to std::string. + +Let buf be an internal to the conversion functions buffer, sufficiently large to contain the result of conversion. + +1) Converts a signed integer to a string as if by std::sprintf(buf, "%d", value). +2) Converts a signed integer to a string as if by std::sprintf(buf, "%ld", value). +3) Converts a signed integer to a string as if by std::sprintf(buf, "%lld", value). +4) Converts an unsigned integer to a string as if by std::sprintf(buf, "%u", value). +5) Converts an unsigned integer to a string as if by std::sprintf(buf, "%lu", value). +6) Converts an unsigned integer to a string as if by std::sprintf(buf, "%llu", value). +7,8) Converts a floating point value to a string as if by std::sprintf(buf, "%f", value). +9) Converts a floating point value to a string as if by std::sprintf(buf, "%Lf", value). +(until C++26) +1-9) Converts a numeric value to a string as if by std::format("{}", value). +(since C++26) +Parameters +Return value +A string holding the converted value. + +Exceptions +May throw std::bad_alloc from the std::string constructor. + +Notes +With floating point types std::to_string may yield unexpected results as the number of significant digits in the returned string can be zero, see the example. +The return value may differ significantly from what std::cout prints by default, see the example. +std::to_string relies on the current C locale for formatting purposes, and therefore concurrent calls to std::to_string from multiple threads may result in partial serialization of calls. +The results of overloads for integer types do not rely on the current C locale, and thus implementations generally avoid access to the current C locale in these overloads for both correctness and performance. However, such avoidance is not guaranteed by the standard. +(until C++26) +C++17 provides std::to_chars as a higher-performance locale-independent alternative. diff --git a/contrib/try_convert/data/tt_cidr.data b/contrib/try_convert/data/tt_cidr.data new file mode 100644 index 0000000000..73d05ee9bd --- /dev/null +++ b/contrib/try_convert/data/tt_cidr.data @@ -0,0 +1,16 @@ +192.168.100.128/25 +192.168/24 +192.168/25 +192.168.1 +192.168 +128.1 +128 +128.1.2 +10.1.2 +10.1 +10 +10.1.2.3/32 +2001:4f8:3:ba::/64 +2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128 +::ffff:1.2.3.0/120 +::ffff:1.2.3.0/128 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_citext.data b/contrib/try_convert/data/tt_citext.data new file mode 100644 index 0000000000..ea621c8662 --- /dev/null +++ b/contrib/try_convert/data/tt_citext.data @@ -0,0 +1,70 @@ +All the world's a stage, +And all the men and women merely players; +They have their exits and their entrances, +And one man in his time plays many parts, +His acts being seven ages. At first, the infant, +Mewling and puking in the nurse's arms. +Then the whining schoolboy, with his satchel +And shining morning face, creeping like snail +Unwillingly to school. And then the lover, +Sighing like furnace, with a woeful ballad +Made to his mistress' eyebrow. Then a soldier, +Full of strange oaths and bearded like the pard, +Jealous in honor, sudden and quick in quarrel, +Seeking the bubble reputation +Even in the cannon's mouth. And then the justice, +In fair round belly with good capon lined, +With eyes severe and beard of formal cut, +Full of wise saws and modern instances; +And so he plays his part. The sixth age shifts +Into the lean and slippered pantaloon, +With spectacles on nose and pouch on side; +His youthful hose, well saved, a world too wide +For his shrunk shank, and his big manly voice, +Turning again toward childish treble, pipes +And whistles in his sound. Last scene of all, +That ends this strange eventful history, +Is second childishness and mere oblivion, +Sans teeth, sans eyes, sans taste, sans everything. + +std::to_string + C++ Strings library std::basic_string +Defined in header +std::string to_string( int value ); +std::string to_string( long value ); +std::string to_string( long long value ); +std::string to_string( unsigned value ); +std::string to_string( unsigned long value ); +std::string to_string( unsigned long long value ); +std::string to_string( float value ); +std::string to_string( double value ); +std::string to_string( long double value ); +Converts a numeric value to std::string. + +Let buf be an internal to the conversion functions buffer, sufficiently large to contain the result of conversion. + +1) Converts a signed integer to a string as if by std::sprintf(buf, "%d", value). +2) Converts a signed integer to a string as if by std::sprintf(buf, "%ld", value). +3) Converts a signed integer to a string as if by std::sprintf(buf, "%lld", value). +4) Converts an unsigned integer to a string as if by std::sprintf(buf, "%u", value). +5) Converts an unsigned integer to a string as if by std::sprintf(buf, "%lu", value). +6) Converts an unsigned integer to a string as if by std::sprintf(buf, "%llu", value). +7,8) Converts a floating point value to a string as if by std::sprintf(buf, "%f", value). +9) Converts a floating point value to a string as if by std::sprintf(buf, "%Lf", value). +(until C++26) +1-9) Converts a numeric value to a string as if by std::format("{}", value). +(since C++26) +Parameters +Return value +A string holding the converted value. + +Exceptions +May throw std::bad_alloc from the std::string constructor. + +Notes +With floating point types std::to_string may yield unexpected results as the number of significant digits in the returned string can be zero, see the example. +The return value may differ significantly from what std::cout prints by default, see the example. +std::to_string relies on the current C locale for formatting purposes, and therefore concurrent calls to std::to_string from multiple threads may result in partial serialization of calls. +The results of overloads for integer types do not rely on the current C locale, and thus implementations generally avoid access to the current C locale in these overloads for both correctness and performance. However, such avoidance is not guaranteed by the standard. +(until C++26) +C++17 provides std::to_chars as a higher-performance locale-independent alternative. diff --git a/contrib/try_convert/data/tt_complex.data b/contrib/try_convert/data/tt_complex.data new file mode 100644 index 0000000000..d7ebf7eb24 --- /dev/null +++ b/contrib/try_convert/data/tt_complex.data @@ -0,0 +1,12 @@ +1.1 + 1.0i +10.0 +-1213 - 13.342i +1546i +0.00004 + 9i +111111 - 0.00i +0i +0 +-111.234 +567.1 +123331 +-2 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_date.data b/contrib/try_convert/data/tt_date.data new file mode 100644 index 0000000000..a933b76310 --- /dev/null +++ b/contrib/try_convert/data/tt_date.data @@ -0,0 +1,12 @@ +2015-10-28 +1974-02-15 +2019-07-22 +2024-06-24 +1986-12-03 +1982-12-12 +1979-07-17 +1982-06-27 +2001-06-25 +1975-02-18 +2007-06-14 +1973-06-11 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_float4.data b/contrib/try_convert/data/tt_float4.data new file mode 100644 index 0000000000..d634a54094 --- /dev/null +++ b/contrib/try_convert/data/tt_float4.data @@ -0,0 +1,24 @@ +5.09526 +0.90909 +0.47116 +1.09649 +62.7446 +79.2079 +42.2159 +6.35277 +381.619 +996.121 +529.114 +971.078 +8607.79 +114.810 +7207.21 +6817.10 +53697.0 +26682.5 +64096.1 +11155.2 +434765 +453723 +953815 +875852 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_float8.data b/contrib/try_convert/data/tt_float8.data new file mode 100644 index 0000000000..441d46d8a5 --- /dev/null +++ b/contrib/try_convert/data/tt_float8.data @@ -0,0 +1,30 @@ +2.6338905075109076 +5.005861130502983 +17.865188053013135 +91.26278393448204 +870.5185698367669 +298.4447914486329 +6389.494948660052 +6089.702114381723 +15283.926854963482 +76251.08000751512 +539379.0301196257 +778626.4786305582 +5303536.721951775 +5718.961279435053 +32415605.70046731 +1947674.2385832302 +929098616.2646171 +878721877.8231843 +8316655293.611794 +3075141254.026614 +5792516649.418756 +87800959920.40405 +946949445297.994 +85653452067.87878 +4859904633166.138 +692125184683.836 +76060216525723.16 +76583442930698.78 +128391464499762.8 +475282378098731.3 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_inet.data b/contrib/try_convert/data/tt_inet.data new file mode 100644 index 0000000000..e523116692 --- /dev/null +++ b/contrib/try_convert/data/tt_inet.data @@ -0,0 +1,19 @@ +192.168.100.128/25 +192.168.0.0/24 +192.168.0.0/25 +192.168.100.128 +192.168.0.1/24 +192.168.0.1/25 +192.168.1.0 +192.168.0.0 +128.1.0.0 +128.0.0.0 +128.1.2.0 +10.1.2.0 +10.1.0.0 +10.0.0.0 +10.1.2.3/32 +2001:4f8:3:ba::/64 +2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128 +::ffff:1.2.3.0/120 +::ffff:1.2.3.0/128 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_int2.data b/contrib/try_convert/data/tt_int2.data new file mode 100644 index 0000000000..d6021f2c5e --- /dev/null +++ b/contrib/try_convert/data/tt_int2.data @@ -0,0 +1,24 @@ +6 +0 +2 +2 +7 +6 +89 +8 +42 +2 +21 +50 +26 +198 +649 +544 +220 +589 +8094 +64 +8058 +6981 +3402 +1554 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_int4.data b/contrib/try_convert/data/tt_int4.data new file mode 100644 index 0000000000..1508f6a912 --- /dev/null +++ b/contrib/try_convert/data/tt_int4.data @@ -0,0 +1,27 @@ +9 +3 +0 +9 +84 +60 +807 +729 +536 +9731 +3785 +5520 +82940 +61851 +86170 +577352 +704571 +45824 +2278982 +2893879 +797919 +23279088 +10100142 +27797360 +635684444 +364832178 +370180967 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_int8.data b/contrib/try_convert/data/tt_int8.data new file mode 100644 index 0000000000..cb2afdd7cb --- /dev/null +++ b/contrib/try_convert/data/tt_int8.data @@ -0,0 +1,36 @@ +2 +2 +93 +64 +609 +171 +7291 +1634 +37945 +98952 +639999 +556949 +6846142 +8428519 +77599991 +22904807 +32100243 +315453048 +2677408759 +2109828435 +94290971433 +87636762647 +314677880798 +655438665294 +3956319010606 +9145475897405 +45885185258739 +26488016649805 +246627507693983 +561368134163150 +2627416085229352 +5845859902235405 +89782288360247696 +39940050514039728 +219320759157283328 +997537606495110272 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_interval.data b/contrib/try_convert/data/tt_interval.data new file mode 100644 index 0000000000..3f44dbbc92 --- /dev/null +++ b/contrib/try_convert/data/tt_interval.data @@ -0,0 +1,12 @@ +16736 days, 13:35:45 +1506 days, 12:52:07 +18099 days, 20:19:33 +19898 days, 20:02:00 +6180 days, 9:16:50 +4727 days, 16:01:59 +3484 days, 5:59:54 +4560 days, 15:52:43 +11498 days, 17:23:38 +1873 days, 16:50:17 +13678 days, 10:50:09 +1257 days, 9:06:52 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_json.data b/contrib/try_convert/data/tt_json.data new file mode 100644 index 0000000000..947eac5083 --- /dev/null +++ b/contrib/try_convert/data/tt_json.data @@ -0,0 +1,29 @@ +{"glossary": {"title": "example glossary","GlossDiv": {"title": "S","GlossList": {"GlossEntry": {"ID": "SGML","SortAs": "SGML","GlossTerm": "Standard Generalized Markup Language","Acronym": "SGML","Abbrev": "ISO 8879:1986","GlossDef": {"para": "A meta-markup language, used to create markup languages such as DocBook.","GlossSeeAlso": ["GML", "XML"]},"GlossSee": "markup"}}}}} +{"menu": {"id": "file","value": "File","popup": {"menuitem": [{"value": "New", "onclick": "CreateNewDoc()"},{"value": "Open", "onclick": "OpenDoc()"},{"value": "Close", "onclick": "CloseDoc()"}]}}} +{"widget": {"debug": "on","window": {"title": "Sample Konfabulator Widget","name": "main_window","width": 500,"height": 500},"image": { "src": "Images/Sun.png","name": "sun1","hOffset": 250,"vOffset": 250,"alignment": "center"},"text": {"data": "Click Here","size": 36,"style": "bold","name": "text1","hOffset": 250,"vOffset": 100,"alignment": "center","onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"}}} +{"menu": {"header": "SVG Viewer","items": [{"id": "Open"},{"id": "OpenNew", "label": "Open New"},null,{"id": "ZoomIn", "label": "Zoom In"},{"id": "ZoomOut", "label": "Zoom Out"},{"id": "OriginalView", "label": "Original View"},null,{"id": "Quality"},{"id": "Pause"},{"id": "Mute"},null,{"id": "Find", "label": "Find..."},{"id": "FindAgain", "label": "Find Again"},{"id": "Copy"},{"id": "CopyAgain", "label": "Copy Again"},{"id": "CopySVG", "label": "Copy SVG"},{"id": "ViewSVG", "label": "View SVG"},{"id": "ViewSource", "label": "View Source"},{"id": "SaveAs", "label": "Save As"},null,{"id": "Help"},{"id": "About", "label": "About Adobe CVG Viewer..."}]}} +{"line":1, "date":"CB", "node":"AA"} +{"cleaned":false, "status":59, "line":2, "disabled":false, "node":"CBB"} +{"indexed":true, "status":35, "line":3, "disabled":false, "wait":"CAA", "subtitle":"BA", "user":"CCA"} +{"line":4, "disabled":true, "space":"BB"} +{"cleaned":false, "line":5, "wait":"BB", "query":"CAC", "coauthors":"ACA", "node":"CBA"} +{"world":"CB", "query":"CBC", "indexed":false, "line":6, "pos":92, "date":"AAB", "space":"CB", "coauthors":"ACA", "node":"CBC"} +{"state":98, "org":43, "line":7, "pos":97} +{"auth":"BB", "title":"CAC", "query":"BA", "status":94, "line":8, "coauthors":"BBB"} +{"auth":"BAC", "title":"CAA", "wait":"CA", "bad":true, "query":"AA", "indexed":true, "line":9, "pos":56} +{"title":"AAC", "bad":true, "user":"AAB", "query":"AC", "line":10, "node":"AB"} +{"world":"CAC", "user":"AB", "query":"ACA", "indexed":true, "line":11, "space":"CB"} +{"line":12, "pos":72, "abstract":"BBA", "space":"AAC"} +{} +{"world":"CC", "query":"AA", "line":14, "disabled":false, "date":"CAC", "coauthors":"AB"} +{"org":68, "title":"BBB", "query":"BAC", "line":15, "public":false} +{"org":73, "user":"AA", "indexed":true, "line":16, "date":"CCC", "public":true, "coauthors":"AB"} +{"indexed":false, "line":17} +{"state":23, "auth":"BCC", "org":38, "status":28, "line":18, "disabled":false, "abstract":"CB"} +{"state":99, "auth":"CA", "indexed":true, "line":19, "date":"BA"} +{"wait":"CBA", "user":"BBA", "indexed":true, "line":20, "disabled":false, "abstract":"BA", "date":"ABA"} +{"org":10, "query":"AC", "indexed":false, "line":21, "disabled":true, "abstract":"CA", "pos":44} +{"state":65, "title":"AC", "user":"AAC", "cleaned":true, "status":93, "line":22, "abstract":"ABC", "node":"CCC"} +{"subtitle":"AC", "user":"CCC", "line":23} +{"state":67, "world":"ACB", "bad":true, "user":"CB", "line":24, "disabled":true} +{} \ No newline at end of file diff --git a/contrib/try_convert/data/tt_jsonb.data b/contrib/try_convert/data/tt_jsonb.data new file mode 100644 index 0000000000..947eac5083 --- /dev/null +++ b/contrib/try_convert/data/tt_jsonb.data @@ -0,0 +1,29 @@ +{"glossary": {"title": "example glossary","GlossDiv": {"title": "S","GlossList": {"GlossEntry": {"ID": "SGML","SortAs": "SGML","GlossTerm": "Standard Generalized Markup Language","Acronym": "SGML","Abbrev": "ISO 8879:1986","GlossDef": {"para": "A meta-markup language, used to create markup languages such as DocBook.","GlossSeeAlso": ["GML", "XML"]},"GlossSee": "markup"}}}}} +{"menu": {"id": "file","value": "File","popup": {"menuitem": [{"value": "New", "onclick": "CreateNewDoc()"},{"value": "Open", "onclick": "OpenDoc()"},{"value": "Close", "onclick": "CloseDoc()"}]}}} +{"widget": {"debug": "on","window": {"title": "Sample Konfabulator Widget","name": "main_window","width": 500,"height": 500},"image": { "src": "Images/Sun.png","name": "sun1","hOffset": 250,"vOffset": 250,"alignment": "center"},"text": {"data": "Click Here","size": 36,"style": "bold","name": "text1","hOffset": 250,"vOffset": 100,"alignment": "center","onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"}}} +{"menu": {"header": "SVG Viewer","items": [{"id": "Open"},{"id": "OpenNew", "label": "Open New"},null,{"id": "ZoomIn", "label": "Zoom In"},{"id": "ZoomOut", "label": "Zoom Out"},{"id": "OriginalView", "label": "Original View"},null,{"id": "Quality"},{"id": "Pause"},{"id": "Mute"},null,{"id": "Find", "label": "Find..."},{"id": "FindAgain", "label": "Find Again"},{"id": "Copy"},{"id": "CopyAgain", "label": "Copy Again"},{"id": "CopySVG", "label": "Copy SVG"},{"id": "ViewSVG", "label": "View SVG"},{"id": "ViewSource", "label": "View Source"},{"id": "SaveAs", "label": "Save As"},null,{"id": "Help"},{"id": "About", "label": "About Adobe CVG Viewer..."}]}} +{"line":1, "date":"CB", "node":"AA"} +{"cleaned":false, "status":59, "line":2, "disabled":false, "node":"CBB"} +{"indexed":true, "status":35, "line":3, "disabled":false, "wait":"CAA", "subtitle":"BA", "user":"CCA"} +{"line":4, "disabled":true, "space":"BB"} +{"cleaned":false, "line":5, "wait":"BB", "query":"CAC", "coauthors":"ACA", "node":"CBA"} +{"world":"CB", "query":"CBC", "indexed":false, "line":6, "pos":92, "date":"AAB", "space":"CB", "coauthors":"ACA", "node":"CBC"} +{"state":98, "org":43, "line":7, "pos":97} +{"auth":"BB", "title":"CAC", "query":"BA", "status":94, "line":8, "coauthors":"BBB"} +{"auth":"BAC", "title":"CAA", "wait":"CA", "bad":true, "query":"AA", "indexed":true, "line":9, "pos":56} +{"title":"AAC", "bad":true, "user":"AAB", "query":"AC", "line":10, "node":"AB"} +{"world":"CAC", "user":"AB", "query":"ACA", "indexed":true, "line":11, "space":"CB"} +{"line":12, "pos":72, "abstract":"BBA", "space":"AAC"} +{} +{"world":"CC", "query":"AA", "line":14, "disabled":false, "date":"CAC", "coauthors":"AB"} +{"org":68, "title":"BBB", "query":"BAC", "line":15, "public":false} +{"org":73, "user":"AA", "indexed":true, "line":16, "date":"CCC", "public":true, "coauthors":"AB"} +{"indexed":false, "line":17} +{"state":23, "auth":"BCC", "org":38, "status":28, "line":18, "disabled":false, "abstract":"CB"} +{"state":99, "auth":"CA", "indexed":true, "line":19, "date":"BA"} +{"wait":"CBA", "user":"BBA", "indexed":true, "line":20, "disabled":false, "abstract":"BA", "date":"ABA"} +{"org":10, "query":"AC", "indexed":false, "line":21, "disabled":true, "abstract":"CA", "pos":44} +{"state":65, "title":"AC", "user":"AAC", "cleaned":true, "status":93, "line":22, "abstract":"ABC", "node":"CCC"} +{"subtitle":"AC", "user":"CCC", "line":23} +{"state":67, "world":"ACB", "bad":true, "user":"CB", "line":24, "disabled":true} +{} \ No newline at end of file diff --git a/contrib/try_convert/data/tt_macaddr.data b/contrib/try_convert/data/tt_macaddr.data new file mode 100644 index 0000000000..b3d66c3c48 --- /dev/null +++ b/contrib/try_convert/data/tt_macaddr.data @@ -0,0 +1,6 @@ +08:00:2b:01:02:03 +08-00-2b-01-02-03 +08002b:010203 +08002b-010203 +0800.2b01.0203 +08002b010203 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_money.data b/contrib/try_convert/data/tt_money.data new file mode 100644 index 0000000000..77ec2df165 --- /dev/null +++ b/contrib/try_convert/data/tt_money.data @@ -0,0 +1,8 @@ +10 +0.01 +10.03 +$9 +$1,000,000,000,000,000.00 +0 +$555555555 +1,656,343 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_numeric.data b/contrib/try_convert/data/tt_numeric.data new file mode 100644 index 0000000000..0651147684 --- /dev/null +++ b/contrib/try_convert/data/tt_numeric.data @@ -0,0 +1,30 @@ +5.49803593494943 +2.65056628940059 +87.2433041085257 +42.3137940200886 +211.798205442082 +539.296088779458 +7299.31069089976 +2011.51063389695 +31171.6291300894 +99514.9356660894 +649878.057639453 +438100.083914504 +5175758.4103559 +1210041.95868265 +22469733.7031557 +33808556.2147455 +588308718.457233 +230114732.596577 +2202173844.51559 +709930860.090325 +63110295727.0098 +22894178381.1154 +905420013006.127 +859635400253.746 +708573498886.534 +2380046343689.95 +66897777829628.1 +21423680737043.2 +132311848725025 +935514240580671 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_point.data b/contrib/try_convert/data/tt_point.data new file mode 100644 index 0000000000..611184758d --- /dev/null +++ b/contrib/try_convert/data/tt_point.data @@ -0,0 +1,16 @@ +(1, 2) +(-100000, 0) +21, 9999999999 +0.011111, 9 +962856498.3423, -243.24 +3321, 123 +23,12 +1321 , 132 +216 ,345354 +( 21, 9999999999 ) +( 0.011111, 9 ) +( 962856498.3423, -243.24 ) +(3321, 123 ) +( 23,12) +(1321 , 132 ) +( 216 ,345354) \ No newline at end of file diff --git a/contrib/try_convert/data/tt_regtype.data b/contrib/try_convert/data/tt_regtype.data new file mode 100644 index 0000000000..187bba1047 --- /dev/null +++ b/contrib/try_convert/data/tt_regtype.data @@ -0,0 +1,30 @@ +bool + bytea + char + name + int8 + int2 + int2vector + int4 + regproc + text + oid + tid + xid + cid + oidvector + pg_type + pg_attribute + pg_proc + pg_class + json + xml + _xml + pg_node_tree + _json + complex + _complex + smgr + point + lseg + path \ No newline at end of file diff --git a/contrib/try_convert/data/tt_reltime.data b/contrib/try_convert/data/tt_reltime.data new file mode 100644 index 0000000000..3f44dbbc92 --- /dev/null +++ b/contrib/try_convert/data/tt_reltime.data @@ -0,0 +1,12 @@ +16736 days, 13:35:45 +1506 days, 12:52:07 +18099 days, 20:19:33 +19898 days, 20:02:00 +6180 days, 9:16:50 +4727 days, 16:01:59 +3484 days, 5:59:54 +4560 days, 15:52:43 +11498 days, 17:23:38 +1873 days, 16:50:17 +13678 days, 10:50:09 +1257 days, 9:06:52 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_text.data b/contrib/try_convert/data/tt_text.data new file mode 100644 index 0000000000..ea621c8662 --- /dev/null +++ b/contrib/try_convert/data/tt_text.data @@ -0,0 +1,70 @@ +All the world's a stage, +And all the men and women merely players; +They have their exits and their entrances, +And one man in his time plays many parts, +His acts being seven ages. At first, the infant, +Mewling and puking in the nurse's arms. +Then the whining schoolboy, with his satchel +And shining morning face, creeping like snail +Unwillingly to school. And then the lover, +Sighing like furnace, with a woeful ballad +Made to his mistress' eyebrow. Then a soldier, +Full of strange oaths and bearded like the pard, +Jealous in honor, sudden and quick in quarrel, +Seeking the bubble reputation +Even in the cannon's mouth. And then the justice, +In fair round belly with good capon lined, +With eyes severe and beard of formal cut, +Full of wise saws and modern instances; +And so he plays his part. The sixth age shifts +Into the lean and slippered pantaloon, +With spectacles on nose and pouch on side; +His youthful hose, well saved, a world too wide +For his shrunk shank, and his big manly voice, +Turning again toward childish treble, pipes +And whistles in his sound. Last scene of all, +That ends this strange eventful history, +Is second childishness and mere oblivion, +Sans teeth, sans eyes, sans taste, sans everything. + +std::to_string + C++ Strings library std::basic_string +Defined in header +std::string to_string( int value ); +std::string to_string( long value ); +std::string to_string( long long value ); +std::string to_string( unsigned value ); +std::string to_string( unsigned long value ); +std::string to_string( unsigned long long value ); +std::string to_string( float value ); +std::string to_string( double value ); +std::string to_string( long double value ); +Converts a numeric value to std::string. + +Let buf be an internal to the conversion functions buffer, sufficiently large to contain the result of conversion. + +1) Converts a signed integer to a string as if by std::sprintf(buf, "%d", value). +2) Converts a signed integer to a string as if by std::sprintf(buf, "%ld", value). +3) Converts a signed integer to a string as if by std::sprintf(buf, "%lld", value). +4) Converts an unsigned integer to a string as if by std::sprintf(buf, "%u", value). +5) Converts an unsigned integer to a string as if by std::sprintf(buf, "%lu", value). +6) Converts an unsigned integer to a string as if by std::sprintf(buf, "%llu", value). +7,8) Converts a floating point value to a string as if by std::sprintf(buf, "%f", value). +9) Converts a floating point value to a string as if by std::sprintf(buf, "%Lf", value). +(until C++26) +1-9) Converts a numeric value to a string as if by std::format("{}", value). +(since C++26) +Parameters +Return value +A string holding the converted value. + +Exceptions +May throw std::bad_alloc from the std::string constructor. + +Notes +With floating point types std::to_string may yield unexpected results as the number of significant digits in the returned string can be zero, see the example. +The return value may differ significantly from what std::cout prints by default, see the example. +std::to_string relies on the current C locale for formatting purposes, and therefore concurrent calls to std::to_string from multiple threads may result in partial serialization of calls. +The results of overloads for integer types do not rely on the current C locale, and thus implementations generally avoid access to the current C locale in these overloads for both correctness and performance. However, such avoidance is not guaranteed by the standard. +(until C++26) +C++17 provides std::to_chars as a higher-performance locale-independent alternative. diff --git a/contrib/try_convert/data/tt_time.data b/contrib/try_convert/data/tt_time.data new file mode 100644 index 0000000000..92ba52ea63 --- /dev/null +++ b/contrib/try_convert/data/tt_time.data @@ -0,0 +1,12 @@ +13:35:45 +21:52:07 +16:19:33 +20:02:00 +11:16:50 +01:01:59 +14:59:54 +10:52:43 +19:23:38 +01:50:17 +09:50:09 +09:06:52 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_timestamp.data b/contrib/try_convert/data/tt_timestamp.data new file mode 100644 index 0000000000..5cf22efbee --- /dev/null +++ b/contrib/try_convert/data/tt_timestamp.data @@ -0,0 +1,12 @@ +2015-10-28 16:35:45 +1974-02-15 15:52:07 +2019-07-22 23:19:33 +2024-06-24 23:02:00 +1986-12-03 12:16:50 +1982-12-11 19:01:59 +1979-07-17 08:59:54 +1982-06-27 18:52:43 +2001-06-25 20:23:38 +1975-02-17 19:50:17 +2007-06-14 13:50:09 +1973-06-11 12:06:52 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_timestamptz.data b/contrib/try_convert/data/tt_timestamptz.data new file mode 100644 index 0000000000..bdb863b79f --- /dev/null +++ b/contrib/try_convert/data/tt_timestamptz.data @@ -0,0 +1,12 @@ +2015-10-28 13:35:45+00:00 +1974-02-15 21:52:07+09:00 +2019-07-22 16:19:33-04:00 +2024-06-24 20:02:00+00:00 +1986-12-03 11:16:50+02:00 +1982-12-12 01:01:59+09:00 +1979-07-17 14:59:54+09:00 +1982-06-27 10:52:43-04:00 +2001-06-25 19:23:38+03:00 +1975-02-18 01:50:17+09:00 +2007-06-14 09:50:09+00:00 +1973-06-11 09:06:52+00:00 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_timetz.data b/contrib/try_convert/data/tt_timetz.data new file mode 100644 index 0000000000..cee4c87ffb --- /dev/null +++ b/contrib/try_convert/data/tt_timetz.data @@ -0,0 +1,12 @@ +13:35:45 UTC +21:52:07 JST +16:19:33 EDT +20:02:00 UTC +11:16:50 EET +01:01:59 JST +14:59:54 JST +10:52:43 EDT +19:23:38 EEST +01:50:17 JST +09:50:09 UTC +09:06:52 UTC \ No newline at end of file diff --git a/contrib/try_convert/data/tt_uuid.data b/contrib/try_convert/data/tt_uuid.data new file mode 100644 index 0000000000..6680d6384b --- /dev/null +++ b/contrib/try_convert/data/tt_uuid.data @@ -0,0 +1,6 @@ +a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11 +A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11 +{a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11} +a0eebc999c0b4ef8bb6d6bb9bd380a11 +a0ee-bc99-9c0b-4ef8-bb6d-6bb9-bd38-0a11 +{a0eebc99-9c0b4ef8-bb6d6bb9-bd380a11} \ No newline at end of file diff --git a/contrib/try_convert/data/tt_varbit.data b/contrib/try_convert/data/tt_varbit.data new file mode 100644 index 0000000000..f6724da39a --- /dev/null +++ b/contrib/try_convert/data/tt_varbit.data @@ -0,0 +1,11 @@ +1 +0 +1010101 +11001010 +1011011101111 +01001 +1111 +00000000000000000000000 +1111111111111111111 +0101001010101 +11101001000100 \ No newline at end of file diff --git a/contrib/try_convert/data/tt_varchar.data b/contrib/try_convert/data/tt_varchar.data new file mode 100644 index 0000000000..ea621c8662 --- /dev/null +++ b/contrib/try_convert/data/tt_varchar.data @@ -0,0 +1,70 @@ +All the world's a stage, +And all the men and women merely players; +They have their exits and their entrances, +And one man in his time plays many parts, +His acts being seven ages. At first, the infant, +Mewling and puking in the nurse's arms. +Then the whining schoolboy, with his satchel +And shining morning face, creeping like snail +Unwillingly to school. And then the lover, +Sighing like furnace, with a woeful ballad +Made to his mistress' eyebrow. Then a soldier, +Full of strange oaths and bearded like the pard, +Jealous in honor, sudden and quick in quarrel, +Seeking the bubble reputation +Even in the cannon's mouth. And then the justice, +In fair round belly with good capon lined, +With eyes severe and beard of formal cut, +Full of wise saws and modern instances; +And so he plays his part. The sixth age shifts +Into the lean and slippered pantaloon, +With spectacles on nose and pouch on side; +His youthful hose, well saved, a world too wide +For his shrunk shank, and his big manly voice, +Turning again toward childish treble, pipes +And whistles in his sound. Last scene of all, +That ends this strange eventful history, +Is second childishness and mere oblivion, +Sans teeth, sans eyes, sans taste, sans everything. + +std::to_string + C++ Strings library std::basic_string +Defined in header +std::string to_string( int value ); +std::string to_string( long value ); +std::string to_string( long long value ); +std::string to_string( unsigned value ); +std::string to_string( unsigned long value ); +std::string to_string( unsigned long long value ); +std::string to_string( float value ); +std::string to_string( double value ); +std::string to_string( long double value ); +Converts a numeric value to std::string. + +Let buf be an internal to the conversion functions buffer, sufficiently large to contain the result of conversion. + +1) Converts a signed integer to a string as if by std::sprintf(buf, "%d", value). +2) Converts a signed integer to a string as if by std::sprintf(buf, "%ld", value). +3) Converts a signed integer to a string as if by std::sprintf(buf, "%lld", value). +4) Converts an unsigned integer to a string as if by std::sprintf(buf, "%u", value). +5) Converts an unsigned integer to a string as if by std::sprintf(buf, "%lu", value). +6) Converts an unsigned integer to a string as if by std::sprintf(buf, "%llu", value). +7,8) Converts a floating point value to a string as if by std::sprintf(buf, "%f", value). +9) Converts a floating point value to a string as if by std::sprintf(buf, "%Lf", value). +(until C++26) +1-9) Converts a numeric value to a string as if by std::format("{}", value). +(since C++26) +Parameters +Return value +A string holding the converted value. + +Exceptions +May throw std::bad_alloc from the std::string constructor. + +Notes +With floating point types std::to_string may yield unexpected results as the number of significant digits in the returned string can be zero, see the example. +The return value may differ significantly from what std::cout prints by default, see the example. +std::to_string relies on the current C locale for formatting purposes, and therefore concurrent calls to std::to_string from multiple threads may result in partial serialization of calls. +The results of overloads for integer types do not rely on the current C locale, and thus implementations generally avoid access to the current C locale in these overloads for both correctness and performance. However, such avoidance is not guaranteed by the standard. +(until C++26) +C++17 provides std::to_chars as a higher-performance locale-independent alternative. diff --git a/contrib/try_convert/data/tt_xml.data b/contrib/try_convert/data/tt_xml.data new file mode 100644 index 0000000000..b4a66101dd --- /dev/null +++ b/contrib/try_convert/data/tt_xml.data @@ -0,0 +1,5 @@ + + on main_window 500 500 250 250 center text1 250 100 center sun1.opacity = (sun1.opacity / 100) * 90; + A Song of Ice and Fire George R. R. Martin English Epic fantasy + Rick Grimes 35 Maths Male Daryl Dixon 33 Science Male Maggie 36 Arts Female +
Adobe SVG Viewer
Open Open New Zoom In Zoom Out Original View Quality Pause Mute Find... Find Again Copy Copy Again Copy SVG View SVG View Source Save As Help About Adobe CVG Viewer... \ No newline at end of file diff --git a/contrib/try_convert/generate_data.py b/contrib/try_convert/generate_data.py new file mode 100644 index 0000000000..43f2dc96c4 --- /dev/null +++ b/contrib/try_convert/generate_data.py @@ -0,0 +1,100 @@ +import random +import datetime +import time +import pytz + +random.seed(42) + +### NUMBERS + +numbers = { + 'int2' : ((-32768, 32767), False), + 'int4' : ((-2147483648, 2147483647), False), + 'int8' : ((-9223372036854775808, 9223372036854775807), False), + 'float4' : ((10**6, 10**6), True), + 'float8' : ((10**15, 10**15), True), + 'numeric' : ((10**20, 10**20), True), +} + + +def save_datafile(t, data): + filename = f'data/tt_{t}.data' + file = open(filename, 'w') + file.write('\n'.join([str(d) for d in data])) + + return filename + + +for number_type in numbers: + + type_range = numbers[number_type][0] + is_float = numbers[number_type][1] + + mn = type_range[0] + mx = type_range[1] + + nln = 0 + ln = len(str(type_range[1]))-1 + + table_name = f'tt_{number_type}' + + values = [] + + for c in range(nln, ln): + rep = 20 // ln + 1 + for _ in range(rep): + n = random.random() + if c >= 0: + n *= (10 ** (c+1)) + else: + n /= (10 ** (-c)) + if not is_float: + n = int(n) + + values += [n] + + filename = save_datafile(number_type, values) + +### TIMES + +MINTIME = datetime.datetime.fromtimestamp(0) +MAXTIME = datetime.datetime(2024,12,2,10,39,59) +mintime_ts = int(time.mktime(MINTIME.timetuple())) +maxtime_ts = int(time.mktime(MAXTIME.timetuple())) + +timestamp_values = [] +timestamptz_values = [] +time_values = [] +timetz_values = [] +date_values = [] +interval_values = [] + +timezones = [pytz.timezone("UTC"), pytz.timezone("Asia/Istanbul"), pytz.timezone("US/Eastern"), pytz.timezone("Asia/Tokyo")] + +for _ in range(12): + random_ts = random.randint(mintime_ts, maxtime_ts) + randtom_tz = timezones[random.randint(0, len(timezones)-1)] + RANDOMTIME = datetime.datetime.fromtimestamp(random_ts, randtom_tz) + R_clear = datetime.datetime.fromtimestamp(RANDOMTIME.timestamp()) + + timestamp_text = str(R_clear) + timestamptz_text = str(RANDOMTIME) + timetz_text = str(RANDOMTIME.time()) + " " + RANDOMTIME.tzname() + time_text = str(RANDOMTIME.time()) + date_text = str(RANDOMTIME.date()) + dt = (R_clear-MINTIME) + interval_text = str(dt) + + timestamp_values += [timestamp_text] + timestamptz_values += [timestamptz_text] + time_values += [time_text] + timetz_values += [timetz_text] + date_values += [date_text] + interval_values += [interval_text] + +save_datafile("timestamp", timestamp_values) +save_datafile("timestamptz", timestamptz_values) +save_datafile("time", time_values) +save_datafile("timetz", timetz_values) +save_datafile("date", date_values) +save_datafile("interval", interval_values) diff --git a/contrib/try_convert/generate_test.py b/contrib/try_convert/generate_test.py new file mode 100644 index 0000000000..abddfdaeb4 --- /dev/null +++ b/contrib/try_convert/generate_test.py @@ -0,0 +1,608 @@ +import re + +supported_types = [ + 'int8', # NUMBERS + 'int4', + 'int2', + 'float8', + 'float4', + 'numeric', + 'complex', + + 'bool', + + 'bit', # BITSTRING + 'varbit', + + 'date', # TIME + 'time', + 'timetz', + 'timestamp', + 'timestamptz', + 'interval', + 'abstime', + 'reltime', + + 'point', # GEOMENTY + # 'circle', + # 'line', + # 'lseg', + # 'path', + # 'box', + # 'polygon', + + 'cidr', # IP + 'inet', + 'macaddr', + + 'json', # OBJ + 'jsonb', + 'xml', + + # 'bytea', + + 'char', # STRINGS + # 'bpchar', + 'varchar', + 'text', + + 'money', + # # 'pg_lsn', + # # 'tsquery', + # # 'tsvector', + # # 'txid_snapshot', + 'uuid', + + 'regtype', # SYSTEM + + 'citext', +] + +string_types = [ + 'text', + 'citext', + 'char', + # 'bpchar', + 'varchar', +] + +typmod_types = [ + 'bit', + 'varbit', + 'char', + 'varchar', + # 'bpchar', +] + +typmod_lens = [ + None, 1, 5, 10, 20 +] + +def get_typemod_type(t, l): + if l is None: + return t + else: + return f'{t}({l})' + +def get_typemod_table(t, l): + if l is None: + return f'tt_{t}' + else: + return f'tt_{t}_{l}' + +uncomparable_types = [ + 'json', + 'xml', + 'point', +] + +extensions = [ + 'citext' +] + +extension_types = [ + 'citext' +] + +extension_casts = [ + ('citext', 'text'), + ('citext', 'varchar'), + ('citext', 'bpchar'), + ('text', 'citext'), + ('varchar', 'citext'), + ('bpchar', 'citext'), + ('boolean', 'citext'), + ('inet', 'citext'), +] + +print('Supported types:', ' '.join(supported_types)) + + +pg_type_path = '/home/robozmey/gpdb_src/src/include/catalog/pg_type.h' +pg_cast_path = '/home/robozmey/gpdb_src/src/include/catalog/pg_cast.h' +pg_proc_path = '/home/robozmey/gpdb_src/src/backend/catalog/pg_proc_combined.h' + + +def remove_empty_lines(t): + return "\n".join([s for s in t.split("\n") if s]) + +### GET FUNCTION IDs + +f = open(pg_proc_path) +content = f.read() + +# DATA(insert OID = 46 ( textin PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 25 "2275" _null_ _null_ _null_ _null_ textin _null_ _null_ _null_ )); +func_pattern = r'DATA\(insert OID =\s+(\w*)\s+\(.*?(\w*) _null_ _null_ _null_ n?\s?a?\s?\)\);'; + +func_id_name = {} + +func_id_name['0'] = 'via I/O' + +for (id, name) in re.findall(func_pattern, content): + func_id_name[id] = name + # print(id, name) + + + +### GET TYPE IDs + +# TODO Is_have_IO + +f = open(pg_type_path) +content = f.read() + +type_pattern = r'DATA\(insert OID = (.*) \([\s]*(.*?)[\s]'; + +type_name_id = {} +type_id_name = {} + +supported_types_count = 0 + +for (id, name) in re.findall(type_pattern, content): + if name != '' and name[0] != '_': + id = int(id) + type_id_name[id] = name + type_name_id[name] = id + + if name in supported_types: + # print(f'|{name}|✅|') + supported_types_count += 1 + +supported_extension_types_count = 0 +for name in extension_types: + if name in supported_types: + supported_extension_types_count += 1 + +print(f'Types found: {len(type_id_name)}, supported: {supported_types_count}') +print(f'Extensions types found: {len(extension_types)}, supported: {supported_extension_types_count}') + + +### GET CONVERTS + +f = open(pg_cast_path) +content = f.read() + +cast_pattern = r'DATA\(insert \([\s]*(\d+)[\s]+(\d+)[\s]+(\d+)[\s]+(.)[\s]+(.)'; + +casts = [] +supported_cast_count = 0 + +for (source, target, funcid, _, meth) in re.findall(cast_pattern, content): + casts += [(int(source), int(target), meth)] + print(type_id_name[int(source)], ' -> ', type_id_name[int(target)], ' via ', meth, f'({funcid} - {func_id_name[funcid]}) ', f'{source}-{target}') + if type_id_name[int(source)] in supported_types and type_id_name[int(target)] in supported_types: + supported_cast_count += 1 + +supported_extension_casts_count = 0 +for s, t in extension_casts: + if s in supported_types and t in supported_types: + supported_extension_casts_count += 1 + +print(f'Casts found: {len(casts)}, supported: {supported_cast_count}') +print(f'Extensions casts found: {len(extension_casts)}, supported: {supported_extension_casts_count}') + + +### HEADER & FOOTER + +test_header = \ + f'-- SCRIPT-GENERATED TEST for TRY_CONVERT\n' \ + f'-- Tests {supported_types_count} types of {len(type_id_name)} from pg_types.h\n' \ + f'-- Tests {supported_cast_count} cast of {len(casts)} from pg_cast.h\n' \ + f'-- Tests {supported_extension_types_count} types of {len(extension_types)} from extensions\n' \ + f'-- Tests {supported_extension_casts_count} casts of {len(extension_casts)} from extensions\n' \ + f'\n' \ + f'create schema tryconvert;\n' \ + f'set search_path = tryconvert;\n' \ + f'\n' \ + f'-- start_ignore\n' \ + f'CREATE EXTENSION IF NOT EXISTS try_convert;\n' \ + f'-- end_ignore\n' \ + f'\n' \ + +for type_name in supported_types: + test_header += \ + f'select add_type_for_try_convert(\'{type_name}\'::regtype);' + +for extension in extensions: + test_header += \ + f'-- start_ignore\n' \ + f'CREATE EXTENSION IF NOT EXISTS {extension};\n' \ + f'-- end_ignore\n' \ + +test_footer = 'reset search_path;' + + +### TRY_CONVERT_BY_SQL + +test_funcs = '' + +func_text = \ + f'CREATE FUNCTION try_convert_by_sql_text(_in text, INOUT _out ANYELEMENT, source_type text)\n' \ + f' LANGUAGE plpgsql AS\n' \ + f'$func$\n' \ + f' BEGIN\n' \ + f' EXECUTE format(\'SELECT %L::%s::%s\', $1, source_type, pg_typeof(_out))\n' \ + f' INTO _out;\n' \ + f' EXCEPTION WHEN others THEN\n' \ + f' -- do nothing: _out already carries default\n' \ + f' END\n' \ + f'$func$;\n' + +test_funcs += func_text + +func_text = \ + f'CREATE FUNCTION try_convert_by_sql_text_with_len_out(_in text, INOUT _out ANYELEMENT, source_type text, len_out int)\n' \ + f' LANGUAGE plpgsql AS\n' \ + f'$func$\n' \ + f' BEGIN\n' \ + f' EXECUTE format(\'SELECT %L::%s::%s(%s)\', $1, source_type, pg_typeof(_out), len_out::text)\n' \ + f' INTO _out;\n' \ + f' EXCEPTION WHEN others THEN\n' \ + f' -- do nothing: _out already carries default\n' \ + f' END\n' \ + f'$func$;\n' + +test_funcs += func_text + +for type_name in supported_types: + + func_text = \ + f'CREATE FUNCTION try_convert_by_sql_with_len_out(_in {type_name}, INOUT _out ANYELEMENT, len_out int)\n' \ + f' LANGUAGE plpgsql AS\n' \ + f'$func$\n' \ + f' BEGIN\n' \ + f' EXECUTE format(\'SELECT %L::{type_name}::%s(%s)\', $1, pg_typeof(_out), len_out::text)\n' \ + f' INTO _out;\n' \ + f' EXCEPTION WHEN others THEN\n' \ + f' -- do nothing: _out already carries default\n' \ + f' END\n' \ + f'$func$;\n' + + test_funcs += func_text + + func_text = \ + f'CREATE FUNCTION try_convert_by_sql(_in {type_name}, INOUT _out ANYELEMENT)\n' \ + f' LANGUAGE plpgsql AS\n' \ + f'$func$\n' \ + f' BEGIN\n' \ + f' EXECUTE format(\'SELECT %L::{type_name}::%s\', $1, pg_typeof(_out))\n' \ + f' INTO _out;\n' \ + f' EXCEPTION WHEN others THEN\n' \ + f' -- do nothing: _out already carries default\n' \ + f' END\n' \ + f'$func$;\n' + + test_funcs += func_text + +### CREATE DATA + +import random + +random.seed(42) + +numbers = { + 'int2' : ((-32768, 32767), False), + 'int4' : ((-2147483648, 2147483647), False), + 'int8' : ((-9223372036854775808, 9223372036854775807), False), + 'float4' : ((10**6, 10**6), True), + 'float8' : ((10**15, 10**15), True), + 'numeric' : ((10**20, 10**20), True), +} + +test_load_data = '-- LOAD DATA\n' + +test_load_data += f'CREATE TABLE tt_temp (v text) DISTRIBUTED BY (v);\n' + +def copy_data(table_name, filename, type_name): + return f'DELETE FROM tt_temp;\n' \ + f'COPY tt_temp from \'@abs_srcdir@/{filename}\';\n' \ + f'INSERT INTO {table_name}(id, v) SELECT row_number() OVER(), v::{type_name} from tt_temp;' + +type_tables = {} + +def create_table(type_name, varlen=None): + table_name = get_typemod_table(type_name, varlen) + field_type = get_typemod_type(type_name, varlen) + + type_tables[type_name] = table_name + + load_data = f'CREATE TABLE {table_name} (id serial, v {field_type}) DISTRIBUTED BY (id);\n' + + filename = f'data/tt_{type_name}.data' + + load_data += copy_data(table_name, filename, field_type) + '\n' + + # load_data += f'SELECT * FROM {table_name};' + + return load_data + +def get_string_table(type_name, string_type, type_varlen=None, string_varlen=None): + + if type_varlen is not None and string_varlen is not None: + return f'tt_{string_type}_{string_varlen}_of_{type_name}_{type_varlen}' + elif type_varlen is not None: + return f'tt_{string_type}_of_{type_name}_{type_varlen}' + elif string_varlen is not None: + return f'tt_{string_type}_{string_varlen}_of_{type_name}' + + return f'tt_{string_type}_of_{type_name}' + +for type_name in supported_types: + + for type_varlen in typmod_lens: + if type_varlen is not None and type_name not in typmod_types: + continue + + test_load_data += create_table(type_name, type_varlen) + + for string_type in string_types: + for string_varlen in typmod_lens: + if string_varlen is not None and string_type not in typmod_types: + continue + + field_type = get_typemod_type(type_name, type_varlen) + string_field_type = get_typemod_type(string_type, string_varlen) + + table_name = get_string_table(type_name, string_type, type_varlen, string_varlen) + + load_data = f'CREATE TABLE {table_name} (id serial, v {string_field_type}) DISTRIBUTED BY (id);\n' + + cut = f'::{field_type}' if type_varlen is not None else '' + + load_data += f'INSERT INTO {table_name}(id, v) SELECT row_number() OVER(), v{cut}::{string_field_type} from tt_temp;\n' + + test_load_data += load_data + + + +## GET DATA + +def get_data(type_name): + return type_tables[type_name] + +def get_len_from_data(type_name): + f = open(f'data/tt_{type_name}') + return(len(f.read().split('\n'))) + +def get_from_data(type_name, i = None): + f = open(f'data/tt_{type_name}.data') + values = f.read().split('\n') + if i is None: + return content + return values[i] + +## TEST + +def create_test(source_name, target_name, test_data, default='NULL', source_varlen=None, target_varlen=None): + + test_filter = 'v1 is distinct from v2' if target_name not in uncomparable_types else 'v1::text is distinct from v2::text' + + try_convert_sql = f'try_convert_by_sql(v, {default}::{target_name})' + + if target_varlen is not None: + try_convert_sql = f'try_convert_by_sql_with_len_out(v, {default}::{target_name}, {target_varlen})' + + if source_varlen is not None or source_name in ['bpchar']: + + source_name_1 = get_typemod_type(source_name, source_varlen) + + try_convert_sql = f'try_convert_by_sql_text(v::text, {default}::{target_name}, \'{source_name_1}\'::text)' + + if target_varlen is not None: + try_convert_sql = f'try_convert_by_sql_text_with_len_out(v::text, {default}::{target_name}, \'{source_name_1}\'::text, {target_varlen})' + + target_name_1 = get_typemod_type(target_name, target_varlen) + + query = \ + f'select * from (' \ + f'select ' \ + f'try_convert(v, {default}::{target_name_1}) as v1, ' \ + f'{try_convert_sql} as v2' \ + f' from {test_data}' \ + f') as t(v1, v2) where {test_filter};' + result = \ + ' v1 | v2 \n' \ + '----+----\n' \ + '(0 rows)\n' \ + + input_source = query + output_source = remove_empty_lines(query) + '\n' + result + + return input_source, output_source + + +### CAST to & from text + +text_tests_in = [] +text_tests_out = [] + +default_value = 'NULL' + +for string_type in string_types: + for string_varlen in typmod_lens: + if string_varlen is not None and type_name not in typmod_types: + continue + + for type_name in supported_types: + for type_varlen in typmod_lens: + if type_varlen is not None and type_name not in typmod_types: + continue + + test_type_table = get_typemod_table(type_name, type_varlen) + + text_type_table = get_string_table(type_name, string_type, type_varlen, string_varlen) + + test_corrupted_text_data = f'(select (\'!@#%^&*\' || v || \'!@#%^&*\') from {text_type_table}) as t(v)' + + to_text_in, to_text_out = create_test(type_name, string_type, test_type_table, default_value, type_varlen, string_varlen) + from_text_in, from_text_out = create_test(string_type, type_name, text_type_table, default_value, string_varlen, type_varlen) + # from_corrupted_text_in, from_corrupted_text_out = create_test(string_type, type_name, test_corrupted_text_data, default_value, string_varlen, type_varlen) + + text_tests_in += [to_text_in, from_text_in] + text_tests_out += [to_text_out, from_text_out] + +# print(text_tests_in[0]) +# print(text_tests_in[1]) + + +### CAST from pg_cast + +function_tests_in = [] +function_tests_out = [] + +type_casts = [(type_id_name[source_id], type_id_name[target_id]) for (source_id, target_id, method) in casts] \ + + extension_casts + +for source_name, target_name in type_casts: + if (source_name not in supported_types or target_name not in supported_types): + continue + + dd = get_from_data(target_name, 0).translate(str.maketrans('', '', '\'')) + d = f'\'{dd}\'' + + for default in ['NULL', d]: + + for source_varlen in typmod_lens: + if source_varlen is not None and source_name not in typmod_types: + continue + + test_table = get_typemod_table(source_name, source_varlen) + + for target_varlen in typmod_lens: + if target_varlen is not None and target_name not in typmod_types: + continue + + test_in, test_out = create_test(source_name, target_name, test_table, default, source_varlen, target_varlen) + + function_tests_in += [test_in] + function_tests_out += [test_out] + + +# print(function_tests_in[0]) + + +### DEFAULTS TEST + +# for type_name in supported_types: + +# query = f'SELECT try_convert({}::{}, {get_from_data(type_name, 0)}::{type_name});' + +### ONE MILLION ERRORS + +test_million = '' + +test_million_data = \ + 'DROP TABLE IF EXISTS text_ints; CREATE TABLE text_ints (v text) DISTRIBUTED BY (v);\n' \ + 'INSERT INTO text_ints(v) SELECT (random()*1000)::int4::text FROM generate_series(1,1000000);\n' \ + 'DROP TABLE IF EXISTS text_error_ints; CREATE TABLE text_error_ints (v text) DISTRIBUTED BY (v);\n' \ + 'INSERT INTO text_error_ints(v) SELECT (random()*1000000 + 1000000)::int8::text FROM generate_series(1,1000000);\n' \ + 'DROP TABLE IF EXISTS int4_ints; CREATE TABLE int4_ints (v int4) DISTRIBUTED BY (v);\n' \ + 'INSERT INTO int4_ints(v) SELECT (random()*1000)::int4 FROM generate_series(1,1000000);\n' \ + 'DROP TABLE IF EXISTS int4_error_ints; CREATE TABLE int4_error_ints (v int4) DISTRIBUTED BY (v);\n' \ + 'INSERT INTO int4_error_ints(v) SELECT (random()*1000000 + 1000000)::int4 FROM generate_series(1,1000000);\n' + +test_million_query1 = \ + 'SELECT count(*) FROM (SELECT try_convert(v, NULL::int2) as v FROM text_ints) as t(v) WHERE v IS NOT NULL;\n' +test_million_query2 = \ + 'SELECT count(*) FROM (SELECT try_convert(v, NULL::int2) as v FROM text_error_ints) as t(v) WHERE v IS NULL;\n' + +test_million_query3 = \ + 'SELECT count(*) FROM (SELECT try_convert(v, NULL::int2) as v FROM int4_ints) as t(v) WHERE v IS NOT NULL;\n' +test_million_query4 = \ + 'SELECT count(*) FROM (SELECT try_convert(v, NULL::int2) as v FROM int4_error_ints) as t(v) WHERE v IS NULL;\n' + +test_million_result = \ + ' count \n' \ + '---------\n' \ + ' 1000000\n' \ + '(1 row)\n' \ + +test_million_in = test_million_data + test_million_query1 + test_million_query2 + test_million_query3 + test_million_query4 +test_million_out = test_million_data + \ + test_million_query1 + test_million_result + '\n' + \ + test_million_query2 + test_million_result + '\n' + \ + test_million_query3 + test_million_result + '\n' + \ + test_million_query4 + test_million_result + +### NESTED CASTS + +value = '42::int4' + +for level in range(100): + value = f'try_convert(try_convert({value}, NULL::text), NULL::int4)' + + +test_nested_query = f'select {value} as v;\n' + +test_nested_result = \ + ' v \n' \ + '----\n' \ + ' 42\n' \ + '(1 row)\n' \ + +test_nested_in = test_nested_query +test_nested_out = test_nested_query + test_nested_result + + +### CONSTRUCT TEST + +test_str = '\n'.join([ + test_header, \ + # FUNCTIONS + test_funcs, \ + # CREATE DATA + test_load_data, \ + '-- TEXT TESTS', \ + '\n'.join(text_tests_in), \ + '-- FUNCTION TESTS', \ + '\n'.join(function_tests_in), \ + '-- MILLION TESTS', \ + test_million_in, + '-- NESTED TESTS', \ + test_nested_in, + test_footer + ]) + '\n' + +test_f = open('input/try_convert.source', 'w') +test_f.write(test_str) + + +test_str = '\n'.join([ + remove_empty_lines(test_header), \ + # FUNCTIONS + remove_empty_lines(test_funcs), \ + # CREATE DATA + remove_empty_lines(test_load_data), \ + '-- TEXT TESTS', \ + '\n'.join(text_tests_out), \ + '-- FUNCTION TESTS', \ + '\n'.join(function_tests_out), \ + '-- MILLION TESTS', \ + test_million_out, + '-- NESTED TESTS', \ + test_nested_out, + remove_empty_lines(test_footer) + ]) + '\n' + +test_f = open('output/try_convert.source', 'w') +test_f.write(test_str) diff --git a/contrib/try_convert/input/try_convert.source b/contrib/try_convert/input/try_convert.source new file mode 100644 index 0000000000..c2a8f178d6 --- /dev/null +++ b/contrib/try_convert/input/try_convert.source @@ -0,0 +1,3133 @@ +-- SCRIPT-GENERATED TEST for TRY_CONVERT +-- Tests 31 types of 91 from pg_types.h +-- Tests 111 cast of 206 from pg_cast.h +-- Tests 1 types of 1 from extensions +-- Tests 5 casts of 8 from extensions + +create schema tryconvert; +set search_path = tryconvert; + +-- start_ignore +CREATE EXTENSION IF NOT EXISTS try_convert; +-- end_ignore + +select add_type_for_try_convert('int8'::regtype);select add_type_for_try_convert('int4'::regtype);select add_type_for_try_convert('int2'::regtype);select add_type_for_try_convert('float8'::regtype);select add_type_for_try_convert('float4'::regtype);select add_type_for_try_convert('numeric'::regtype);select add_type_for_try_convert('complex'::regtype);select add_type_for_try_convert('bool'::regtype);select add_type_for_try_convert('bit'::regtype);select add_type_for_try_convert('varbit'::regtype);select add_type_for_try_convert('date'::regtype);select add_type_for_try_convert('time'::regtype);select add_type_for_try_convert('timetz'::regtype);select add_type_for_try_convert('timestamp'::regtype);select add_type_for_try_convert('timestamptz'::regtype);select add_type_for_try_convert('interval'::regtype);select add_type_for_try_convert('abstime'::regtype);select add_type_for_try_convert('reltime'::regtype);select add_type_for_try_convert('point'::regtype);select add_type_for_try_convert('cidr'::regtype);select add_type_for_try_convert('inet'::regtype);select add_type_for_try_convert('macaddr'::regtype);select add_type_for_try_convert('json'::regtype);select add_type_for_try_convert('jsonb'::regtype);select add_type_for_try_convert('xml'::regtype);select add_type_for_try_convert('char'::regtype);select add_type_for_try_convert('varchar'::regtype);select add_type_for_try_convert('text'::regtype);select add_type_for_try_convert('money'::regtype);select add_type_for_try_convert('uuid'::regtype);select add_type_for_try_convert('regtype'::regtype);select add_type_for_try_convert('citext'::regtype);-- start_ignore +CREATE EXTENSION IF NOT EXISTS citext; +-- end_ignore + +CREATE FUNCTION try_convert_by_sql_text(_in text, INOUT _out ANYELEMENT, source_type text) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::%s::%s', $1, source_type, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_text_with_len_out(_in text, INOUT _out ANYELEMENT, source_type text, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::%s::%s(%s)', $1, source_type, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in int8, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::int8::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in int8, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::int8::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in int4, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::int4::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in int4, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::int4::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in int2, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::int2::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in int2, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::int2::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in float8, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::float8::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in float8, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::float8::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in float4, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::float4::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in float4, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::float4::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in numeric, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::numeric::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in numeric, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::numeric::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in complex, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::complex::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in complex, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::complex::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in bool, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::bool::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in bool, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::bool::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in bit, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::bit::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in bit, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::bit::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in varbit, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::varbit::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in varbit, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::varbit::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in date, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::date::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in date, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::date::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in time, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::time::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in time, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::time::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in timetz, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::timetz::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in timetz, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::timetz::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in timestamp, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::timestamp::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in timestamp, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::timestamp::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in timestamptz, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::timestamptz::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in timestamptz, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::timestamptz::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in interval, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::interval::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in interval, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::interval::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in abstime, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::abstime::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in abstime, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::abstime::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in reltime, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::reltime::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in reltime, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::reltime::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in point, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::point::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in point, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::point::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in cidr, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::cidr::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in cidr, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::cidr::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in inet, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::inet::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in inet, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::inet::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in macaddr, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::macaddr::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in macaddr, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::macaddr::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in json, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::json::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in json, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::json::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in jsonb, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::jsonb::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in jsonb, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::jsonb::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in xml, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::xml::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in xml, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::xml::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in char, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::char::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in char, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::char::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in varchar, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::varchar::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in varchar, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::varchar::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in text, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::text::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in text, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::text::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in money, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::money::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in money, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::money::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in uuid, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::uuid::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in uuid, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::uuid::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in regtype, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::regtype::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in regtype, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::regtype::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in citext, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::citext::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in citext, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::citext::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; + +-- LOAD DATA +CREATE TABLE tt_temp (v text) DISTRIBUTED BY (v); +CREATE TABLE tt_int8 (id serial, v int8) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_int8.data'; +INSERT INTO tt_int8(id, v) SELECT row_number() OVER(), v::int8 from tt_temp; +CREATE TABLE tt_text_of_int8 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_int8(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_int8 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_int8(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_int8 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_int8(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_int8 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_int8(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_int8 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_int8(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_int8 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_int8(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_int8 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_int8(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_int8 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_int8(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_int8 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_int8(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_int8 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_int8(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_int8 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_int8(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_int8 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_int8(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_int4 (id serial, v int4) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_int4.data'; +INSERT INTO tt_int4(id, v) SELECT row_number() OVER(), v::int4 from tt_temp; +CREATE TABLE tt_text_of_int4 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_int4(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_int4 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_int4(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_int4 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_int4(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_int4 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_int4(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_int4 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_int4(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_int4 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_int4(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_int4 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_int4(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_int4 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_int4(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_int4 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_int4(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_int4 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_int4(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_int4 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_int4(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_int4 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_int4(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_int2 (id serial, v int2) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_int2.data'; +INSERT INTO tt_int2(id, v) SELECT row_number() OVER(), v::int2 from tt_temp; +CREATE TABLE tt_text_of_int2 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_int2(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_int2 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_int2(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_int2 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_int2(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_int2 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_int2(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_int2 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_int2(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_int2 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_int2(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_int2 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_int2(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_int2 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_int2(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_int2 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_int2(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_int2 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_int2(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_int2 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_int2(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_int2 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_int2(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_float8 (id serial, v float8) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_float8.data'; +INSERT INTO tt_float8(id, v) SELECT row_number() OVER(), v::float8 from tt_temp; +CREATE TABLE tt_text_of_float8 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_float8(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_float8 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_float8(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_float8 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_float8(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_float8 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_float8(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_float8 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_float8(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_float8 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_float8(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_float8 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_float8(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_float8 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_float8(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_float8 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_float8(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_float8 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_float8(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_float8 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_float8(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_float8 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_float8(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_float4 (id serial, v float4) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_float4.data'; +INSERT INTO tt_float4(id, v) SELECT row_number() OVER(), v::float4 from tt_temp; +CREATE TABLE tt_text_of_float4 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_float4(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_float4 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_float4(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_float4 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_float4(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_float4 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_float4(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_float4 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_float4(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_float4 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_float4(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_float4 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_float4(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_float4 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_float4(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_float4 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_float4(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_float4 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_float4(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_float4 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_float4(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_float4 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_float4(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_numeric (id serial, v numeric) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_numeric.data'; +INSERT INTO tt_numeric(id, v) SELECT row_number() OVER(), v::numeric from tt_temp; +CREATE TABLE tt_text_of_numeric (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_numeric(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_numeric (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_numeric(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_numeric (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_numeric(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_numeric (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_numeric(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_numeric (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_numeric(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_numeric (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_numeric(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_numeric (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_numeric(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_numeric (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_numeric(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_numeric (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_numeric(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_numeric (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_numeric(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_numeric (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_numeric(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_numeric (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_numeric(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_complex (id serial, v complex) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_complex.data'; +INSERT INTO tt_complex(id, v) SELECT row_number() OVER(), v::complex from tt_temp; +CREATE TABLE tt_text_of_complex (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_complex(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_complex (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_complex(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_complex (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_complex(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_complex (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_complex(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_complex (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_complex(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_complex (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_complex(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_complex (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_complex(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_complex (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_complex(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_complex (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_complex(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_complex (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_complex(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_complex (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_complex(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_complex (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_complex(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_bool (id serial, v bool) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_bool.data'; +INSERT INTO tt_bool(id, v) SELECT row_number() OVER(), v::bool from tt_temp; +CREATE TABLE tt_text_of_bool (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_bool(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_bool (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_bool(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_bool (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_bool(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_bool (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_bool(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_bool (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_bool(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_bool (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_bool(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_bool (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_bool(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_bool (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_bool(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_bool (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_bool(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_bool (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_bool(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_bool (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_bool(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_bool (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_bool(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_bit (id serial, v bit) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_bit.data'; +INSERT INTO tt_bit(id, v) SELECT row_number() OVER(), v::bit from tt_temp; +CREATE TABLE tt_text_of_bit (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_bit(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_bit (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_bit(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_bit (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_bit(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_bit (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_bit(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_bit (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_bit(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_bit (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_bit(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_bit (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_bit(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_bit (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_bit(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_bit (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_bit(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_bit (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_bit(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_bit (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_bit(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_bit (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_bit(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_bit_1 (id serial, v bit(1)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_bit.data'; +INSERT INTO tt_bit_1(id, v) SELECT row_number() OVER(), v::bit(1) from tt_temp; +CREATE TABLE tt_text_of_bit_1 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::text from tt_temp; +CREATE TABLE tt_citext_of_bit_1 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::citext from tt_temp; +CREATE TABLE tt_char_of_bit_1 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::char from tt_temp; +CREATE TABLE tt_char_1_of_bit_1 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_bit_1 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_bit_1 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_bit_1 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_bit_1 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_bit_1 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_bit_1 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_bit_1 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_bit_1 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::varchar(20) from tt_temp; +CREATE TABLE tt_bit_5 (id serial, v bit(5)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_bit.data'; +INSERT INTO tt_bit_5(id, v) SELECT row_number() OVER(), v::bit(5) from tt_temp; +CREATE TABLE tt_text_of_bit_5 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::text from tt_temp; +CREATE TABLE tt_citext_of_bit_5 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::citext from tt_temp; +CREATE TABLE tt_char_of_bit_5 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::char from tt_temp; +CREATE TABLE tt_char_1_of_bit_5 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_bit_5 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_bit_5 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_bit_5 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_bit_5 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_bit_5 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_bit_5 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_bit_5 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_bit_5 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::varchar(20) from tt_temp; +CREATE TABLE tt_bit_10 (id serial, v bit(10)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_bit.data'; +INSERT INTO tt_bit_10(id, v) SELECT row_number() OVER(), v::bit(10) from tt_temp; +CREATE TABLE tt_text_of_bit_10 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::text from tt_temp; +CREATE TABLE tt_citext_of_bit_10 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::citext from tt_temp; +CREATE TABLE tt_char_of_bit_10 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::char from tt_temp; +CREATE TABLE tt_char_1_of_bit_10 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_bit_10 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_bit_10 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_bit_10 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_bit_10 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_bit_10 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_bit_10 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_bit_10 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_bit_10 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::varchar(20) from tt_temp; +CREATE TABLE tt_bit_20 (id serial, v bit(20)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_bit.data'; +INSERT INTO tt_bit_20(id, v) SELECT row_number() OVER(), v::bit(20) from tt_temp; +CREATE TABLE tt_text_of_bit_20 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::text from tt_temp; +CREATE TABLE tt_citext_of_bit_20 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::citext from tt_temp; +CREATE TABLE tt_char_of_bit_20 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::char from tt_temp; +CREATE TABLE tt_char_1_of_bit_20 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_bit_20 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_bit_20 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_bit_20 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_bit_20 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_bit_20 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_bit_20 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_bit_20 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_bit_20 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::varchar(20) from tt_temp; +CREATE TABLE tt_varbit (id serial, v varbit) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varbit.data'; +INSERT INTO tt_varbit(id, v) SELECT row_number() OVER(), v::varbit from tt_temp; +CREATE TABLE tt_text_of_varbit (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varbit(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_varbit (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varbit(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_varbit (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varbit(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_varbit (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varbit(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varbit (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varbit(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varbit (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varbit(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varbit (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varbit(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varbit (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varbit(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varbit (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varbit(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varbit (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varbit(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varbit (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varbit(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varbit (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varbit(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_varbit_1 (id serial, v varbit(1)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varbit.data'; +INSERT INTO tt_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1) from tt_temp; +CREATE TABLE tt_text_of_varbit_1 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::text from tt_temp; +CREATE TABLE tt_citext_of_varbit_1 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::citext from tt_temp; +CREATE TABLE tt_char_of_varbit_1 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::char from tt_temp; +CREATE TABLE tt_char_1_of_varbit_1 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varbit_1 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varbit_1 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varbit_1 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varbit_1 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varbit_1 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varbit_1 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varbit_1 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varbit_1 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::varchar(20) from tt_temp; +CREATE TABLE tt_varbit_5 (id serial, v varbit(5)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varbit.data'; +INSERT INTO tt_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5) from tt_temp; +CREATE TABLE tt_text_of_varbit_5 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::text from tt_temp; +CREATE TABLE tt_citext_of_varbit_5 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::citext from tt_temp; +CREATE TABLE tt_char_of_varbit_5 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::char from tt_temp; +CREATE TABLE tt_char_1_of_varbit_5 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varbit_5 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varbit_5 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varbit_5 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varbit_5 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varbit_5 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varbit_5 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varbit_5 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varbit_5 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::varchar(20) from tt_temp; +CREATE TABLE tt_varbit_10 (id serial, v varbit(10)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varbit.data'; +INSERT INTO tt_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10) from tt_temp; +CREATE TABLE tt_text_of_varbit_10 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::text from tt_temp; +CREATE TABLE tt_citext_of_varbit_10 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::citext from tt_temp; +CREATE TABLE tt_char_of_varbit_10 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::char from tt_temp; +CREATE TABLE tt_char_1_of_varbit_10 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varbit_10 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varbit_10 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varbit_10 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varbit_10 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varbit_10 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varbit_10 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varbit_10 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varbit_10 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::varchar(20) from tt_temp; +CREATE TABLE tt_varbit_20 (id serial, v varbit(20)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varbit.data'; +INSERT INTO tt_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20) from tt_temp; +CREATE TABLE tt_text_of_varbit_20 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::text from tt_temp; +CREATE TABLE tt_citext_of_varbit_20 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::citext from tt_temp; +CREATE TABLE tt_char_of_varbit_20 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::char from tt_temp; +CREATE TABLE tt_char_1_of_varbit_20 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varbit_20 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varbit_20 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varbit_20 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varbit_20 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varbit_20 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varbit_20 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varbit_20 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varbit_20 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::varchar(20) from tt_temp; +CREATE TABLE tt_date (id serial, v date) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_date.data'; +INSERT INTO tt_date(id, v) SELECT row_number() OVER(), v::date from tt_temp; +CREATE TABLE tt_text_of_date (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_date(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_date (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_date(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_date (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_date(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_date (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_date(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_date (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_date(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_date (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_date(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_date (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_date(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_date (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_date(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_date (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_date(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_date (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_date(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_date (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_date(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_date (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_date(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_time (id serial, v time) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_time.data'; +INSERT INTO tt_time(id, v) SELECT row_number() OVER(), v::time from tt_temp; +CREATE TABLE tt_text_of_time (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_time(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_time (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_time(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_time (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_time(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_time (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_time(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_time (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_time(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_time (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_time(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_time (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_time(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_time (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_time(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_time (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_time(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_time (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_time(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_time (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_time(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_time (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_time(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_timetz (id serial, v timetz) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_timetz.data'; +INSERT INTO tt_timetz(id, v) SELECT row_number() OVER(), v::timetz from tt_temp; +CREATE TABLE tt_text_of_timetz (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_timetz(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_timetz (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_timetz(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_timetz (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_timetz(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_timetz (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_timetz(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_timetz (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_timetz(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_timetz (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_timetz(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_timetz (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_timetz(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_timetz (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_timetz(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_timetz (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_timetz(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_timetz (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_timetz(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_timetz (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_timetz(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_timetz (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_timetz(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_timestamp (id serial, v timestamp) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_timestamp.data'; +INSERT INTO tt_timestamp(id, v) SELECT row_number() OVER(), v::timestamp from tt_temp; +CREATE TABLE tt_text_of_timestamp (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_timestamp(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_timestamp (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_timestamp(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_timestamp (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_timestamp(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_timestamp (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_timestamp(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_timestamp (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_timestamp(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_timestamp (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_timestamp(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_timestamp (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_timestamp(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_timestamp (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_timestamp(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_timestamp (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_timestamp(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_timestamp (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_timestamp(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_timestamp (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_timestamp(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_timestamp (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_timestamp(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_timestamptz (id serial, v timestamptz) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_timestamptz.data'; +INSERT INTO tt_timestamptz(id, v) SELECT row_number() OVER(), v::timestamptz from tt_temp; +CREATE TABLE tt_text_of_timestamptz (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_timestamptz(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_timestamptz (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_timestamptz(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_timestamptz (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_timestamptz(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_timestamptz (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_timestamptz(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_timestamptz (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_timestamptz(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_timestamptz (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_timestamptz(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_timestamptz (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_timestamptz(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_timestamptz (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_timestamptz(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_timestamptz (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_timestamptz(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_timestamptz (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_timestamptz(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_timestamptz (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_timestamptz(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_timestamptz (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_timestamptz(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_interval (id serial, v interval) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_interval.data'; +INSERT INTO tt_interval(id, v) SELECT row_number() OVER(), v::interval from tt_temp; +CREATE TABLE tt_text_of_interval (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_interval(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_interval (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_interval(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_interval (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_interval(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_interval (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_interval(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_interval (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_interval(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_interval (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_interval(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_interval (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_interval(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_interval (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_interval(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_interval (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_interval(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_interval (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_interval(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_interval (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_interval(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_interval (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_interval(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_abstime (id serial, v abstime) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_abstime.data'; +INSERT INTO tt_abstime(id, v) SELECT row_number() OVER(), v::abstime from tt_temp; +CREATE TABLE tt_text_of_abstime (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_abstime(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_abstime (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_abstime(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_abstime (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_abstime(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_abstime (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_abstime(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_abstime (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_abstime(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_abstime (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_abstime(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_abstime (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_abstime(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_abstime (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_abstime(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_abstime (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_abstime(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_abstime (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_abstime(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_abstime (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_abstime(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_abstime (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_abstime(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_reltime (id serial, v reltime) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_reltime.data'; +INSERT INTO tt_reltime(id, v) SELECT row_number() OVER(), v::reltime from tt_temp; +CREATE TABLE tt_text_of_reltime (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_reltime(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_reltime (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_reltime(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_reltime (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_reltime(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_reltime (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_reltime(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_reltime (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_reltime(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_reltime (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_reltime(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_reltime (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_reltime(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_reltime (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_reltime(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_reltime (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_reltime(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_reltime (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_reltime(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_reltime (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_reltime(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_reltime (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_reltime(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_point (id serial, v point) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_point.data'; +INSERT INTO tt_point(id, v) SELECT row_number() OVER(), v::point from tt_temp; +CREATE TABLE tt_text_of_point (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_point(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_point (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_point(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_point (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_point(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_point (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_point(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_point (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_point(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_point (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_point(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_point (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_point(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_point (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_point(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_point (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_point(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_point (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_point(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_point (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_point(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_point (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_point(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_cidr (id serial, v cidr) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_cidr.data'; +INSERT INTO tt_cidr(id, v) SELECT row_number() OVER(), v::cidr from tt_temp; +CREATE TABLE tt_text_of_cidr (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_cidr(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_cidr (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_cidr(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_cidr (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_cidr(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_cidr (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_cidr(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_cidr (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_cidr(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_cidr (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_cidr(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_cidr (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_cidr(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_cidr (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_cidr(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_cidr (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_cidr(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_cidr (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_cidr(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_cidr (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_cidr(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_cidr (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_cidr(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_inet (id serial, v inet) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_inet.data'; +INSERT INTO tt_inet(id, v) SELECT row_number() OVER(), v::inet from tt_temp; +CREATE TABLE tt_text_of_inet (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_inet(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_inet (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_inet(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_inet (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_inet(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_inet (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_inet(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_inet (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_inet(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_inet (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_inet(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_inet (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_inet(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_inet (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_inet(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_inet (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_inet(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_inet (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_inet(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_inet (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_inet(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_inet (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_inet(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_macaddr (id serial, v macaddr) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_macaddr.data'; +INSERT INTO tt_macaddr(id, v) SELECT row_number() OVER(), v::macaddr from tt_temp; +CREATE TABLE tt_text_of_macaddr (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_macaddr(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_macaddr (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_macaddr(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_macaddr (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_macaddr(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_macaddr (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_macaddr(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_macaddr (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_macaddr(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_macaddr (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_macaddr(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_macaddr (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_macaddr(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_macaddr (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_macaddr(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_macaddr (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_macaddr(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_macaddr (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_macaddr(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_macaddr (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_macaddr(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_macaddr (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_macaddr(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_json (id serial, v json) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_json.data'; +INSERT INTO tt_json(id, v) SELECT row_number() OVER(), v::json from tt_temp; +CREATE TABLE tt_text_of_json (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_json(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_json (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_json(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_json (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_json(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_json (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_json(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_json (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_json(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_json (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_json(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_json (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_json(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_json (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_json(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_json (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_json(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_json (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_json(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_json (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_json(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_json (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_json(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_jsonb (id serial, v jsonb) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_jsonb.data'; +INSERT INTO tt_jsonb(id, v) SELECT row_number() OVER(), v::jsonb from tt_temp; +CREATE TABLE tt_text_of_jsonb (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_jsonb(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_jsonb (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_jsonb(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_jsonb (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_jsonb(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_jsonb (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_jsonb(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_jsonb (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_jsonb(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_jsonb (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_jsonb(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_jsonb (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_jsonb(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_jsonb (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_jsonb(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_jsonb (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_jsonb(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_jsonb (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_jsonb(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_jsonb (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_jsonb(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_jsonb (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_jsonb(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_xml (id serial, v xml) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_xml.data'; +INSERT INTO tt_xml(id, v) SELECT row_number() OVER(), v::xml from tt_temp; +CREATE TABLE tt_text_of_xml (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_xml(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_xml (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_xml(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_xml (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_xml(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_xml (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_xml(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_xml (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_xml(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_xml (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_xml(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_xml (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_xml(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_xml (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_xml(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_xml (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_xml(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_xml (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_xml(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_xml (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_xml(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_xml (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_xml(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_char (id serial, v char) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_char.data'; +INSERT INTO tt_char(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_text_of_char (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_char(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_char (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_char(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_char (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_char(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_char (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_char(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_char (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_char(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_char (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_char(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_char (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_char(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_char (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_char(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_char (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_char(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_char (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_char(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_char (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_char(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_char (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_char(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_char_1 (id serial, v char(1)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_char.data'; +INSERT INTO tt_char_1(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_text_of_char_1 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::text from tt_temp; +CREATE TABLE tt_citext_of_char_1 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::citext from tt_temp; +CREATE TABLE tt_char_of_char_1 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::char from tt_temp; +CREATE TABLE tt_char_1_of_char_1 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_char_1 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_char_1 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_char_1 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_char_1 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_char_1 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_char_1 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_char_1 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_char_1 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::varchar(20) from tt_temp; +CREATE TABLE tt_char_5 (id serial, v char(5)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_char.data'; +INSERT INTO tt_char_5(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_text_of_char_5 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::text from tt_temp; +CREATE TABLE tt_citext_of_char_5 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::citext from tt_temp; +CREATE TABLE tt_char_of_char_5 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::char from tt_temp; +CREATE TABLE tt_char_1_of_char_5 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_char_5 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_char_5 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_char_5 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_char_5 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_char_5 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_char_5 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_char_5 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_char_5 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::varchar(20) from tt_temp; +CREATE TABLE tt_char_10 (id serial, v char(10)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_char.data'; +INSERT INTO tt_char_10(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_text_of_char_10 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::text from tt_temp; +CREATE TABLE tt_citext_of_char_10 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::citext from tt_temp; +CREATE TABLE tt_char_of_char_10 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::char from tt_temp; +CREATE TABLE tt_char_1_of_char_10 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_char_10 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_char_10 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_char_10 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_char_10 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_char_10 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_char_10 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_char_10 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_char_10 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::varchar(20) from tt_temp; +CREATE TABLE tt_char_20 (id serial, v char(20)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_char.data'; +INSERT INTO tt_char_20(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_text_of_char_20 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::text from tt_temp; +CREATE TABLE tt_citext_of_char_20 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::citext from tt_temp; +CREATE TABLE tt_char_of_char_20 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::char from tt_temp; +CREATE TABLE tt_char_1_of_char_20 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_char_20 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_char_20 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_char_20 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_char_20 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_char_20 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_char_20 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_char_20 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_char_20 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::varchar(20) from tt_temp; +CREATE TABLE tt_varchar (id serial, v varchar) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varchar.data'; +INSERT INTO tt_varchar(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_text_of_varchar (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varchar(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_varchar (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varchar(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_varchar (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varchar(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_varchar (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varchar(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varchar (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varchar(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varchar (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varchar(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varchar (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varchar(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varchar (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varchar(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varchar (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varchar(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varchar (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varchar(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varchar (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varchar(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varchar (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varchar(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_varchar_1 (id serial, v varchar(1)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varchar.data'; +INSERT INTO tt_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_text_of_varchar_1 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::text from tt_temp; +CREATE TABLE tt_citext_of_varchar_1 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::citext from tt_temp; +CREATE TABLE tt_char_of_varchar_1 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::char from tt_temp; +CREATE TABLE tt_char_1_of_varchar_1 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varchar_1 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varchar_1 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varchar_1 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varchar_1 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varchar_1 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varchar_1 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varchar_1 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varchar_1 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::varchar(20) from tt_temp; +CREATE TABLE tt_varchar_5 (id serial, v varchar(5)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varchar.data'; +INSERT INTO tt_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_text_of_varchar_5 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::text from tt_temp; +CREATE TABLE tt_citext_of_varchar_5 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::citext from tt_temp; +CREATE TABLE tt_char_of_varchar_5 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::char from tt_temp; +CREATE TABLE tt_char_1_of_varchar_5 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varchar_5 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varchar_5 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varchar_5 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varchar_5 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varchar_5 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varchar_5 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varchar_5 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varchar_5 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::varchar(20) from tt_temp; +CREATE TABLE tt_varchar_10 (id serial, v varchar(10)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varchar.data'; +INSERT INTO tt_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_text_of_varchar_10 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::text from tt_temp; +CREATE TABLE tt_citext_of_varchar_10 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::citext from tt_temp; +CREATE TABLE tt_char_of_varchar_10 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::char from tt_temp; +CREATE TABLE tt_char_1_of_varchar_10 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varchar_10 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varchar_10 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varchar_10 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varchar_10 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varchar_10 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varchar_10 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varchar_10 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varchar_10 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::varchar(20) from tt_temp; +CREATE TABLE tt_varchar_20 (id serial, v varchar(20)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varchar.data'; +INSERT INTO tt_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_text_of_varchar_20 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::text from tt_temp; +CREATE TABLE tt_citext_of_varchar_20 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::citext from tt_temp; +CREATE TABLE tt_char_of_varchar_20 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::char from tt_temp; +CREATE TABLE tt_char_1_of_varchar_20 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varchar_20 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varchar_20 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varchar_20 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varchar_20 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varchar_20 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varchar_20 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varchar_20 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varchar_20 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::varchar(20) from tt_temp; +CREATE TABLE tt_text (id serial, v text) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_text.data'; +INSERT INTO tt_text(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_text_of_text (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_text(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_text (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_text(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_text (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_text(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_text (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_text(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_text (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_text(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_text (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_text(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_text (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_text(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_text (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_text(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_text (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_text(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_text (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_text(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_text (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_text(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_text (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_text(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_money (id serial, v money) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_money.data'; +INSERT INTO tt_money(id, v) SELECT row_number() OVER(), v::money from tt_temp; +CREATE TABLE tt_text_of_money (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_money(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_money (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_money(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_money (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_money(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_money (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_money(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_money (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_money(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_money (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_money(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_money (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_money(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_money (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_money(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_money (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_money(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_money (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_money(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_money (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_money(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_money (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_money(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_uuid (id serial, v uuid) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_uuid.data'; +INSERT INTO tt_uuid(id, v) SELECT row_number() OVER(), v::uuid from tt_temp; +CREATE TABLE tt_text_of_uuid (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_uuid(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_uuid (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_uuid(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_uuid (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_uuid(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_uuid (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_uuid(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_uuid (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_uuid(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_uuid (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_uuid(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_uuid (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_uuid(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_uuid (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_uuid(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_uuid (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_uuid(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_uuid (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_uuid(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_uuid (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_uuid(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_uuid (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_uuid(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_regtype (id serial, v regtype) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_regtype.data'; +INSERT INTO tt_regtype(id, v) SELECT row_number() OVER(), v::regtype from tt_temp; +CREATE TABLE tt_text_of_regtype (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_regtype(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_regtype (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_regtype(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_regtype (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_regtype(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_regtype (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_regtype(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_regtype (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_regtype(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_regtype (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_regtype(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_regtype (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_regtype(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_regtype (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_regtype(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_regtype (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_regtype(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_regtype (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_regtype(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_regtype (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_regtype(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_regtype (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_regtype(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_citext (id serial, v citext) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_citext.data'; +INSERT INTO tt_citext(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_text_of_citext (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_citext(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_citext (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_citext(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_citext (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_citext(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_citext (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_citext(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_citext (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_citext(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_citext (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_citext(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_citext (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_citext(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_citext (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_citext(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_citext (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_citext(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_citext (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_citext(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_citext (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_citext(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_citext (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_citext(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; + +-- TEXT TESTS +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_text_of_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_text_of_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_text_of_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_text_of_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_text_of_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_text_of_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_complex) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_text_of_complex) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bool) as v1, try_convert_by_sql(v, NULL::bool) as v2 from tt_text_of_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_text_of_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_text_of_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_text_of_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_text_of_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_text_of_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql(v, NULL::varbit) as v2 from tt_text_of_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 1) as v2 from tt_text_of_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 5) as v2 from tt_text_of_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 10) as v2 from tt_text_of_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 20) as v2 from tt_text_of_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_text_of_date) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_text_of_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_text_of_timetz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_text_of_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_text_of_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_text_of_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_text_of_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::reltime) as v1, try_convert_by_sql(v, NULL::reltime) as v2 from tt_text_of_reltime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_point) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::point) as v1, try_convert_by_sql(v, NULL::point) as v2 from tt_text_of_point) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::cidr) as v1, try_convert_by_sql(v, NULL::cidr) as v2 from tt_text_of_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::inet) as v1, try_convert_by_sql(v, NULL::inet) as v2 from tt_text_of_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_macaddr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::macaddr) as v1, try_convert_by_sql(v, NULL::macaddr) as v2 from tt_text_of_macaddr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_json) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::json) as v1, try_convert_by_sql(v, NULL::json) as v2 from tt_text_of_json) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_jsonb) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::jsonb) as v1, try_convert_by_sql(v, NULL::jsonb) as v2 from tt_text_of_jsonb) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql(v, NULL::xml) as v2 from tt_text_of_xml) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_text_of_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_text_of_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_text_of_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_text_of_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_text_of_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_text_of_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_text_of_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_text_of_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_text_of_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_text_of_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_text_of_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_money) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_text_of_money) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_uuid) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::uuid) as v1, try_convert_by_sql(v, NULL::uuid) as v2 from tt_text_of_uuid) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_text_of_regtype) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_text_of_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_citext_of_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_citext_of_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_citext_of_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_citext_of_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_citext_of_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_citext_of_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_complex) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_citext_of_complex) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bool) as v1, try_convert_by_sql(v, NULL::bool) as v2 from tt_citext_of_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_citext_of_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_citext_of_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_citext_of_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_citext_of_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_citext_of_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql(v, NULL::varbit) as v2 from tt_citext_of_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 1) as v2 from tt_citext_of_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 5) as v2 from tt_citext_of_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 10) as v2 from tt_citext_of_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 20) as v2 from tt_citext_of_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_citext_of_date) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_citext_of_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_citext_of_timetz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_citext_of_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_citext_of_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_citext_of_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_citext_of_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::reltime) as v1, try_convert_by_sql(v, NULL::reltime) as v2 from tt_citext_of_reltime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_point) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::point) as v1, try_convert_by_sql(v, NULL::point) as v2 from tt_citext_of_point) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::cidr) as v1, try_convert_by_sql(v, NULL::cidr) as v2 from tt_citext_of_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::inet) as v1, try_convert_by_sql(v, NULL::inet) as v2 from tt_citext_of_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_macaddr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::macaddr) as v1, try_convert_by_sql(v, NULL::macaddr) as v2 from tt_citext_of_macaddr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_json) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::json) as v1, try_convert_by_sql(v, NULL::json) as v2 from tt_citext_of_json) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_jsonb) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::jsonb) as v1, try_convert_by_sql(v, NULL::jsonb) as v2 from tt_citext_of_jsonb) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql(v, NULL::xml) as v2 from tt_citext_of_xml) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_citext_of_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_citext_of_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_citext_of_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_citext_of_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_citext_of_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_citext_of_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_citext_of_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_citext_of_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_citext_of_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_citext_of_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_citext_of_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_money) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_citext_of_money) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_uuid) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::uuid) as v1, try_convert_by_sql(v, NULL::uuid) as v2 from tt_citext_of_uuid) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_citext_of_regtype) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_citext_of_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_char_of_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_char_of_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_char_of_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_char_of_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_char_of_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_char_of_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_complex) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_char_of_complex) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bool) as v1, try_convert_by_sql(v, NULL::bool) as v2 from tt_char_of_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_char_of_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_char_of_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_char_of_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_char_of_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_char_of_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql(v, NULL::varbit) as v2 from tt_char_of_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 1) as v2 from tt_char_of_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 5) as v2 from tt_char_of_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 10) as v2 from tt_char_of_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 20) as v2 from tt_char_of_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_char_of_date) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_char_of_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_char_of_timetz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_char_of_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_char_of_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_char_of_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_char_of_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::reltime) as v1, try_convert_by_sql(v, NULL::reltime) as v2 from tt_char_of_reltime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_point) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::point) as v1, try_convert_by_sql(v, NULL::point) as v2 from tt_char_of_point) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::cidr) as v1, try_convert_by_sql(v, NULL::cidr) as v2 from tt_char_of_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::inet) as v1, try_convert_by_sql(v, NULL::inet) as v2 from tt_char_of_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_macaddr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::macaddr) as v1, try_convert_by_sql(v, NULL::macaddr) as v2 from tt_char_of_macaddr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_json) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::json) as v1, try_convert_by_sql(v, NULL::json) as v2 from tt_char_of_json) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_jsonb) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::jsonb) as v1, try_convert_by_sql(v, NULL::jsonb) as v2 from tt_char_of_jsonb) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql(v, NULL::xml) as v2 from tt_char_of_xml) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_char_of_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_char_of_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_char_of_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_char_of_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_char_of_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_char_of_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_char_of_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_char_of_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_char_of_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_char_of_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_char_of_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_money) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_char_of_money) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_uuid) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::uuid) as v1, try_convert_by_sql(v, NULL::uuid) as v2 from tt_char_of_uuid) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_char_of_regtype) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_char_of_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_varchar_of_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_varchar_of_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_varchar_of_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_varchar_of_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_varchar_of_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_varchar_of_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_complex) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_varchar_of_complex) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bool) as v1, try_convert_by_sql(v, NULL::bool) as v2 from tt_varchar_of_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_varchar_of_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_varchar_of_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_varchar_of_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_varchar_of_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_varchar_of_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql(v, NULL::varbit) as v2 from tt_varchar_of_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 1) as v2 from tt_varchar_of_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 5) as v2 from tt_varchar_of_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 10) as v2 from tt_varchar_of_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 20) as v2 from tt_varchar_of_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_varchar_of_date) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_varchar_of_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_varchar_of_timetz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_varchar_of_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_varchar_of_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_varchar_of_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_varchar_of_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::reltime) as v1, try_convert_by_sql(v, NULL::reltime) as v2 from tt_varchar_of_reltime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_point) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::point) as v1, try_convert_by_sql(v, NULL::point) as v2 from tt_varchar_of_point) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::cidr) as v1, try_convert_by_sql(v, NULL::cidr) as v2 from tt_varchar_of_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::inet) as v1, try_convert_by_sql(v, NULL::inet) as v2 from tt_varchar_of_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_macaddr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::macaddr) as v1, try_convert_by_sql(v, NULL::macaddr) as v2 from tt_varchar_of_macaddr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_json) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::json) as v1, try_convert_by_sql(v, NULL::json) as v2 from tt_varchar_of_json) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_jsonb) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::jsonb) as v1, try_convert_by_sql(v, NULL::jsonb) as v2 from tt_varchar_of_jsonb) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql(v, NULL::xml) as v2 from tt_varchar_of_xml) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_varchar_of_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_varchar_of_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_varchar_of_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_varchar_of_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_varchar_of_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_varchar_of_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_varchar_of_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_varchar_of_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_varchar_of_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_varchar_of_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_varchar_of_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_money) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_varchar_of_money) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_uuid) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::uuid) as v1, try_convert_by_sql(v, NULL::uuid) as v2 from tt_varchar_of_uuid) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_varchar_of_regtype) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_varchar_of_citext) as t(v1, v2) where v1 is distinct from v2; +-- FUNCTION TESTS +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '6'::int2) as v1, try_convert_by_sql(v, '6'::int2) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '5.09526'::float4) as v1, try_convert_by_sql(v, '5.09526'::float4) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2.6338905075109076'::float8) as v1, try_convert_by_sql(v, '2.6338905075109076'::float8) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '5.09526'::float4) as v1, try_convert_by_sql(v, '5.09526'::float4) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2.6338905075109076'::float8) as v1, try_convert_by_sql(v, '2.6338905075109076'::float8) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '6'::int2) as v1, try_convert_by_sql(v, '6'::int2) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '5.09526'::float4) as v1, try_convert_by_sql(v, '5.09526'::float4) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2.6338905075109076'::float8) as v1, try_convert_by_sql(v, '2.6338905075109076'::float8) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '6'::int2) as v1, try_convert_by_sql(v, '6'::int2) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2.6338905075109076'::float8) as v1, try_convert_by_sql(v, '2.6338905075109076'::float8) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '6'::int2) as v1, try_convert_by_sql(v, '6'::int2) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '5.09526'::float4) as v1, try_convert_by_sql(v, '5.09526'::float4) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '6'::int2) as v1, try_convert_by_sql(v, '6'::int2) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '5.09526'::float4) as v1, try_convert_by_sql(v, '5.09526'::float4) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2.6338905075109076'::float8) as v1, try_convert_by_sql(v, '2.6338905075109076'::float8) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_money) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_money) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '10'::money) as v1, try_convert_by_sql(v, '10'::money) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '10'::money) as v1, try_convert_by_sql(v, '10'::money) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '10'::money) as v1, try_convert_by_sql(v, '10'::money) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bool) as v1, try_convert_by_sql(v, NULL::bool) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'f'::bool) as v1, try_convert_by_sql(v, 'f'::bool) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'bool'::regtype) as v1, try_convert_by_sql(v, 'bool'::regtype) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'bool'::regtype) as v1, try_convert_by_sql(v, 'bool'::regtype) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'bool'::regtype) as v1, try_convert_by_sql(v, 'bool'::regtype) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(1)'::text, 1) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(1)'::text, 5) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(1)'::text, 10) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(1)'::text, 20) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(5)'::text, 1) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(5)'::text, 5) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(5)'::text, 10) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(5)'::text, 20) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(10)'::text, 1) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(10)'::text, 5) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(10)'::text, 10) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(10)'::text, 20) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(20)'::text, 1) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(20)'::text, 5) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(20)'::text, 10) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(20)'::text, 20) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(1)'::text, 1) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(1)'::text, 5) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(1)'::text, 10) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(1)'::text, 20) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(5)'::text, 1) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(5)'::text, 5) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(5)'::text, 10) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(5)'::text, 20) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(10)'::text, 1) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(10)'::text, 5) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(10)'::text, 10) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(10)'::text, 20) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(20)'::text, 1) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(20)'::text, 5) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(20)'::text, 10) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(20)'::text, 20) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::char) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 1) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 5) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 10) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 20) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(1)'::text, 1) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(1)'::text, 5) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(1)'::text, 10) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(1)'::text, 20) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(5)'::text, 1) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(5)'::text, 5) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(5)'::text, 10) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(5)'::text, 20) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(10)'::text, 1) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(10)'::text, 5) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(10)'::text, 10) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(10)'::text, 20) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(20)'::text, 1) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(20)'::text, 5) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(20)'::text, 10) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(20)'::text, 20) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::char) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 1) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 5) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 10) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 20) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::char, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(1)'::text, 1) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(1)'::text, 5) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(1)'::text, 10) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(1)'::text, 20) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::char, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(5)'::text, 1) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(5)'::text, 5) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(5)'::text, 10) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(5)'::text, 20) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::char, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(10)'::text, 1) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(10)'::text, 5) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(10)'::text, 10) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(10)'::text, 20) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::char, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(20)'::text, 1) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(20)'::text, 5) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(20)'::text, 10) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(20)'::text, 20) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::char) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 1) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 5) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 10) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 20) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28'::date) as v1, try_convert_by_sql(v, '2015-10-28'::date) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '13:35:45'::time) as v1, try_convert_by_sql(v, '13:35:45'::time) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28 16:35:45'::timestamp) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::timestamp) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v1, try_convert_by_sql(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '16736 days, 13:35:45'::interval) as v1, try_convert_by_sql(v, '16736 days, 13:35:45'::interval) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28 16:35:45'::timestamp) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::timestamp) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v1, try_convert_by_sql(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '16736 days, 13:35:45'::interval) as v1, try_convert_by_sql(v, '16736 days, 13:35:45'::interval) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '13:35:45 UTC'::timetz) as v1, try_convert_by_sql(v, '13:35:45 UTC'::timetz) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28 16:35:45'::abstime) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::abstime) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28'::date) as v1, try_convert_by_sql(v, '2015-10-28'::date) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '13:35:45'::time) as v1, try_convert_by_sql(v, '13:35:45'::time) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v1, try_convert_by_sql(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28 16:35:45'::abstime) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::abstime) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28'::date) as v1, try_convert_by_sql(v, '2015-10-28'::date) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '13:35:45'::time) as v1, try_convert_by_sql(v, '13:35:45'::time) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28 16:35:45'::timestamp) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::timestamp) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '13:35:45 UTC'::timetz) as v1, try_convert_by_sql(v, '13:35:45 UTC'::timetz) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::reltime) as v1, try_convert_by_sql(v, NULL::reltime) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '16736 days, 13:35:45'::reltime) as v1, try_convert_by_sql(v, '16736 days, 13:35:45'::reltime) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '13:35:45'::time) as v1, try_convert_by_sql(v, '13:35:45'::time) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '13:35:45'::time) as v1, try_convert_by_sql(v, '13:35:45'::time) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28 16:35:45'::abstime) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::abstime) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::reltime) as v1, try_convert_by_sql(v, NULL::reltime) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '16736 days, 13:35:45'::reltime) as v1, try_convert_by_sql(v, '16736 days, 13:35:45'::reltime) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::inet) as v1, try_convert_by_sql(v, NULL::inet) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '192.168.100.128/25'::inet) as v1, try_convert_by_sql(v, '192.168.100.128/25'::inet) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::cidr) as v1, try_convert_by_sql(v, NULL::cidr) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '192.168.100.128/25'::cidr) as v1, try_convert_by_sql(v, '192.168.100.128/25'::cidr) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql(v, NULL::varbit) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 1) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 5) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 10) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 20) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(1)'::text, 1) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(1)'::text, 5) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(1)'::text, 10) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(1)'::text, 20) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(5)'::text, 1) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(5)'::text, 5) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(5)'::text, 10) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(5)'::text, 20) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(10)'::text, 1) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(10)'::text, 5) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(10)'::text, 10) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(10)'::text, 20) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(20)'::text, 1) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(20)'::text, 5) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(20)'::text, 10) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(20)'::text, 20) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql(v, '1'::varbit) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 1) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 5) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 10) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 20) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(1)'::text, 1) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(1)'::text, 5) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(1)'::text, 10) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(1)'::text, 20) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(5)'::text, 1) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(5)'::text, 5) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(5)'::text, 10) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(5)'::text, 20) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(10)'::text, 1) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(10)'::text, 5) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(10)'::text, 10) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(10)'::text, 20) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(20)'::text, 1) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(20)'::text, 5) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(20)'::text, 10) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(20)'::text, 20) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(1)'::text, 1) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(1)'::text, 5) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(1)'::text, 10) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(1)'::text, 20) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(5)'::text, 1) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(5)'::text, 5) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(5)'::text, 10) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(5)'::text, 20) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(10)'::text, 1) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(10)'::text, 5) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(10)'::text, 10) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(10)'::text, 20) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(20)'::text, 1) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(20)'::text, 5) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(20)'::text, 10) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(20)'::text, 20) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql(v, '1'::bit) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 1) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 5) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 10) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 20) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(1)'::text, 1) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(1)'::text, 5) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(1)'::text, 10) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(1)'::text, 20) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(5)'::text, 1) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(5)'::text, 5) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(5)'::text, 10) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(5)'::text, 20) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(10)'::text, 1) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(10)'::text, 5) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(10)'::text, 10) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(10)'::text, 20) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(20)'::text, 1) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(20)'::text, 5) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(20)'::text, 10) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(20)'::text, 20) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql(v, '1'::bit) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 1) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 5) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 10) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 20) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql(v, '1'::bit) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 1) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 5) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 10) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 20) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql_text(v::text, NULL::int8, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql_text(v::text, NULL::int8, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql_text(v::text, NULL::int8, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql_text(v::text, NULL::int8, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql_text(v::text, '2'::int8, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql_text(v::text, '2'::int8, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql_text(v::text, '2'::int8, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql_text(v::text, '2'::int8, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql(v, NULL::xml) as v2 from tt_text) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, ' '::xml) as v1, try_convert_by_sql(v, ' '::xml) as v2 from tt_text) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql(v, NULL::xml) as v2 from tt_varchar) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql_text(v::text, NULL::xml, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql_text(v::text, NULL::xml, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql_text(v::text, NULL::xml, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql_text(v::text, NULL::xml, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, ' '::xml) as v1, try_convert_by_sql(v, ' '::xml) as v2 from tt_varchar) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, ' '::xml) as v1, try_convert_by_sql_text(v::text, ' '::xml, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, ' '::xml) as v1, try_convert_by_sql_text(v::text, ' '::xml, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, ' '::xml) as v1, try_convert_by_sql_text(v::text, ' '::xml, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, ' '::xml) as v1, try_convert_by_sql_text(v::text, ' '::xml, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(1)'::text, 1) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(1)'::text, 5) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(1)'::text, 10) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(1)'::text, 20) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(5)'::text, 1) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(5)'::text, 5) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(5)'::text, 10) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(5)'::text, 20) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(10)'::text, 1) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(10)'::text, 5) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(10)'::text, 10) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(10)'::text, 20) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(20)'::text, 1) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(20)'::text, 5) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(20)'::text, 10) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(20)'::text, 20) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(1)'::text, 1) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(1)'::text, 5) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(1)'::text, 10) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(1)'::text, 20) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(5)'::text, 1) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(5)'::text, 5) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(5)'::text, 10) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(5)'::text, 20) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(10)'::text, 1) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(10)'::text, 5) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(10)'::text, 10) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(10)'::text, 20) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(20)'::text, 1) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(20)'::text, 5) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(20)'::text, 10) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(20)'::text, 20) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '13:35:45'::time) as v1, try_convert_by_sql(v, '13:35:45'::time) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28 16:35:45'::timestamp) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::timestamp) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v1, try_convert_by_sql(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '16736 days, 13:35:45'::interval) as v1, try_convert_by_sql(v, '16736 days, 13:35:45'::interval) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '13:35:45 UTC'::timetz) as v1, try_convert_by_sql(v, '13:35:45 UTC'::timetz) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(1)'::text, 1) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(1)'::text, 5) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(1)'::text, 10) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(1)'::text, 20) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(5)'::text, 1) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(5)'::text, 5) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(5)'::text, 10) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(5)'::text, 20) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(10)'::text, 1) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(10)'::text, 5) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(10)'::text, 10) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(10)'::text, 20) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(20)'::text, 1) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(20)'::text, 5) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(20)'::text, 10) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(20)'::text, 20) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql(v, '1'::bit) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 1) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 5) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 10) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 20) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(1)'::text, 1) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(1)'::text, 5) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(1)'::text, 10) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(1)'::text, 20) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(5)'::text, 1) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(5)'::text, 5) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(5)'::text, 10) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(5)'::text, 20) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(10)'::text, 1) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(10)'::text, 5) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(10)'::text, 10) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(10)'::text, 20) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(20)'::text, 1) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(20)'::text, 5) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(20)'::text, 10) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(20)'::text, 20) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql(v, NULL::varbit) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 1) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 5) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 10) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 20) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(1)'::text, 1) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(1)'::text, 5) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(1)'::text, 10) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(1)'::text, 20) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(5)'::text, 1) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(5)'::text, 5) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(5)'::text, 10) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(5)'::text, 20) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(10)'::text, 1) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(10)'::text, 5) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(10)'::text, 10) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(10)'::text, 20) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(20)'::text, 1) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(20)'::text, 5) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(20)'::text, 10) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(20)'::text, 20) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql(v, '1'::varbit) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 1) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 5) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 10) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 20) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(1)'::text, 1) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(1)'::text, 5) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(1)'::text, 10) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(1)'::text, 20) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(5)'::text, 1) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(5)'::text, 5) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(5)'::text, 10) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(5)'::text, 20) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(10)'::text, 1) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(10)'::text, 5) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(10)'::text, 10) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(10)'::text, 20) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(20)'::text, 1) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(20)'::text, 5) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(20)'::text, 10) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(20)'::text, 20) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::jsonb) as v1, try_convert_by_sql(v, NULL::jsonb) as v2 from tt_json) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '{"glossary": {"title": "example glossary","GlossDiv": {"title": "S","GlossList": {"GlossEntry": {"ID": "SGML","SortAs": "SGML","GlossTerm": "Standard Generalized Markup Language","Acronym": "SGML","Abbrev": "ISO 8879:1986","GlossDef": {"para": "A meta-markup language, used to create markup languages such as DocBook.","GlossSeeAlso": ["GML", "XML"]},"GlossSee": "markup"}}}}}'::jsonb) as v1, try_convert_by_sql(v, '{"glossary": {"title": "example glossary","GlossDiv": {"title": "S","GlossList": {"GlossEntry": {"ID": "SGML","SortAs": "SGML","GlossTerm": "Standard Generalized Markup Language","Acronym": "SGML","Abbrev": "ISO 8879:1986","GlossDef": {"para": "A meta-markup language, used to create markup languages such as DocBook.","GlossSeeAlso": ["GML", "XML"]},"GlossSee": "markup"}}}}}'::jsonb) as v2 from tt_json) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::json) as v1, try_convert_by_sql(v, NULL::json) as v2 from tt_jsonb) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, '{"glossary": {"title": "example glossary","GlossDiv": {"title": "S","GlossList": {"GlossEntry": {"ID": "SGML","SortAs": "SGML","GlossTerm": "Standard Generalized Markup Language","Acronym": "SGML","Abbrev": "ISO 8879:1986","GlossDef": {"para": "A meta-markup language, used to create markup languages such as DocBook.","GlossSeeAlso": ["GML", "XML"]},"GlossSee": "markup"}}}}}'::json) as v1, try_convert_by_sql(v, '{"glossary": {"title": "example glossary","GlossDiv": {"title": "S","GlossList": {"GlossEntry": {"ID": "SGML","SortAs": "SGML","GlossTerm": "Standard Generalized Markup Language","Acronym": "SGML","Abbrev": "ISO 8879:1986","GlossDef": {"para": "A meta-markup language, used to create markup languages such as DocBook.","GlossSeeAlso": ["GML", "XML"]},"GlossSee": "markup"}}}}}'::json) as v2 from tt_jsonb) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_point) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_point) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::point) as v1, try_convert_by_sql(v, NULL::point) as v2 from tt_complex) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, '(1, 2)'::point) as v1, try_convert_by_sql(v, '(1, 2)'::point) as v2 from tt_complex) as t(v1, v2) where v1::text is distinct from v2::text; +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::citext) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::citext) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::citext, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::citext, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::citext, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::citext, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::citext) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; +-- MILLION TESTS +DROP TABLE IF EXISTS text_ints; CREATE TABLE text_ints (v text) DISTRIBUTED BY (v); +INSERT INTO text_ints(v) SELECT (random()*1000)::int4::text FROM generate_series(1,1000000); +DROP TABLE IF EXISTS text_error_ints; CREATE TABLE text_error_ints (v text) DISTRIBUTED BY (v); +INSERT INTO text_error_ints(v) SELECT (random()*1000000 + 1000000)::int8::text FROM generate_series(1,1000000); +DROP TABLE IF EXISTS int4_ints; CREATE TABLE int4_ints (v int4) DISTRIBUTED BY (v); +INSERT INTO int4_ints(v) SELECT (random()*1000)::int4 FROM generate_series(1,1000000); +DROP TABLE IF EXISTS int4_error_ints; CREATE TABLE int4_error_ints (v int4) DISTRIBUTED BY (v); +INSERT INTO int4_error_ints(v) SELECT (random()*1000000 + 1000000)::int4 FROM generate_series(1,1000000); +SELECT count(*) FROM (SELECT try_convert(v, NULL::int2) as v FROM text_ints) as t(v) WHERE v IS NOT NULL; +SELECT count(*) FROM (SELECT try_convert(v, NULL::int2) as v FROM text_error_ints) as t(v) WHERE v IS NULL; +SELECT count(*) FROM (SELECT try_convert(v, NULL::int2) as v FROM int4_ints) as t(v) WHERE v IS NOT NULL; +SELECT count(*) FROM (SELECT try_convert(v, NULL::int2) as v FROM int4_error_ints) as t(v) WHERE v IS NULL; + +-- NESTED TESTS +select try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(42::int4, NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4) as v; + +reset search_path; diff --git a/contrib/try_convert/output/try_convert.source b/contrib/try_convert/output/try_convert.source new file mode 100644 index 0000000000..5ed3784f24 --- /dev/null +++ b/contrib/try_convert/output/try_convert.source @@ -0,0 +1,7502 @@ +-- SCRIPT-GENERATED TEST for TRY_CONVERT +-- Tests 31 types of 91 from pg_types.h +-- Tests 111 cast of 206 from pg_cast.h +-- Tests 1 types of 1 from extensions +-- Tests 5 casts of 8 from extensions +create schema tryconvert; +set search_path = tryconvert; +-- start_ignore +CREATE EXTENSION IF NOT EXISTS try_convert; +-- end_ignore +select add_type_for_try_convert('int8'::regtype);select add_type_for_try_convert('int4'::regtype);select add_type_for_try_convert('int2'::regtype);select add_type_for_try_convert('float8'::regtype);select add_type_for_try_convert('float4'::regtype);select add_type_for_try_convert('numeric'::regtype);select add_type_for_try_convert('complex'::regtype);select add_type_for_try_convert('bool'::regtype);select add_type_for_try_convert('bit'::regtype);select add_type_for_try_convert('varbit'::regtype);select add_type_for_try_convert('date'::regtype);select add_type_for_try_convert('time'::regtype);select add_type_for_try_convert('timetz'::regtype);select add_type_for_try_convert('timestamp'::regtype);select add_type_for_try_convert('timestamptz'::regtype);select add_type_for_try_convert('interval'::regtype);select add_type_for_try_convert('abstime'::regtype);select add_type_for_try_convert('reltime'::regtype);select add_type_for_try_convert('point'::regtype);select add_type_for_try_convert('cidr'::regtype);select add_type_for_try_convert('inet'::regtype);select add_type_for_try_convert('macaddr'::regtype);select add_type_for_try_convert('json'::regtype);select add_type_for_try_convert('jsonb'::regtype);select add_type_for_try_convert('xml'::regtype);select add_type_for_try_convert('char'::regtype);select add_type_for_try_convert('varchar'::regtype);select add_type_for_try_convert('text'::regtype);select add_type_for_try_convert('money'::regtype);select add_type_for_try_convert('uuid'::regtype);select add_type_for_try_convert('regtype'::regtype);select add_type_for_try_convert('citext'::regtype);-- start_ignore +CREATE EXTENSION IF NOT EXISTS citext; +-- end_ignore +CREATE FUNCTION try_convert_by_sql_text(_in text, INOUT _out ANYELEMENT, source_type text) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::%s::%s', $1, source_type, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_text_with_len_out(_in text, INOUT _out ANYELEMENT, source_type text, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::%s::%s(%s)', $1, source_type, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in int8, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::int8::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in int8, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::int8::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in int4, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::int4::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in int4, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::int4::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in int2, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::int2::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in int2, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::int2::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in float8, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::float8::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in float8, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::float8::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in float4, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::float4::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in float4, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::float4::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in numeric, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::numeric::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in numeric, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::numeric::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in complex, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::complex::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in complex, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::complex::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in bool, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::bool::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in bool, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::bool::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in bit, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::bit::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in bit, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::bit::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in varbit, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::varbit::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in varbit, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::varbit::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in date, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::date::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in date, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::date::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in time, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::time::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in time, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::time::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in timetz, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::timetz::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in timetz, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::timetz::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in timestamp, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::timestamp::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in timestamp, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::timestamp::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in timestamptz, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::timestamptz::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in timestamptz, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::timestamptz::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in interval, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::interval::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in interval, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::interval::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in abstime, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::abstime::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in abstime, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::abstime::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in reltime, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::reltime::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in reltime, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::reltime::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in point, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::point::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in point, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::point::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in cidr, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::cidr::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in cidr, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::cidr::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in inet, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::inet::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in inet, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::inet::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in macaddr, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::macaddr::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in macaddr, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::macaddr::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in json, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::json::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in json, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::json::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in jsonb, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::jsonb::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in jsonb, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::jsonb::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in xml, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::xml::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in xml, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::xml::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in char, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::char::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in char, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::char::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in varchar, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::varchar::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in varchar, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::varchar::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in text, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::text::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in text, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::text::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in money, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::money::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in money, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::money::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in uuid, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::uuid::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in uuid, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::uuid::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in regtype, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::regtype::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in regtype, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::regtype::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql_with_len_out(_in citext, INOUT _out ANYELEMENT, len_out int) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::citext::%s(%s)', $1, pg_typeof(_out), len_out::text) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +CREATE FUNCTION try_convert_by_sql(_in citext, INOUT _out ANYELEMENT) + LANGUAGE plpgsql AS +$func$ + BEGIN + EXECUTE format('SELECT %L::citext::%s', $1, pg_typeof(_out)) + INTO _out; + EXCEPTION WHEN others THEN + -- do nothing: _out already carries default + END +$func$; +-- LOAD DATA +CREATE TABLE tt_temp (v text) DISTRIBUTED BY (v); +CREATE TABLE tt_int8 (id serial, v int8) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_int8.data'; +INSERT INTO tt_int8(id, v) SELECT row_number() OVER(), v::int8 from tt_temp; +CREATE TABLE tt_text_of_int8 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_int8(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_int8 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_int8(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_int8 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_int8(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_int8 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_int8(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_int8 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_int8(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_int8 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_int8(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_int8 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_int8(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_int8 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_int8(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_int8 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_int8(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_int8 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_int8(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_int8 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_int8(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_int8 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_int8(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_int4 (id serial, v int4) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_int4.data'; +INSERT INTO tt_int4(id, v) SELECT row_number() OVER(), v::int4 from tt_temp; +CREATE TABLE tt_text_of_int4 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_int4(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_int4 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_int4(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_int4 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_int4(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_int4 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_int4(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_int4 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_int4(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_int4 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_int4(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_int4 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_int4(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_int4 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_int4(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_int4 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_int4(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_int4 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_int4(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_int4 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_int4(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_int4 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_int4(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_int2 (id serial, v int2) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_int2.data'; +INSERT INTO tt_int2(id, v) SELECT row_number() OVER(), v::int2 from tt_temp; +CREATE TABLE tt_text_of_int2 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_int2(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_int2 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_int2(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_int2 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_int2(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_int2 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_int2(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_int2 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_int2(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_int2 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_int2(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_int2 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_int2(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_int2 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_int2(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_int2 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_int2(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_int2 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_int2(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_int2 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_int2(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_int2 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_int2(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_float8 (id serial, v float8) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_float8.data'; +INSERT INTO tt_float8(id, v) SELECT row_number() OVER(), v::float8 from tt_temp; +CREATE TABLE tt_text_of_float8 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_float8(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_float8 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_float8(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_float8 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_float8(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_float8 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_float8(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_float8 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_float8(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_float8 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_float8(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_float8 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_float8(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_float8 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_float8(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_float8 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_float8(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_float8 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_float8(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_float8 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_float8(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_float8 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_float8(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_float4 (id serial, v float4) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_float4.data'; +INSERT INTO tt_float4(id, v) SELECT row_number() OVER(), v::float4 from tt_temp; +CREATE TABLE tt_text_of_float4 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_float4(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_float4 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_float4(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_float4 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_float4(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_float4 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_float4(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_float4 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_float4(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_float4 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_float4(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_float4 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_float4(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_float4 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_float4(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_float4 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_float4(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_float4 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_float4(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_float4 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_float4(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_float4 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_float4(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_numeric (id serial, v numeric) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_numeric.data'; +INSERT INTO tt_numeric(id, v) SELECT row_number() OVER(), v::numeric from tt_temp; +CREATE TABLE tt_text_of_numeric (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_numeric(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_numeric (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_numeric(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_numeric (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_numeric(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_numeric (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_numeric(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_numeric (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_numeric(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_numeric (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_numeric(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_numeric (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_numeric(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_numeric (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_numeric(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_numeric (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_numeric(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_numeric (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_numeric(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_numeric (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_numeric(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_numeric (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_numeric(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_complex (id serial, v complex) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_complex.data'; +INSERT INTO tt_complex(id, v) SELECT row_number() OVER(), v::complex from tt_temp; +CREATE TABLE tt_text_of_complex (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_complex(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_complex (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_complex(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_complex (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_complex(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_complex (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_complex(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_complex (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_complex(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_complex (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_complex(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_complex (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_complex(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_complex (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_complex(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_complex (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_complex(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_complex (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_complex(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_complex (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_complex(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_complex (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_complex(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_bool (id serial, v bool) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_bool.data'; +INSERT INTO tt_bool(id, v) SELECT row_number() OVER(), v::bool from tt_temp; +CREATE TABLE tt_text_of_bool (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_bool(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_bool (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_bool(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_bool (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_bool(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_bool (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_bool(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_bool (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_bool(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_bool (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_bool(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_bool (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_bool(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_bool (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_bool(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_bool (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_bool(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_bool (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_bool(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_bool (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_bool(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_bool (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_bool(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_bit (id serial, v bit) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_bit.data'; +INSERT INTO tt_bit(id, v) SELECT row_number() OVER(), v::bit from tt_temp; +CREATE TABLE tt_text_of_bit (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_bit(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_bit (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_bit(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_bit (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_bit(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_bit (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_bit(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_bit (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_bit(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_bit (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_bit(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_bit (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_bit(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_bit (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_bit(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_bit (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_bit(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_bit (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_bit(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_bit (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_bit(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_bit (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_bit(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_bit_1 (id serial, v bit(1)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_bit.data'; +INSERT INTO tt_bit_1(id, v) SELECT row_number() OVER(), v::bit(1) from tt_temp; +CREATE TABLE tt_text_of_bit_1 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::text from tt_temp; +CREATE TABLE tt_citext_of_bit_1 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::citext from tt_temp; +CREATE TABLE tt_char_of_bit_1 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::char from tt_temp; +CREATE TABLE tt_char_1_of_bit_1 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_bit_1 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_bit_1 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_bit_1 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_bit_1 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_bit_1 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_bit_1 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_bit_1 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_bit_1 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_bit_1(id, v) SELECT row_number() OVER(), v::bit(1)::varchar(20) from tt_temp; +CREATE TABLE tt_bit_5 (id serial, v bit(5)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_bit.data'; +INSERT INTO tt_bit_5(id, v) SELECT row_number() OVER(), v::bit(5) from tt_temp; +CREATE TABLE tt_text_of_bit_5 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::text from tt_temp; +CREATE TABLE tt_citext_of_bit_5 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::citext from tt_temp; +CREATE TABLE tt_char_of_bit_5 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::char from tt_temp; +CREATE TABLE tt_char_1_of_bit_5 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_bit_5 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_bit_5 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_bit_5 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_bit_5 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_bit_5 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_bit_5 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_bit_5 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_bit_5 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_bit_5(id, v) SELECT row_number() OVER(), v::bit(5)::varchar(20) from tt_temp; +CREATE TABLE tt_bit_10 (id serial, v bit(10)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_bit.data'; +INSERT INTO tt_bit_10(id, v) SELECT row_number() OVER(), v::bit(10) from tt_temp; +CREATE TABLE tt_text_of_bit_10 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::text from tt_temp; +CREATE TABLE tt_citext_of_bit_10 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::citext from tt_temp; +CREATE TABLE tt_char_of_bit_10 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::char from tt_temp; +CREATE TABLE tt_char_1_of_bit_10 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_bit_10 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_bit_10 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_bit_10 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_bit_10 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_bit_10 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_bit_10 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_bit_10 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_bit_10 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_bit_10(id, v) SELECT row_number() OVER(), v::bit(10)::varchar(20) from tt_temp; +CREATE TABLE tt_bit_20 (id serial, v bit(20)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_bit.data'; +INSERT INTO tt_bit_20(id, v) SELECT row_number() OVER(), v::bit(20) from tt_temp; +CREATE TABLE tt_text_of_bit_20 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::text from tt_temp; +CREATE TABLE tt_citext_of_bit_20 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::citext from tt_temp; +CREATE TABLE tt_char_of_bit_20 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::char from tt_temp; +CREATE TABLE tt_char_1_of_bit_20 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_bit_20 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_bit_20 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_bit_20 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_bit_20 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_bit_20 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_bit_20 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_bit_20 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_bit_20 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_bit_20(id, v) SELECT row_number() OVER(), v::bit(20)::varchar(20) from tt_temp; +CREATE TABLE tt_varbit (id serial, v varbit) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varbit.data'; +INSERT INTO tt_varbit(id, v) SELECT row_number() OVER(), v::varbit from tt_temp; +CREATE TABLE tt_text_of_varbit (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varbit(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_varbit (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varbit(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_varbit (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varbit(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_varbit (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varbit(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varbit (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varbit(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varbit (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varbit(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varbit (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varbit(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varbit (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varbit(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varbit (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varbit(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varbit (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varbit(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varbit (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varbit(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varbit (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varbit(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_varbit_1 (id serial, v varbit(1)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varbit.data'; +INSERT INTO tt_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1) from tt_temp; +CREATE TABLE tt_text_of_varbit_1 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::text from tt_temp; +CREATE TABLE tt_citext_of_varbit_1 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::citext from tt_temp; +CREATE TABLE tt_char_of_varbit_1 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::char from tt_temp; +CREATE TABLE tt_char_1_of_varbit_1 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varbit_1 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varbit_1 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varbit_1 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varbit_1 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varbit_1 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varbit_1 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varbit_1 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varbit_1 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varbit_1(id, v) SELECT row_number() OVER(), v::varbit(1)::varchar(20) from tt_temp; +CREATE TABLE tt_varbit_5 (id serial, v varbit(5)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varbit.data'; +INSERT INTO tt_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5) from tt_temp; +CREATE TABLE tt_text_of_varbit_5 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::text from tt_temp; +CREATE TABLE tt_citext_of_varbit_5 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::citext from tt_temp; +CREATE TABLE tt_char_of_varbit_5 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::char from tt_temp; +CREATE TABLE tt_char_1_of_varbit_5 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varbit_5 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varbit_5 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varbit_5 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varbit_5 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varbit_5 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varbit_5 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varbit_5 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varbit_5 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varbit_5(id, v) SELECT row_number() OVER(), v::varbit(5)::varchar(20) from tt_temp; +CREATE TABLE tt_varbit_10 (id serial, v varbit(10)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varbit.data'; +INSERT INTO tt_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10) from tt_temp; +CREATE TABLE tt_text_of_varbit_10 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::text from tt_temp; +CREATE TABLE tt_citext_of_varbit_10 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::citext from tt_temp; +CREATE TABLE tt_char_of_varbit_10 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::char from tt_temp; +CREATE TABLE tt_char_1_of_varbit_10 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varbit_10 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varbit_10 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varbit_10 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varbit_10 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varbit_10 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varbit_10 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varbit_10 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varbit_10 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varbit_10(id, v) SELECT row_number() OVER(), v::varbit(10)::varchar(20) from tt_temp; +CREATE TABLE tt_varbit_20 (id serial, v varbit(20)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varbit.data'; +INSERT INTO tt_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20) from tt_temp; +CREATE TABLE tt_text_of_varbit_20 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::text from tt_temp; +CREATE TABLE tt_citext_of_varbit_20 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::citext from tt_temp; +CREATE TABLE tt_char_of_varbit_20 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::char from tt_temp; +CREATE TABLE tt_char_1_of_varbit_20 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varbit_20 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varbit_20 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varbit_20 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varbit_20 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varbit_20 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varbit_20 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varbit_20 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varbit_20 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varbit_20(id, v) SELECT row_number() OVER(), v::varbit(20)::varchar(20) from tt_temp; +CREATE TABLE tt_date (id serial, v date) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_date.data'; +INSERT INTO tt_date(id, v) SELECT row_number() OVER(), v::date from tt_temp; +CREATE TABLE tt_text_of_date (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_date(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_date (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_date(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_date (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_date(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_date (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_date(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_date (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_date(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_date (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_date(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_date (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_date(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_date (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_date(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_date (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_date(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_date (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_date(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_date (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_date(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_date (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_date(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_time (id serial, v time) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_time.data'; +INSERT INTO tt_time(id, v) SELECT row_number() OVER(), v::time from tt_temp; +CREATE TABLE tt_text_of_time (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_time(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_time (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_time(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_time (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_time(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_time (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_time(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_time (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_time(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_time (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_time(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_time (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_time(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_time (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_time(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_time (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_time(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_time (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_time(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_time (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_time(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_time (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_time(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_timetz (id serial, v timetz) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_timetz.data'; +INSERT INTO tt_timetz(id, v) SELECT row_number() OVER(), v::timetz from tt_temp; +CREATE TABLE tt_text_of_timetz (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_timetz(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_timetz (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_timetz(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_timetz (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_timetz(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_timetz (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_timetz(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_timetz (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_timetz(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_timetz (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_timetz(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_timetz (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_timetz(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_timetz (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_timetz(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_timetz (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_timetz(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_timetz (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_timetz(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_timetz (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_timetz(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_timetz (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_timetz(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_timestamp (id serial, v timestamp) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_timestamp.data'; +INSERT INTO tt_timestamp(id, v) SELECT row_number() OVER(), v::timestamp from tt_temp; +CREATE TABLE tt_text_of_timestamp (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_timestamp(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_timestamp (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_timestamp(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_timestamp (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_timestamp(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_timestamp (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_timestamp(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_timestamp (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_timestamp(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_timestamp (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_timestamp(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_timestamp (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_timestamp(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_timestamp (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_timestamp(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_timestamp (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_timestamp(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_timestamp (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_timestamp(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_timestamp (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_timestamp(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_timestamp (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_timestamp(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_timestamptz (id serial, v timestamptz) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_timestamptz.data'; +INSERT INTO tt_timestamptz(id, v) SELECT row_number() OVER(), v::timestamptz from tt_temp; +CREATE TABLE tt_text_of_timestamptz (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_timestamptz(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_timestamptz (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_timestamptz(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_timestamptz (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_timestamptz(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_timestamptz (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_timestamptz(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_timestamptz (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_timestamptz(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_timestamptz (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_timestamptz(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_timestamptz (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_timestamptz(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_timestamptz (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_timestamptz(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_timestamptz (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_timestamptz(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_timestamptz (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_timestamptz(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_timestamptz (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_timestamptz(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_timestamptz (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_timestamptz(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_interval (id serial, v interval) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_interval.data'; +INSERT INTO tt_interval(id, v) SELECT row_number() OVER(), v::interval from tt_temp; +CREATE TABLE tt_text_of_interval (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_interval(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_interval (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_interval(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_interval (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_interval(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_interval (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_interval(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_interval (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_interval(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_interval (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_interval(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_interval (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_interval(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_interval (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_interval(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_interval (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_interval(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_interval (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_interval(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_interval (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_interval(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_interval (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_interval(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_abstime (id serial, v abstime) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_abstime.data'; +INSERT INTO tt_abstime(id, v) SELECT row_number() OVER(), v::abstime from tt_temp; +CREATE TABLE tt_text_of_abstime (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_abstime(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_abstime (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_abstime(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_abstime (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_abstime(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_abstime (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_abstime(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_abstime (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_abstime(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_abstime (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_abstime(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_abstime (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_abstime(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_abstime (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_abstime(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_abstime (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_abstime(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_abstime (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_abstime(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_abstime (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_abstime(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_abstime (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_abstime(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_reltime (id serial, v reltime) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_reltime.data'; +INSERT INTO tt_reltime(id, v) SELECT row_number() OVER(), v::reltime from tt_temp; +CREATE TABLE tt_text_of_reltime (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_reltime(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_reltime (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_reltime(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_reltime (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_reltime(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_reltime (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_reltime(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_reltime (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_reltime(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_reltime (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_reltime(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_reltime (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_reltime(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_reltime (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_reltime(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_reltime (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_reltime(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_reltime (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_reltime(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_reltime (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_reltime(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_reltime (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_reltime(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_point (id serial, v point) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_point.data'; +INSERT INTO tt_point(id, v) SELECT row_number() OVER(), v::point from tt_temp; +CREATE TABLE tt_text_of_point (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_point(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_point (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_point(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_point (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_point(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_point (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_point(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_point (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_point(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_point (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_point(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_point (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_point(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_point (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_point(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_point (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_point(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_point (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_point(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_point (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_point(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_point (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_point(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_cidr (id serial, v cidr) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_cidr.data'; +INSERT INTO tt_cidr(id, v) SELECT row_number() OVER(), v::cidr from tt_temp; +CREATE TABLE tt_text_of_cidr (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_cidr(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_cidr (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_cidr(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_cidr (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_cidr(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_cidr (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_cidr(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_cidr (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_cidr(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_cidr (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_cidr(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_cidr (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_cidr(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_cidr (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_cidr(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_cidr (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_cidr(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_cidr (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_cidr(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_cidr (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_cidr(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_cidr (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_cidr(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_inet (id serial, v inet) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_inet.data'; +INSERT INTO tt_inet(id, v) SELECT row_number() OVER(), v::inet from tt_temp; +CREATE TABLE tt_text_of_inet (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_inet(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_inet (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_inet(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_inet (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_inet(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_inet (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_inet(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_inet (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_inet(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_inet (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_inet(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_inet (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_inet(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_inet (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_inet(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_inet (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_inet(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_inet (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_inet(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_inet (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_inet(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_inet (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_inet(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_macaddr (id serial, v macaddr) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_macaddr.data'; +INSERT INTO tt_macaddr(id, v) SELECT row_number() OVER(), v::macaddr from tt_temp; +CREATE TABLE tt_text_of_macaddr (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_macaddr(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_macaddr (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_macaddr(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_macaddr (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_macaddr(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_macaddr (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_macaddr(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_macaddr (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_macaddr(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_macaddr (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_macaddr(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_macaddr (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_macaddr(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_macaddr (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_macaddr(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_macaddr (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_macaddr(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_macaddr (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_macaddr(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_macaddr (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_macaddr(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_macaddr (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_macaddr(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_json (id serial, v json) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_json.data'; +INSERT INTO tt_json(id, v) SELECT row_number() OVER(), v::json from tt_temp; +CREATE TABLE tt_text_of_json (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_json(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_json (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_json(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_json (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_json(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_json (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_json(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_json (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_json(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_json (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_json(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_json (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_json(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_json (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_json(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_json (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_json(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_json (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_json(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_json (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_json(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_json (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_json(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_jsonb (id serial, v jsonb) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_jsonb.data'; +INSERT INTO tt_jsonb(id, v) SELECT row_number() OVER(), v::jsonb from tt_temp; +CREATE TABLE tt_text_of_jsonb (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_jsonb(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_jsonb (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_jsonb(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_jsonb (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_jsonb(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_jsonb (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_jsonb(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_jsonb (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_jsonb(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_jsonb (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_jsonb(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_jsonb (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_jsonb(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_jsonb (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_jsonb(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_jsonb (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_jsonb(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_jsonb (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_jsonb(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_jsonb (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_jsonb(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_jsonb (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_jsonb(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_xml (id serial, v xml) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_xml.data'; +INSERT INTO tt_xml(id, v) SELECT row_number() OVER(), v::xml from tt_temp; +CREATE TABLE tt_text_of_xml (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_xml(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_xml (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_xml(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_xml (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_xml(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_xml (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_xml(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_xml (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_xml(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_xml (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_xml(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_xml (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_xml(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_xml (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_xml(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_xml (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_xml(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_xml (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_xml(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_xml (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_xml(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_xml (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_xml(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_char (id serial, v char) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_char.data'; +INSERT INTO tt_char(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_text_of_char (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_char(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_char (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_char(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_char (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_char(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_char (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_char(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_char (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_char(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_char (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_char(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_char (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_char(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_char (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_char(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_char (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_char(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_char (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_char(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_char (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_char(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_char (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_char(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_char_1 (id serial, v char(1)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_char.data'; +INSERT INTO tt_char_1(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_text_of_char_1 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::text from tt_temp; +CREATE TABLE tt_citext_of_char_1 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::citext from tt_temp; +CREATE TABLE tt_char_of_char_1 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::char from tt_temp; +CREATE TABLE tt_char_1_of_char_1 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_char_1 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_char_1 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_char_1 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_char_1 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_char_1 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_char_1 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_char_1 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_char_1 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_char_1(id, v) SELECT row_number() OVER(), v::char(1)::varchar(20) from tt_temp; +CREATE TABLE tt_char_5 (id serial, v char(5)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_char.data'; +INSERT INTO tt_char_5(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_text_of_char_5 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::text from tt_temp; +CREATE TABLE tt_citext_of_char_5 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::citext from tt_temp; +CREATE TABLE tt_char_of_char_5 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::char from tt_temp; +CREATE TABLE tt_char_1_of_char_5 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_char_5 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_char_5 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_char_5 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_char_5 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_char_5 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_char_5 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_char_5 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_char_5 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_char_5(id, v) SELECT row_number() OVER(), v::char(5)::varchar(20) from tt_temp; +CREATE TABLE tt_char_10 (id serial, v char(10)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_char.data'; +INSERT INTO tt_char_10(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_text_of_char_10 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::text from tt_temp; +CREATE TABLE tt_citext_of_char_10 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::citext from tt_temp; +CREATE TABLE tt_char_of_char_10 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::char from tt_temp; +CREATE TABLE tt_char_1_of_char_10 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_char_10 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_char_10 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_char_10 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_char_10 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_char_10 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_char_10 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_char_10 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_char_10 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_char_10(id, v) SELECT row_number() OVER(), v::char(10)::varchar(20) from tt_temp; +CREATE TABLE tt_char_20 (id serial, v char(20)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_char.data'; +INSERT INTO tt_char_20(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_text_of_char_20 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::text from tt_temp; +CREATE TABLE tt_citext_of_char_20 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::citext from tt_temp; +CREATE TABLE tt_char_of_char_20 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::char from tt_temp; +CREATE TABLE tt_char_1_of_char_20 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_char_20 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_char_20 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_char_20 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_char_20 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_char_20 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_char_20 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_char_20 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_char_20 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_char_20(id, v) SELECT row_number() OVER(), v::char(20)::varchar(20) from tt_temp; +CREATE TABLE tt_varchar (id serial, v varchar) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varchar.data'; +INSERT INTO tt_varchar(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_text_of_varchar (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varchar(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_varchar (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varchar(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_varchar (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varchar(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_varchar (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varchar(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varchar (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varchar(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varchar (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varchar(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varchar (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varchar(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varchar (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varchar(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varchar (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varchar(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varchar (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varchar(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varchar (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varchar(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varchar (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varchar(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_varchar_1 (id serial, v varchar(1)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varchar.data'; +INSERT INTO tt_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_text_of_varchar_1 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::text from tt_temp; +CREATE TABLE tt_citext_of_varchar_1 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::citext from tt_temp; +CREATE TABLE tt_char_of_varchar_1 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::char from tt_temp; +CREATE TABLE tt_char_1_of_varchar_1 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varchar_1 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varchar_1 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varchar_1 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varchar_1 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varchar_1 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varchar_1 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varchar_1 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varchar_1 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varchar_1(id, v) SELECT row_number() OVER(), v::varchar(1)::varchar(20) from tt_temp; +CREATE TABLE tt_varchar_5 (id serial, v varchar(5)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varchar.data'; +INSERT INTO tt_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_text_of_varchar_5 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::text from tt_temp; +CREATE TABLE tt_citext_of_varchar_5 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::citext from tt_temp; +CREATE TABLE tt_char_of_varchar_5 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::char from tt_temp; +CREATE TABLE tt_char_1_of_varchar_5 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varchar_5 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varchar_5 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varchar_5 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varchar_5 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varchar_5 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varchar_5 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varchar_5 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varchar_5 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varchar_5(id, v) SELECT row_number() OVER(), v::varchar(5)::varchar(20) from tt_temp; +CREATE TABLE tt_varchar_10 (id serial, v varchar(10)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varchar.data'; +INSERT INTO tt_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_text_of_varchar_10 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::text from tt_temp; +CREATE TABLE tt_citext_of_varchar_10 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::citext from tt_temp; +CREATE TABLE tt_char_of_varchar_10 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::char from tt_temp; +CREATE TABLE tt_char_1_of_varchar_10 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varchar_10 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varchar_10 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varchar_10 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varchar_10 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varchar_10 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varchar_10 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varchar_10 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varchar_10 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varchar_10(id, v) SELECT row_number() OVER(), v::varchar(10)::varchar(20) from tt_temp; +CREATE TABLE tt_varchar_20 (id serial, v varchar(20)) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_varchar.data'; +INSERT INTO tt_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_text_of_varchar_20 (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::text from tt_temp; +CREATE TABLE tt_citext_of_varchar_20 (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::citext from tt_temp; +CREATE TABLE tt_char_of_varchar_20 (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::char from tt_temp; +CREATE TABLE tt_char_1_of_varchar_20 (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_varchar_20 (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_varchar_20 (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_varchar_20 (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_varchar_20 (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_varchar_20 (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_varchar_20 (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_varchar_20 (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_varchar_20 (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_varchar_20(id, v) SELECT row_number() OVER(), v::varchar(20)::varchar(20) from tt_temp; +CREATE TABLE tt_text (id serial, v text) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_text.data'; +INSERT INTO tt_text(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_text_of_text (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_text(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_text (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_text(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_text (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_text(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_text (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_text(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_text (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_text(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_text (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_text(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_text (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_text(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_text (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_text(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_text (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_text(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_text (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_text(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_text (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_text(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_text (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_text(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_money (id serial, v money) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_money.data'; +INSERT INTO tt_money(id, v) SELECT row_number() OVER(), v::money from tt_temp; +CREATE TABLE tt_text_of_money (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_money(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_money (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_money(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_money (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_money(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_money (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_money(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_money (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_money(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_money (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_money(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_money (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_money(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_money (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_money(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_money (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_money(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_money (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_money(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_money (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_money(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_money (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_money(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_uuid (id serial, v uuid) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_uuid.data'; +INSERT INTO tt_uuid(id, v) SELECT row_number() OVER(), v::uuid from tt_temp; +CREATE TABLE tt_text_of_uuid (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_uuid(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_uuid (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_uuid(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_uuid (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_uuid(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_uuid (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_uuid(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_uuid (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_uuid(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_uuid (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_uuid(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_uuid (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_uuid(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_uuid (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_uuid(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_uuid (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_uuid(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_uuid (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_uuid(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_uuid (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_uuid(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_uuid (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_uuid(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_regtype (id serial, v regtype) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_regtype.data'; +INSERT INTO tt_regtype(id, v) SELECT row_number() OVER(), v::regtype from tt_temp; +CREATE TABLE tt_text_of_regtype (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_regtype(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_regtype (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_regtype(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_regtype (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_regtype(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_regtype (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_regtype(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_regtype (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_regtype(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_regtype (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_regtype(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_regtype (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_regtype(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_regtype (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_regtype(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_regtype (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_regtype(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_regtype (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_regtype(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_regtype (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_regtype(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_regtype (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_regtype(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +CREATE TABLE tt_citext (id serial, v citext) DISTRIBUTED BY (id); +DELETE FROM tt_temp; +COPY tt_temp from '@abs_srcdir@/data/tt_citext.data'; +INSERT INTO tt_citext(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_text_of_citext (id serial, v text) DISTRIBUTED BY (id); +INSERT INTO tt_text_of_citext(id, v) SELECT row_number() OVER(), v::text from tt_temp; +CREATE TABLE tt_citext_of_citext (id serial, v citext) DISTRIBUTED BY (id); +INSERT INTO tt_citext_of_citext(id, v) SELECT row_number() OVER(), v::citext from tt_temp; +CREATE TABLE tt_char_of_citext (id serial, v char) DISTRIBUTED BY (id); +INSERT INTO tt_char_of_citext(id, v) SELECT row_number() OVER(), v::char from tt_temp; +CREATE TABLE tt_char_1_of_citext (id serial, v char(1)) DISTRIBUTED BY (id); +INSERT INTO tt_char_1_of_citext(id, v) SELECT row_number() OVER(), v::char(1) from tt_temp; +CREATE TABLE tt_char_5_of_citext (id serial, v char(5)) DISTRIBUTED BY (id); +INSERT INTO tt_char_5_of_citext(id, v) SELECT row_number() OVER(), v::char(5) from tt_temp; +CREATE TABLE tt_char_10_of_citext (id serial, v char(10)) DISTRIBUTED BY (id); +INSERT INTO tt_char_10_of_citext(id, v) SELECT row_number() OVER(), v::char(10) from tt_temp; +CREATE TABLE tt_char_20_of_citext (id serial, v char(20)) DISTRIBUTED BY (id); +INSERT INTO tt_char_20_of_citext(id, v) SELECT row_number() OVER(), v::char(20) from tt_temp; +CREATE TABLE tt_varchar_of_citext (id serial, v varchar) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_of_citext(id, v) SELECT row_number() OVER(), v::varchar from tt_temp; +CREATE TABLE tt_varchar_1_of_citext (id serial, v varchar(1)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_1_of_citext(id, v) SELECT row_number() OVER(), v::varchar(1) from tt_temp; +CREATE TABLE tt_varchar_5_of_citext (id serial, v varchar(5)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_5_of_citext(id, v) SELECT row_number() OVER(), v::varchar(5) from tt_temp; +CREATE TABLE tt_varchar_10_of_citext (id serial, v varchar(10)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_10_of_citext(id, v) SELECT row_number() OVER(), v::varchar(10) from tt_temp; +CREATE TABLE tt_varchar_20_of_citext (id serial, v varchar(20)) DISTRIBUTED BY (id); +INSERT INTO tt_varchar_20_of_citext(id, v) SELECT row_number() OVER(), v::varchar(20) from tt_temp; +-- TEXT TESTS +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_text_of_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_text_of_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_text_of_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_text_of_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_text_of_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_text_of_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_complex) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_text_of_complex) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bool) as v1, try_convert_by_sql(v, NULL::bool) as v2 from tt_text_of_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_text_of_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_text_of_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_text_of_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_text_of_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_text_of_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql(v, NULL::varbit) as v2 from tt_text_of_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 1) as v2 from tt_text_of_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 5) as v2 from tt_text_of_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 10) as v2 from tt_text_of_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 20) as v2 from tt_text_of_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_text_of_date) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_text_of_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_text_of_timetz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_text_of_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_text_of_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_text_of_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_text_of_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::reltime) as v1, try_convert_by_sql(v, NULL::reltime) as v2 from tt_text_of_reltime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_point) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::point) as v1, try_convert_by_sql(v, NULL::point) as v2 from tt_text_of_point) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::cidr) as v1, try_convert_by_sql(v, NULL::cidr) as v2 from tt_text_of_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::inet) as v1, try_convert_by_sql(v, NULL::inet) as v2 from tt_text_of_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_macaddr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::macaddr) as v1, try_convert_by_sql(v, NULL::macaddr) as v2 from tt_text_of_macaddr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_json) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::json) as v1, try_convert_by_sql(v, NULL::json) as v2 from tt_text_of_json) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_jsonb) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::jsonb) as v1, try_convert_by_sql(v, NULL::jsonb) as v2 from tt_text_of_jsonb) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql(v, NULL::xml) as v2 from tt_text_of_xml) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_text_of_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_text_of_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_text_of_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_text_of_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_text_of_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_text_of_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_text_of_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_text_of_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_text_of_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_text_of_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_text_of_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_money) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_text_of_money) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_uuid) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::uuid) as v1, try_convert_by_sql(v, NULL::uuid) as v2 from tt_text_of_uuid) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_text_of_regtype) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_text_of_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_citext_of_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_citext_of_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_citext_of_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_citext_of_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_citext_of_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_citext_of_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_complex) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_citext_of_complex) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bool) as v1, try_convert_by_sql(v, NULL::bool) as v2 from tt_citext_of_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_citext_of_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_citext_of_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_citext_of_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_citext_of_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_citext_of_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql(v, NULL::varbit) as v2 from tt_citext_of_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 1) as v2 from tt_citext_of_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 5) as v2 from tt_citext_of_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 10) as v2 from tt_citext_of_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 20) as v2 from tt_citext_of_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_citext_of_date) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_citext_of_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_citext_of_timetz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_citext_of_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_citext_of_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_citext_of_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_citext_of_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::reltime) as v1, try_convert_by_sql(v, NULL::reltime) as v2 from tt_citext_of_reltime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_point) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::point) as v1, try_convert_by_sql(v, NULL::point) as v2 from tt_citext_of_point) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::cidr) as v1, try_convert_by_sql(v, NULL::cidr) as v2 from tt_citext_of_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::inet) as v1, try_convert_by_sql(v, NULL::inet) as v2 from tt_citext_of_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_macaddr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::macaddr) as v1, try_convert_by_sql(v, NULL::macaddr) as v2 from tt_citext_of_macaddr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_json) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::json) as v1, try_convert_by_sql(v, NULL::json) as v2 from tt_citext_of_json) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_jsonb) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::jsonb) as v1, try_convert_by_sql(v, NULL::jsonb) as v2 from tt_citext_of_jsonb) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql(v, NULL::xml) as v2 from tt_citext_of_xml) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_citext_of_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_citext_of_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_citext_of_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_citext_of_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_citext_of_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_citext_of_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_citext_of_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_citext_of_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_citext_of_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_citext_of_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_citext_of_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_money) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_citext_of_money) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_uuid) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::uuid) as v1, try_convert_by_sql(v, NULL::uuid) as v2 from tt_citext_of_uuid) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_citext_of_regtype) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_citext_of_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_char_of_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_char_of_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_char_of_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_char_of_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_char_of_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_char_of_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_complex) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_char_of_complex) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bool) as v1, try_convert_by_sql(v, NULL::bool) as v2 from tt_char_of_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_char_of_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_char_of_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_char_of_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_char_of_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_char_of_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql(v, NULL::varbit) as v2 from tt_char_of_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 1) as v2 from tt_char_of_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 5) as v2 from tt_char_of_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 10) as v2 from tt_char_of_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 20) as v2 from tt_char_of_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_char_of_date) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_char_of_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_char_of_timetz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_char_of_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_char_of_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_char_of_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_char_of_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::reltime) as v1, try_convert_by_sql(v, NULL::reltime) as v2 from tt_char_of_reltime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_point) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::point) as v1, try_convert_by_sql(v, NULL::point) as v2 from tt_char_of_point) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::cidr) as v1, try_convert_by_sql(v, NULL::cidr) as v2 from tt_char_of_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::inet) as v1, try_convert_by_sql(v, NULL::inet) as v2 from tt_char_of_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_macaddr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::macaddr) as v1, try_convert_by_sql(v, NULL::macaddr) as v2 from tt_char_of_macaddr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_json) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::json) as v1, try_convert_by_sql(v, NULL::json) as v2 from tt_char_of_json) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_jsonb) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::jsonb) as v1, try_convert_by_sql(v, NULL::jsonb) as v2 from tt_char_of_jsonb) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql(v, NULL::xml) as v2 from tt_char_of_xml) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_char_of_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_char_of_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_char_of_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_char_of_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_char_of_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_char_of_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_char_of_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_char_of_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_char_of_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_char_of_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_char_of_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_money) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_char_of_money) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_uuid) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::uuid) as v1, try_convert_by_sql(v, NULL::uuid) as v2 from tt_char_of_uuid) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_char_of_regtype) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_char_of_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_varchar_of_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_varchar_of_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_varchar_of_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_varchar_of_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_varchar_of_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_varchar_of_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_complex) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_varchar_of_complex) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bool) as v1, try_convert_by_sql(v, NULL::bool) as v2 from tt_varchar_of_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_varchar_of_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_varchar_of_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_varchar_of_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_varchar_of_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_varchar_of_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql(v, NULL::varbit) as v2 from tt_varchar_of_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 1) as v2 from tt_varchar_of_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 5) as v2 from tt_varchar_of_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 10) as v2 from tt_varchar_of_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 20) as v2 from tt_varchar_of_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_varchar_of_date) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_varchar_of_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_varchar_of_timetz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_varchar_of_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_varchar_of_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_varchar_of_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_varchar_of_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::reltime) as v1, try_convert_by_sql(v, NULL::reltime) as v2 from tt_varchar_of_reltime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_point) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::point) as v1, try_convert_by_sql(v, NULL::point) as v2 from tt_varchar_of_point) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::cidr) as v1, try_convert_by_sql(v, NULL::cidr) as v2 from tt_varchar_of_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::inet) as v1, try_convert_by_sql(v, NULL::inet) as v2 from tt_varchar_of_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_macaddr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::macaddr) as v1, try_convert_by_sql(v, NULL::macaddr) as v2 from tt_varchar_of_macaddr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_json) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::json) as v1, try_convert_by_sql(v, NULL::json) as v2 from tt_varchar_of_json) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_jsonb) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::jsonb) as v1, try_convert_by_sql(v, NULL::jsonb) as v2 from tt_varchar_of_jsonb) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql(v, NULL::xml) as v2 from tt_varchar_of_xml) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_varchar_of_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_varchar_of_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_varchar_of_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_varchar_of_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_varchar_of_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_varchar_of_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_varchar_of_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_varchar_of_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_varchar_of_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_varchar_of_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_varchar_of_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_money) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_varchar_of_money) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_uuid) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::uuid) as v1, try_convert_by_sql(v, NULL::uuid) as v2 from tt_varchar_of_uuid) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_varchar_of_regtype) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_varchar_of_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +-- FUNCTION TESTS +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '6'::int2) as v1, try_convert_by_sql(v, '6'::int2) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '5.09526'::float4) as v1, try_convert_by_sql(v, '5.09526'::float4) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2.6338905075109076'::float8) as v1, try_convert_by_sql(v, '2.6338905075109076'::float8) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '5.09526'::float4) as v1, try_convert_by_sql(v, '5.09526'::float4) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2.6338905075109076'::float8) as v1, try_convert_by_sql(v, '2.6338905075109076'::float8) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '6'::int2) as v1, try_convert_by_sql(v, '6'::int2) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '5.09526'::float4) as v1, try_convert_by_sql(v, '5.09526'::float4) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2.6338905075109076'::float8) as v1, try_convert_by_sql(v, '2.6338905075109076'::float8) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '6'::int2) as v1, try_convert_by_sql(v, '6'::int2) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2.6338905075109076'::float8) as v1, try_convert_by_sql(v, '2.6338905075109076'::float8) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '6'::int2) as v1, try_convert_by_sql(v, '6'::int2) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '5.09526'::float4) as v1, try_convert_by_sql(v, '5.09526'::float4) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int2) as v1, try_convert_by_sql(v, NULL::int2) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '6'::int2) as v1, try_convert_by_sql(v, '6'::int2) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float4) as v1, try_convert_by_sql(v, NULL::float4) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '5.09526'::float4) as v1, try_convert_by_sql(v, '5.09526'::float4) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::float8) as v1, try_convert_by_sql(v, NULL::float8) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2.6338905075109076'::float8) as v1, try_convert_by_sql(v, '2.6338905075109076'::float8) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_money) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_money) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '10'::money) as v1, try_convert_by_sql(v, '10'::money) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '10'::money) as v1, try_convert_by_sql(v, '10'::money) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::money) as v1, try_convert_by_sql(v, NULL::money) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '10'::money) as v1, try_convert_by_sql(v, '10'::money) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bool) as v1, try_convert_by_sql(v, NULL::bool) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'f'::bool) as v1, try_convert_by_sql(v, 'f'::bool) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'bool'::regtype) as v1, try_convert_by_sql(v, 'bool'::regtype) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'bool'::regtype) as v1, try_convert_by_sql(v, 'bool'::regtype) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::regtype) as v1, try_convert_by_sql(v, NULL::regtype) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'bool'::regtype) as v1, try_convert_by_sql(v, 'bool'::regtype) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_regtype) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql_text(v::text, NULL::text, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::text, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(1)'::text, 1) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(1)'::text, 5) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(1)'::text, 10) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(1)'::text, 20) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(5)'::text, 1) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(5)'::text, 5) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(5)'::text, 10) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(5)'::text, 20) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(10)'::text, 1) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(10)'::text, 5) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(10)'::text, 10) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(10)'::text, 20) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(20)'::text, 1) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(20)'::text, 5) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(20)'::text, 10) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'char(20)'::text, 20) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(1)'::text, 1) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(1)'::text, 5) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(1)'::text, 10) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(1)'::text, 20) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(5)'::text, 1) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(5)'::text, 5) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(5)'::text, 10) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(5)'::text, 20) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(10)'::text, 1) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(10)'::text, 5) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(10)'::text, 10) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(10)'::text, 20) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(20)'::text, 1) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(20)'::text, 5) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(20)'::text, 10) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'char(20)'::text, 20) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::char) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 1) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 5) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 10) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 20) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(1)'::text, 1) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(1)'::text, 5) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(1)'::text, 10) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(1)'::text, 20) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(5)'::text, 1) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(5)'::text, 5) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(5)'::text, 10) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(5)'::text, 20) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(10)'::text, 1) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(10)'::text, 5) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(10)'::text, 10) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(10)'::text, 20) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql_text(v::text, NULL::char, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(20)'::text, 1) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(20)'::text, 5) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(20)'::text, 10) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::char, 'varchar(20)'::text, 20) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::char) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 1) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 5) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 10) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 20) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::char, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(1)'::text, 1) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(1)'::text, 5) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(1)'::text, 10) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(1)'::text, 20) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::char, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(5)'::text, 1) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(5)'::text, 5) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(5)'::text, 10) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(5)'::text, 20) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::char, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(10)'::text, 1) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(10)'::text, 5) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(10)'::text, 10) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(10)'::text, 20) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::char, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(20)'::text, 1) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(20)'::text, 5) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(20)'::text, 10) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::char, 'varchar(20)'::text, 20) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_char) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'char(1)'::text) as v2 from tt_char_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'char(5)'::text) as v2 from tt_char_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'char(10)'::text) as v2 from tt_char_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'char(20)'::text) as v2 from tt_char_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char) as v1, try_convert_by_sql(v, NULL::char) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 1) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 5) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 10) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::char(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::char, 20) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::char) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 1) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 5) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 10) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::char(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::char, 20) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28'::date) as v1, try_convert_by_sql(v, '2015-10-28'::date) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '13:35:45'::time) as v1, try_convert_by_sql(v, '13:35:45'::time) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28 16:35:45'::timestamp) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::timestamp) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v1, try_convert_by_sql(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '16736 days, 13:35:45'::interval) as v1, try_convert_by_sql(v, '16736 days, 13:35:45'::interval) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28 16:35:45'::timestamp) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::timestamp) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v1, try_convert_by_sql(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v2 from tt_date) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '16736 days, 13:35:45'::interval) as v1, try_convert_by_sql(v, '16736 days, 13:35:45'::interval) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '13:35:45 UTC'::timetz) as v1, try_convert_by_sql(v, '13:35:45 UTC'::timetz) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28 16:35:45'::abstime) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::abstime) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28'::date) as v1, try_convert_by_sql(v, '2015-10-28'::date) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '13:35:45'::time) as v1, try_convert_by_sql(v, '13:35:45'::time) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v1, try_convert_by_sql(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28 16:35:45'::abstime) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::abstime) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::date) as v1, try_convert_by_sql(v, NULL::date) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28'::date) as v1, try_convert_by_sql(v, '2015-10-28'::date) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '13:35:45'::time) as v1, try_convert_by_sql(v, '13:35:45'::time) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28 16:35:45'::timestamp) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::timestamp) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '13:35:45 UTC'::timetz) as v1, try_convert_by_sql(v, '13:35:45 UTC'::timetz) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::reltime) as v1, try_convert_by_sql(v, NULL::reltime) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '16736 days, 13:35:45'::reltime) as v1, try_convert_by_sql(v, '16736 days, 13:35:45'::reltime) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '13:35:45'::time) as v1, try_convert_by_sql(v, '13:35:45'::time) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '13:35:45'::time) as v1, try_convert_by_sql(v, '13:35:45'::time) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::abstime) as v1, try_convert_by_sql(v, NULL::abstime) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28 16:35:45'::abstime) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::abstime) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_abstime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::reltime) as v1, try_convert_by_sql(v, NULL::reltime) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '16736 days, 13:35:45'::reltime) as v1, try_convert_by_sql(v, '16736 days, 13:35:45'::reltime) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_reltime) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::inet) as v1, try_convert_by_sql(v, NULL::inet) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '192.168.100.128/25'::inet) as v1, try_convert_by_sql(v, '192.168.100.128/25'::inet) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::cidr) as v1, try_convert_by_sql(v, NULL::cidr) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '192.168.100.128/25'::cidr) as v1, try_convert_by_sql(v, '192.168.100.128/25'::cidr) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql(v, NULL::varbit) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 1) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 5) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 10) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 20) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(1)'::text, 1) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(1)'::text, 5) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(1)'::text, 10) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(1)'::text, 20) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(5)'::text, 1) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(5)'::text, 5) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(5)'::text, 10) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(5)'::text, 20) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(10)'::text, 1) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(10)'::text, 5) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(10)'::text, 10) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(10)'::text, 20) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(20)'::text, 1) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(20)'::text, 5) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(20)'::text, 10) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'bit(20)'::text, 20) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql(v, '1'::varbit) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 1) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 5) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 10) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 20) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(1)'::text, 1) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(1)'::text, 5) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(1)'::text, 10) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(1)'::text, 20) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(5)'::text, 1) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(5)'::text, 5) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(5)'::text, 10) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(5)'::text, 20) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(10)'::text, 1) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(10)'::text, 5) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(10)'::text, 10) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(10)'::text, 20) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(20)'::text, 1) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(20)'::text, 5) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(20)'::text, 10) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'bit(20)'::text, 20) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(1)'::text, 1) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(1)'::text, 5) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(1)'::text, 10) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(1)'::text, 20) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(5)'::text, 1) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(5)'::text, 5) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(5)'::text, 10) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(5)'::text, 20) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(10)'::text, 1) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(10)'::text, 5) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(10)'::text, 10) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(10)'::text, 20) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(20)'::text, 1) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(20)'::text, 5) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(20)'::text, 10) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'varbit(20)'::text, 20) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql(v, '1'::bit) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 1) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 5) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 10) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 20) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(1)'::text, 1) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(1)'::text, 5) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(1)'::text, 10) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(1)'::text, 20) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(5)'::text, 1) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(5)'::text, 5) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(5)'::text, 10) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(5)'::text, 20) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(10)'::text, 1) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(10)'::text, 5) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(10)'::text, 10) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(10)'::text, 20) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(20)'::text, 1) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(20)'::text, 5) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(20)'::text, 10) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'varbit(20)'::text, 20) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql(v, '1'::bit) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 1) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 5) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 10) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 20) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql(v, '1'::bit) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 1) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 5) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 10) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 20) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql(v, NULL::int8) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql_text(v::text, NULL::int8, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql_text(v::text, NULL::int8, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql_text(v::text, NULL::int8, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int8) as v1, try_convert_by_sql_text(v::text, NULL::int8, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql(v, '2'::int8) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql_text(v::text, '2'::int8, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql_text(v::text, '2'::int8, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql_text(v::text, '2'::int8, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2'::int8) as v1, try_convert_by_sql_text(v::text, '2'::int8, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql(v, NULL::int4) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::int4) as v1, try_convert_by_sql_text(v::text, NULL::int4, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql(v, '9'::int4) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '9'::int4) as v1, try_convert_by_sql_text(v::text, '9'::int4, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql(v, NULL::xml) as v2 from tt_text) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, ' '::xml) as v1, try_convert_by_sql(v, ' '::xml) as v2 from tt_text) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_cidr) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_bool) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_xml) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql(v, NULL::xml) as v2 from tt_varchar) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql_text(v::text, NULL::xml, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql_text(v::text, NULL::xml, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql_text(v::text, NULL::xml, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::xml) as v1, try_convert_by_sql_text(v::text, NULL::xml, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, ' '::xml) as v1, try_convert_by_sql(v, ' '::xml) as v2 from tt_varchar) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, ' '::xml) as v1, try_convert_by_sql_text(v::text, ' '::xml, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, ' '::xml) as v1, try_convert_by_sql_text(v::text, ' '::xml, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, ' '::xml) as v1, try_convert_by_sql_text(v::text, ' '::xml, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, ' '::xml) as v1, try_convert_by_sql_text(v::text, ' '::xml, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(1)'::text, 1) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(1)'::text, 5) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(1)'::text, 10) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(1)'::text, 20) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(5)'::text, 1) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(5)'::text, 5) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(5)'::text, 10) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(5)'::text, 20) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(10)'::text, 1) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(10)'::text, 5) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(10)'::text, 10) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(10)'::text, 20) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql_text(v::text, NULL::varchar, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(20)'::text, 1) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(20)'::text, 5) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(20)'::text, 10) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varchar, 'varchar(20)'::text, 20) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(1)'::text, 1) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(1)'::text, 5) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(1)'::text, 10) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(1)'::text, 20) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(5)'::text, 1) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(5)'::text, 5) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(5)'::text, 10) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(5)'::text, 20) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(10)'::text, 1) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(10)'::text, 5) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(10)'::text, 10) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(10)'::text, 20) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::varchar, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(20)'::text, 1) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(20)'::text, 5) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(20)'::text, 10) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, 'All the worlds a stage,'::varchar, 'varchar(20)'::text, 20) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::time) as v1, try_convert_by_sql(v, NULL::time) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '13:35:45'::time) as v1, try_convert_by_sql(v, '13:35:45'::time) as v2 from tt_time) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamp) as v1, try_convert_by_sql(v, NULL::timestamp) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28 16:35:45'::timestamp) as v1, try_convert_by_sql(v, '2015-10-28 16:35:45'::timestamp) as v2 from tt_timestamp) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timestamptz) as v1, try_convert_by_sql(v, NULL::timestamptz) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v1, try_convert_by_sql(v, '2015-10-28 13:35:45+00:00'::timestamptz) as v2 from tt_timestamptz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::interval) as v1, try_convert_by_sql(v, NULL::interval) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '16736 days, 13:35:45'::interval) as v1, try_convert_by_sql(v, '16736 days, 13:35:45'::interval) as v2 from tt_interval) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::timetz) as v1, try_convert_by_sql(v, NULL::timetz) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '13:35:45 UTC'::timetz) as v1, try_convert_by_sql(v, '13:35:45 UTC'::timetz) as v2 from tt_timetz) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql(v, NULL::bit) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 1) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 5) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 10) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::bit, 20) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(1)'::text, 1) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(1)'::text, 5) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(1)'::text, 10) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(1)'::text, 20) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(5)'::text, 1) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(5)'::text, 5) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(5)'::text, 10) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(5)'::text, 20) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(10)'::text, 1) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(10)'::text, 5) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(10)'::text, 10) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(10)'::text, 20) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit) as v1, try_convert_by_sql_text(v::text, NULL::bit, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(20)'::text, 1) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(20)'::text, 5) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(20)'::text, 10) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::bit, 'bit(20)'::text, 20) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql(v, '1'::bit) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 1) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 5) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 10) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_with_len_out(v, '1'::bit, 20) as v2 from tt_bit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'bit(1)'::text) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(1)'::text, 1) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(1)'::text, 5) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(1)'::text, 10) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(1)'::text, 20) as v2 from tt_bit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'bit(5)'::text) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(5)'::text, 1) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(5)'::text, 5) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(5)'::text, 10) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(5)'::text, 20) as v2 from tt_bit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'bit(10)'::text) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(10)'::text, 1) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(10)'::text, 5) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(10)'::text, 10) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(10)'::text, 20) as v2 from tt_bit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit) as v1, try_convert_by_sql_text(v::text, '1'::bit, 'bit(20)'::text) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(20)'::text, 1) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(20)'::text, 5) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(20)'::text, 10) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::bit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::bit, 'bit(20)'::text, 20) as v2 from tt_bit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql(v, NULL::varbit) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 1) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 5) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 10) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varbit, 20) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(1)'::text, 1) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(1)'::text, 5) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(1)'::text, 10) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(1)'::text, 20) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(5)'::text, 1) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(5)'::text, 5) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(5)'::text, 10) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(5)'::text, 20) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(10)'::text, 1) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(10)'::text, 5) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(10)'::text, 10) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(10)'::text, 20) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit) as v1, try_convert_by_sql_text(v::text, NULL::varbit, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(20)'::text, 1) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(20)'::text, 5) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(20)'::text, 10) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, NULL::varbit, 'varbit(20)'::text, 20) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql(v, '1'::varbit) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 1) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 5) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 10) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_with_len_out(v, '1'::varbit, 20) as v2 from tt_varbit) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'varbit(1)'::text) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(1)'::text, 1) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(1)'::text, 5) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(1)'::text, 10) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(1)'::text, 20) as v2 from tt_varbit_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'varbit(5)'::text) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(5)'::text, 1) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(5)'::text, 5) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(5)'::text, 10) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(5)'::text, 20) as v2 from tt_varbit_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'varbit(10)'::text) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(10)'::text, 1) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(10)'::text, 5) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(10)'::text, 10) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(10)'::text, 20) as v2 from tt_varbit_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit) as v1, try_convert_by_sql_text(v::text, '1'::varbit, 'varbit(20)'::text) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(1)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(20)'::text, 1) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(5)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(20)'::text, 5) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(10)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(20)'::text, 10) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1'::varbit(20)) as v1, try_convert_by_sql_text_with_len_out(v::text, '1'::varbit, 'varbit(20)'::text, 20) as v2 from tt_varbit_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::numeric) as v1, try_convert_by_sql(v, NULL::numeric) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '5.49803593494943'::numeric) as v1, try_convert_by_sql(v, '5.49803593494943'::numeric) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::jsonb) as v1, try_convert_by_sql(v, NULL::jsonb) as v2 from tt_json) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '{"glossary": {"title": "example glossary","GlossDiv": {"title": "S","GlossList": {"GlossEntry": {"ID": "SGML","SortAs": "SGML","GlossTerm": "Standard Generalized Markup Language","Acronym": "SGML","Abbrev": "ISO 8879:1986","GlossDef": {"para": "A meta-markup language, used to create markup languages such as DocBook.","GlossSeeAlso": ["GML", "XML"]},"GlossSee": "markup"}}}}}'::jsonb) as v1, try_convert_by_sql(v, '{"glossary": {"title": "example glossary","GlossDiv": {"title": "S","GlossList": {"GlossEntry": {"ID": "SGML","SortAs": "SGML","GlossTerm": "Standard Generalized Markup Language","Acronym": "SGML","Abbrev": "ISO 8879:1986","GlossDef": {"para": "A meta-markup language, used to create markup languages such as DocBook.","GlossSeeAlso": ["GML", "XML"]},"GlossSee": "markup"}}}}}'::jsonb) as v2 from tt_json) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::json) as v1, try_convert_by_sql(v, NULL::json) as v2 from tt_jsonb) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '{"glossary": {"title": "example glossary","GlossDiv": {"title": "S","GlossList": {"GlossEntry": {"ID": "SGML","SortAs": "SGML","GlossTerm": "Standard Generalized Markup Language","Acronym": "SGML","Abbrev": "ISO 8879:1986","GlossDef": {"para": "A meta-markup language, used to create markup languages such as DocBook.","GlossSeeAlso": ["GML", "XML"]},"GlossSee": "markup"}}}}}'::json) as v1, try_convert_by_sql(v, '{"glossary": {"title": "example glossary","GlossDiv": {"title": "S","GlossList": {"GlossEntry": {"ID": "SGML","SortAs": "SGML","GlossTerm": "Standard Generalized Markup Language","Acronym": "SGML","Abbrev": "ISO 8879:1986","GlossDef": {"para": "A meta-markup language, used to create markup languages such as DocBook.","GlossSeeAlso": ["GML", "XML"]},"GlossSee": "markup"}}}}}'::json) as v2 from tt_jsonb) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_float8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_float4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_int8) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_int4) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_int2) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_point) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_point) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::point) as v1, try_convert_by_sql(v, NULL::point) as v2 from tt_complex) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '(1, 2)'::point) as v1, try_convert_by_sql(v, '(1, 2)'::point) as v2 from tt_complex) as t(v1, v2) where v1::text is distinct from v2::text; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::complex) as v1, try_convert_by_sql(v, NULL::complex) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, '1.1 + 1.0i'::complex) as v1, try_convert_by_sql(v, '1.1 + 1.0i'::complex) as v2 from tt_numeric) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::text) as v1, try_convert_by_sql(v, NULL::text) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::text) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::text) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar) as v1, try_convert_by_sql(v, NULL::varchar) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 1) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 5) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 10) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, NULL::varchar, 20) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::varchar) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(1)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 1) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(5)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 5) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(10)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 10) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::varchar(20)) as v1, try_convert_by_sql_with_len_out(v, 'All the worlds a stage,'::varchar, 20) as v2 from tt_citext) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::citext) as v2 from tt_text) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql_text(v::text, NULL::citext, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::citext) as v2 from tt_varchar) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::citext, 'varchar(1)'::text) as v2 from tt_varchar_1) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::citext, 'varchar(5)'::text) as v2 from tt_varchar_5) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::citext, 'varchar(10)'::text) as v2 from tt_varchar_10) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql_text(v::text, 'All the worlds a stage,'::citext, 'varchar(20)'::text) as v2 from tt_varchar_20) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, NULL::citext) as v1, try_convert_by_sql(v, NULL::citext) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +select * from (select try_convert(v, 'All the worlds a stage,'::citext) as v1, try_convert_by_sql(v, 'All the worlds a stage,'::citext) as v2 from tt_inet) as t(v1, v2) where v1 is distinct from v2; + v1 | v2 +----+---- +(0 rows) + +-- MILLION TESTS +DROP TABLE IF EXISTS text_ints; CREATE TABLE text_ints (v text) DISTRIBUTED BY (v); +INSERT INTO text_ints(v) SELECT (random()*1000)::int4::text FROM generate_series(1,1000000); +DROP TABLE IF EXISTS text_error_ints; CREATE TABLE text_error_ints (v text) DISTRIBUTED BY (v); +INSERT INTO text_error_ints(v) SELECT (random()*1000000 + 1000000)::int8::text FROM generate_series(1,1000000); +DROP TABLE IF EXISTS int4_ints; CREATE TABLE int4_ints (v int4) DISTRIBUTED BY (v); +INSERT INTO int4_ints(v) SELECT (random()*1000)::int4 FROM generate_series(1,1000000); +DROP TABLE IF EXISTS int4_error_ints; CREATE TABLE int4_error_ints (v int4) DISTRIBUTED BY (v); +INSERT INTO int4_error_ints(v) SELECT (random()*1000000 + 1000000)::int4 FROM generate_series(1,1000000); +SELECT count(*) FROM (SELECT try_convert(v, NULL::int2) as v FROM text_ints) as t(v) WHERE v IS NOT NULL; + count +--------- + 1000000 +(1 row) + +SELECT count(*) FROM (SELECT try_convert(v, NULL::int2) as v FROM text_error_ints) as t(v) WHERE v IS NULL; + count +--------- + 1000000 +(1 row) + +SELECT count(*) FROM (SELECT try_convert(v, NULL::int2) as v FROM int4_ints) as t(v) WHERE v IS NOT NULL; + count +--------- + 1000000 +(1 row) + +SELECT count(*) FROM (SELECT try_convert(v, NULL::int2) as v FROM int4_error_ints) as t(v) WHERE v IS NULL; + count +--------- + 1000000 +(1 row) + +-- NESTED TESTS +select try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(try_convert(42::int4, NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4), NULL::text), NULL::int4) as v; + v +---- + 42 +(1 row) + +reset search_path; diff --git a/contrib/try_convert/test_data.sql b/contrib/try_convert/test_data.sql new file mode 100644 index 0000000000..fcae0b9527 --- /dev/null +++ b/contrib/try_convert/test_data.sql @@ -0,0 +1,13 @@ +-- LOAD DATA +CREATE TABLE tt_int2 (v int2) DISTRIBUTED BY (v); +COPY tt_int2 from '@abs_srcdir@/data/tt_int2.data'; +CREATE TABLE tt_int4 (v int4) DISTRIBUTED BY (v); +COPY tt_int4 from '@abs_srcdir@/data/tt_int4.data'; +CREATE TABLE tt_int8 (v int8) DISTRIBUTED BY (v); +COPY tt_int8 from '@abs_srcdir@/data/tt_int8.data'; +CREATE TABLE tt_float4 (v float4) DISTRIBUTED BY (v); +COPY tt_float4 from '@abs_srcdir@/data/tt_float4.data'; +CREATE TABLE tt_float8 (v float8) DISTRIBUTED BY (v); +COPY tt_float8 from '@abs_srcdir@/data/tt_float8.data'; +CREATE TABLE tt_numeric (v numeric) DISTRIBUTED BY (v); +COPY tt_numeric from '@abs_srcdir@/data/tt_numeric.data'; diff --git a/contrib/try_convert/try_convert--1.0.sql b/contrib/try_convert/try_convert--1.0.sql new file mode 100644 index 0000000000..cf01e6385d --- /dev/null +++ b/contrib/try_convert/try_convert--1.0.sql @@ -0,0 +1,92 @@ +/* contrib/try_convert/try_convert--1.0.sql */ + +-- complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "CREATE EXTENSION try_convert" to load this file. \quit + +/* *********************************************** + * try_convert function for PostgreSQL + * *********************************************** */ + +/* generic file access functions */ + +CREATE FUNCTION try_convert(text, anyelement) +RETURNS anyelement +AS 'MODULE_PATHNAME', 'try_convert' +LANGUAGE C; + +-- DEBUG +CREATE FUNCTION get_targettypeid(anyelement) +RETURNS int4 +AS 'MODULE_PATHNAME', 'get_targettypeid' +LANGUAGE C; + +CREATE FUNCTION get_targetbasetypeid(anyelement) +RETURNS int4 +AS 'MODULE_PATHNAME', 'get_targetbasetypeid' +LANGUAGE C; + +CREATE FUNCTION get_targettypmod(anyelement) +RETURNS int4 +AS 'MODULE_PATHNAME', 'get_targettypmod' +LANGUAGE C; + + +CREATE OR REPLACE FUNCTION add_type_for_try_convert(type regtype) + RETURNS void + LANGUAGE plpgsql AS +$func$ +BEGIN + EXECUTE 'CREATE OR REPLACE FUNCTION try_convert(' || type || ', anyelement) + RETURNS anyelement + AS ''MODULE_PATHNAME'', ''try_convert'' + LANGUAGE C;'; +END +$func$; + +-- NUMBERS +select add_type_for_try_convert('int2'::regtype); +select add_type_for_try_convert('int4'::regtype); +select add_type_for_try_convert('int8'::regtype); +select add_type_for_try_convert('float4'::regtype); +select add_type_for_try_convert('float8'::regtype); +select add_type_for_try_convert('numeric'::regtype); +select add_type_for_try_convert('complex'::regtype); + +-- TIME +select add_type_for_try_convert('date'::regtype); +select add_type_for_try_convert('time'::regtype); +select add_type_for_try_convert('timetz'::regtype); +select add_type_for_try_convert('timestamp'::regtype); +select add_type_for_try_convert('timestamptz'::regtype); +select add_type_for_try_convert('interval'::regtype); +select add_type_for_try_convert('abstime'::regtype); +select add_type_for_try_convert('reltime'::regtype); + +-- CHARACTER +select add_type_for_try_convert('char'::regtype); +select add_type_for_try_convert('bpchar'::regtype); +select add_type_for_try_convert('varchar'::regtype); +select add_type_for_try_convert('text'::regtype); + +-- BIT STRING +select add_type_for_try_convert('bit'::regtype); +select add_type_for_try_convert('varbit'::regtype); + +select add_type_for_try_convert('bool'::regtype); + +select add_type_for_try_convert('money'::regtype); + +select add_type_for_try_convert('uuid'::regtype); + +-- GEOMETRY +select add_type_for_try_convert('point'::regtype); + +-- IP/MAC +select add_type_for_try_convert('cidr'::regtype); +select add_type_for_try_convert('inet'::regtype); +select add_type_for_try_convert('macaddr'::regtype); + +-- OBJ +select add_type_for_try_convert('json'::regtype); +select add_type_for_try_convert('jsonb'::regtype); +select add_type_for_try_convert('xml'::regtype); diff --git a/contrib/try_convert/try_convert.c b/contrib/try_convert/try_convert.c new file mode 100644 index 0000000000..cc82d4bcd8 --- /dev/null +++ b/contrib/try_convert/try_convert.c @@ -0,0 +1,476 @@ +#include "postgres.h" + +#include "catalog/pg_cast.h" +#include "utils/syscache.h" +#include "utils/lsyscache.h" +#include "nodes/nodeFuncs.h" +#include "nodes/miscnodes.h" + +#include "funcapi.h" + +// #define USE_PG_TRY_CATCH + +PG_MODULE_MAGIC; + +PG_FUNCTION_INFO_V1(try_convert); + +// DEBUG +PG_FUNCTION_INFO_V1(get_targettypeid); +PG_FUNCTION_INFO_V1(get_targetbasetypeid); +PG_FUNCTION_INFO_V1(get_targettypmod); + + +typedef enum ConversionType +{ + CONVERSION_TYPE_FUNC, + CONVERSION_TYPE_RELABEL, + CONVERSION_TYPE_VIA_IO, + CONVERSION_TYPE_ARRAY, + CONVERSION_TYPE_NONE +} ConversionType; + + +ConversionType +find_conversion_way(Oid targetTypeId, Oid sourceTypeId, Oid *funcId) +{ + ConversionType result = CONVERSION_TYPE_NONE; + HeapTuple tuple; + + *funcId = InvalidOid; + + /* Perhaps the types are domains; if so, look at their base types */ + if (OidIsValid(sourceTypeId)) + sourceTypeId = getBaseType(sourceTypeId); + if (OidIsValid(targetTypeId)) + targetTypeId = getBaseType(targetTypeId); + + /* Domains are always coercible to and from their base type */ + if (sourceTypeId == targetTypeId) + return CONVERSION_TYPE_RELABEL; + + /* SELECT castcontext from pg_cast */ + + /* Look in pg_cast */ + tuple = SearchSysCache2(CASTSOURCETARGET, + ObjectIdGetDatum(sourceTypeId), + ObjectIdGetDatum(targetTypeId)); + + if (HeapTupleIsValid(tuple)) + { + Form_pg_cast castForm = (Form_pg_cast) GETSTRUCT(tuple); + + switch (castForm->castmethod) + { + case COERCION_METHOD_FUNCTION: + *funcId = castForm->castfunc; + result = CONVERSION_TYPE_FUNC; + break; + case COERCION_METHOD_INOUT: + result = CONVERSION_TYPE_VIA_IO; + break; + case COERCION_METHOD_BINARY: + result = CONVERSION_TYPE_RELABEL; + break; + default: + elog(ERROR, "unrecognized castmethod: %d", + (int) castForm->castmethod); + break; + } + + + ReleaseSysCache(tuple); + } + else + { + /* + * If there's no pg_cast entry, perhaps we are dealing with a pair of + * array types. If so, and if the element types have a suitable cast, + * report that we can coerce with an ArrayCoerceExpr. + * + * Note that the source type can be a domain over array, but not the + * target, because ArrayCoerceExpr won't check domain constraints. + * + * Hack: disallow coercions to oidvector and int2vector, which + * otherwise tend to capture coercions that should go to "real" array + * types. We want those types to be considered "real" arrays for many + * purposes, but not this one. (Also, ArrayCoerceExpr isn't + * guaranteed to produce an output that meets the restrictions of + * these datatypes, such as being 1-dimensional.) + */ + if (targetTypeId != OIDVECTOROID && targetTypeId != INT2VECTOROID) + { + Oid targetElem; + Oid sourceElem; + + if ((targetElem = get_element_type(targetTypeId)) != InvalidOid && + (sourceElem = get_base_element_type(sourceTypeId)) != InvalidOid) + { + ConversionType elempathtype; + Oid elemfuncid; + + elempathtype = find_conversion_way(targetElem, + sourceElem, + &elemfuncid); + if (elempathtype != CONVERSION_TYPE_NONE && + elempathtype != CONVERSION_TYPE_ARRAY) + { + *funcId = elemfuncid; + if (elempathtype == CONVERSION_TYPE_VIA_IO) + result = CONVERSION_TYPE_VIA_IO; + else + result = CONVERSION_TYPE_ARRAY; + } + } + } + + /* + * If we still haven't found a possibility, consider automatic casting + * using I/O functions. We allow assignment casts to string types and + * explicit casts from string types to be handled this way. (The + * CoerceViaIO mechanism is a lot more general than that, but this is + * all we want to allow in the absence of a pg_cast entry.) It would + * probably be better to insist on explicit casts in both directions, + * but this is a compromise to preserve something of the pre-8.3 + * behavior that many types had implicit (yipes!) casts to text. + */ + if (result == CONVERSION_TYPE_NONE) + { + if (TypeCategory(targetTypeId) == TYPCATEGORY_STRING) + result = CONVERSION_TYPE_VIA_IO; + else if (TypeCategory(sourceTypeId) == TYPCATEGORY_STRING) + result = CONVERSION_TYPE_VIA_IO; + } + } + + return result; +} + +ConversionType +find_typmod_conversion_function(Oid typeId, Oid *funcId) +{ + ConversionType result; + // HeapTuple targetType; + Form_pg_type typeForm; + HeapTuple tuple; + + *funcId = InvalidOid; + result = CONVERSION_TYPE_FUNC; + + // targetType = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typeId)); + // typeForm = (Form_pg_type) GETSTRUCT(targetType); + + // /* Check for a varlena array type */ + // if (typeForm->typelem != InvalidOid && typeForm->typlen == -1) + // { + // /* Yes, switch our attention to the element type */ + // typeId = typeForm->typelem; + // result = CONVERSION_TYPE_ARRAY; + // } + // ReleaseSysCache(targetType); + + /* Look in pg_cast */ + tuple = SearchSysCache2(CASTSOURCETARGET, + ObjectIdGetDatum(typeId), + ObjectIdGetDatum(typeId)); + + if (HeapTupleIsValid(tuple)) + { + Form_pg_cast castForm = (Form_pg_cast) GETSTRUCT(tuple); + + *funcId = castForm->castfunc; + ReleaseSysCache(tuple); + } + + if (!OidIsValid(*funcId)) + result = CONVERSION_TYPE_NONE; + + return result; +} + +Datum +try_convert_from_function(Datum value, int32 typmod, Oid funcId, bool *is_failed) +{ + Datum res = 0; + + ErrorSaveContext escontext = {T_ErrorSaveContext, false}; + +#ifdef USE_PG_TRY_CATCH + PG_TRY(); + { +#endif + + res = OidFunctionCall3Safe(funcId, value, typmod, true, &escontext); + + if (escontext.error_occurred) { + *is_failed = true; + } + +#ifdef USE_PG_TRY_CATCH + } + PG_CATCH(); + { + *is_failed = true; + FlushErrorState(); + } + PG_END_TRY(); +#endif + + + return res; +} + + +Datum +try_convert_via_io(Datum value, Oid sourceTypeId, Oid targetTypeId, int32 targetTypMod, bool *is_failed) +{ + FmgrInfo outfunc; + FmgrInfo infunc; + + Oid iofunc = InvalidOid; + bool outtypisvarlena = false; + Oid intypioparam = InvalidOid; + + /* Perhaps the types are domains; if so, look at their base types */ + if (OidIsValid(sourceTypeId)) + sourceTypeId = getBaseType(sourceTypeId); + if (OidIsValid(targetTypeId)) + targetTypeId = getBaseType(targetTypeId); + + /* lookup the input type's output function */ + getTypeOutputInfo(sourceTypeId, &iofunc, &outtypisvarlena); + fmgr_info(iofunc, &outfunc); + + getTypeInputInfo(targetTypeId, &iofunc, &intypioparam); + fmgr_info(iofunc, &infunc); + + Datum res = 0; + char *string; + + ErrorSaveContext escontext = {T_ErrorSaveContext, false}; + +#ifdef USE_PG_TRY_CATCH + PG_TRY(); + { +#endif + + // value cannot be null + string = OutputFunctionCall(&outfunc, value); + + res = InputFunctionCallSafe(&infunc, + string, + intypioparam, + -1, + &escontext); + + if (escontext.error_occurred) { + *is_failed = true; + } + +#ifdef USE_PG_TRY_CATCH + } + PG_CATCH(); + { + *is_failed = true; + FlushErrorState(); + } + PG_END_TRY(); +#endif + + return res; +} + + +/* + * Get the actual typmod int32 of a specific function argument (counting from 0), + * but working from the calling expression tree instead of FmgrInfo + * + * Returns -1 if information is not available + */ +int32 +get_call_expr_argtypmod(Node *expr, int argnum) +{ + List *args; + int32 argtypmod; + + if (expr == NULL) + return -1; + + if (IsA(expr, FuncExpr)) + args = ((FuncExpr *) expr)->args; + else if (IsA(expr, OpExpr)) + args = ((OpExpr *) expr)->args; + else if (IsA(expr, DistinctExpr)) + args = ((DistinctExpr *) expr)->args; + else if (IsA(expr, ScalarArrayOpExpr)) + args = ((ScalarArrayOpExpr *) expr)->args; + else if (IsA(expr, ArrayCoerceExpr)) + args = list_make1(((ArrayCoerceExpr *) expr)->arg); + else if (IsA(expr, NullIfExpr)) + args = ((NullIfExpr *) expr)->args; + else if (IsA(expr, WindowFunc)) + args = ((WindowFunc *) expr)->args; + else + return -1; + + if (argnum < 0 || argnum >= list_length(args)) + return -1; + + argtypmod = exprTypmod((Node *) list_nth(args, argnum)); + + // /* + // * special hack for ScalarArrayOpExpr and ArrayCoerceExpr: what the + // * underlying function will actually get passed is the element type of the + // * array. + // */ + // if (IsA(expr, ScalarArrayOpExpr) && + // argnum == 1) + // argtypmod = get_base_element_type(argtype); + // else if (IsA(expr, ArrayCoerceExpr) && + // argnum == 0) + // argtypmod = get_base_element_type(argtype); + + return argtypmod; +} + +/* + * Get the actual typemod of a specific function argument (counting from 0) + * + * Returns -1 if information is not available + */ +Oid +get_fn_expr_argtypmod(FmgrInfo *flinfo, int argnum) +{ + /* + * can't return anything useful if we have no FmgrInfo or if its fn_expr + * node has not been initialized + */ + if (!flinfo || !flinfo->fn_expr) + return -1; + + return get_call_expr_argtypmod(flinfo->fn_expr, argnum); +} + +Datum +get_targettypeid(PG_FUNCTION_ARGS) +{ + PG_RETURN_INT32(get_fn_expr_argtype(fcinfo->flinfo, 0)); +} + +Datum +get_targetbasetypeid(PG_FUNCTION_ARGS) +{ + PG_RETURN_INT32(getBaseType(get_fn_expr_argtype(fcinfo->flinfo, 0))); +} + +Datum +get_targettypmod(PG_FUNCTION_ARGS) +{ + PG_RETURN_INT32(get_fn_expr_argtypmod(fcinfo->flinfo, 0)); +} + + +Datum +convert(Datum value, ConversionType conversion_type, Oid funcId, Oid sourceTypeId, Oid targetTypeId, int32 targetTypMod, bool *is_failed) { + + switch (conversion_type) + { + case CONVERSION_TYPE_RELABEL: + return value; + + case CONVERSION_TYPE_FUNC: + return try_convert_from_function(value, targetTypMod, funcId, is_failed); + + case CONVERSION_TYPE_VIA_IO: + return try_convert_via_io(value, sourceTypeId, targetTypeId, targetTypMod, is_failed); + + case CONVERSION_TYPE_ARRAY: + elog(ERROR, "no sopport for ARRAY CONVERSION"); + is_failed = true; + break; + + case CONVERSION_TYPE_NONE: + is_failed = true; + return 0; + + default: + /// TODO RAISE ERROR + elog(ERROR, "unrecognized conversion method: %d", + (int) conversion_type); + break; + } + + return 0; +} + +Datum convert_type_typmod(Datum value, int32 sourceTypMod, Oid targetTypeId, int32 targetTypMod, bool *is_failed) { + if (targetTypMod < 0 || targetTypMod == sourceTypMod) + return value; + + Oid funcId = InvalidOid; + ConversionType conversion_type = find_typmod_conversion_function(targetTypeId, &funcId); + + return convert(value, conversion_type, funcId, InvalidOid, targetTypeId, targetTypMod, is_failed); +} + + +Datum +try_convert(PG_FUNCTION_ARGS) +{ + if (fcinfo->argnull[0]) { + PG_RETURN_NULL(); + } + + Oid sourceTypeId = get_fn_expr_argtype(fcinfo->flinfo, 0); + int32 sourceTypMod = get_fn_expr_argtypmod(fcinfo->flinfo, 0); + + Oid targetTypeId = get_fn_expr_argtype(fcinfo->flinfo, 1); + int32 targetTypMod = get_fn_expr_argtypmod(fcinfo->flinfo, 1); + + int32 baseTypMod = targetTypMod; + Oid baseTypeId = getBaseTypeAndTypmod(targetTypeId, &baseTypMod); + + Oid funcId; + + ConversionType conversion_type = find_conversion_way(targetTypeId, sourceTypeId, &funcId); + + Datum value = fcinfo->arg[0]; + + Datum res = value; + Oid resTypeId = sourceTypeId; + int32 resTypMod = sourceTypMod; + + bool is_failed = false; + + if (conversion_type != CONVERSION_TYPE_RELABEL) { + + res = convert(value, conversion_type, funcId, sourceTypeId, baseTypeId, baseTypMod, &is_failed); + + if (is_failed) { + fcinfo->isnull = fcinfo->argnull[1]; + res = fcinfo->arg[1]; + } + + resTypeId = baseTypeId; + resTypMod = -1; + + // if (targetTypeId != baseTypeId) { + // COERCE_DOMAIN(); + // } + } else { + + res = value; + + // if (targetTypeId != baseTypeId) { + // COERCE_DOMAIN(); + // } + } + + res = convert_type_typmod(res, -1, targetTypeId, targetTypMod, &is_failed); + + if (is_failed) { + fcinfo->isnull = fcinfo->argnull[1]; + res = fcinfo->arg[1]; + } + + return res; +} \ No newline at end of file diff --git a/contrib/try_convert/try_convert.control b/contrib/try_convert/try_convert.control new file mode 100644 index 0000000000..f78c59a0ac --- /dev/null +++ b/contrib/try_convert/try_convert.control @@ -0,0 +1,5 @@ +# try_convert extension +comment = 'function for type cast' +default_version = '1.0' +module_pathname = '$libdir/try_convert' +relocatable = true diff --git a/src/backend/utils/adt/float.c b/src/backend/utils/adt/float.c index 2a50d2af1e..f196dd5e1a 100644 --- a/src/backend/utils/adt/float.c +++ b/src/backend/utils/adt/float.c @@ -194,7 +194,7 @@ float4in(PG_FUNCTION_ARGS) * strtod() on different platforms. */ if (*num == '\0') - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for type real: \"%s\"", orig_num))); @@ -262,13 +262,13 @@ float4in(PG_FUNCTION_ARGS) * to see if the result is zero or huge. */ if (val == 0.0 || val >= HUGE_VAL || val <= -HUGE_VAL) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("\"%s\" is out of range for type real", orig_num))); } else - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for type real: \"%s\"", orig_num))); @@ -394,7 +394,7 @@ float8in(PG_FUNCTION_ARGS) * strtod() on different platforms. */ if (*num == '\0') - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for type double precision: \"%s\"", orig_num))); @@ -462,13 +462,13 @@ float8in(PG_FUNCTION_ARGS) * to see if the result is zero or huge. */ if (val == 0.0 || val >= HUGE_VAL || val <= -HUGE_VAL) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("\"%s\" is out of range for type double precision", orig_num))); } else - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for type double precision: \"%s\"", orig_num))); @@ -492,7 +492,7 @@ float8in(PG_FUNCTION_ARGS) /* if there is any junk left at the end of the string, bail out */ if (*endptr != '\0') - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for type double precision: \"%s\"", orig_num))); @@ -1167,7 +1167,7 @@ dtoi4(PG_FUNCTION_ARGS) /* Range check */ if (isnan(num) || !FLOAT8_FITS_IN_INT32(num)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("integer out of range"))); @@ -1192,7 +1192,7 @@ dtoi2(PG_FUNCTION_ARGS) /* Range check */ if (isnan(num) || !FLOAT8_FITS_IN_INT16(num)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("smallint out of range"))); @@ -1241,7 +1241,7 @@ ftoi4(PG_FUNCTION_ARGS) /* Range check */ if (isnan(num) || !FLOAT4_FITS_IN_INT32(num)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("integer out of range"))); @@ -1266,7 +1266,7 @@ ftoi2(PG_FUNCTION_ARGS) /* Range check */ if (isnan(num) || !FLOAT4_FITS_IN_INT16(num)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("smallint out of range"))); diff --git a/src/backend/utils/adt/int.c b/src/backend/utils/adt/int.c index b8f56e5c2e..f8c61d68c0 100644 --- a/src/backend/utils/adt/int.c +++ b/src/backend/utils/adt/int.c @@ -62,7 +62,7 @@ int2in(PG_FUNCTION_ARGS) { char *num = PG_GETARG_CSTRING(0); - PG_RETURN_INT16(pg_atoi(num, sizeof(int16), '\0')); + PG_RETURN_INT16(pg_atoi_safe(num, sizeof(int16), '\0', fcinfo->context)); } /* @@ -282,7 +282,7 @@ int4in(PG_FUNCTION_ARGS) { char *num = PG_GETARG_CSTRING(0); - PG_RETURN_INT32(pg_atoi(num, sizeof(int32), '\0')); + PG_RETURN_INT32(pg_atoi_safe(num, sizeof(int32), '\0', fcinfo->context)); } /* @@ -344,7 +344,7 @@ i4toi2(PG_FUNCTION_ARGS) int32 arg1 = PG_GETARG_INT32(0); if (arg1 < SHRT_MIN || arg1 > SHRT_MAX) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("smallint out of range"))); diff --git a/src/backend/utils/adt/int8.c b/src/backend/utils/adt/int8.c index 2788853c1b..a61a011f73 100644 --- a/src/backend/utils/adt/int8.c +++ b/src/backend/utils/adt/int8.c @@ -52,7 +52,15 @@ typedef struct * If errorOK is true, just return "false" for bad input. */ bool -scanint8(const char *str, bool errorOK, int64 *result) +scanint8(const char *str, bool errorOK, int64 *result) { + return scanint8_safe(str, errorOK, result, NULL); +} + +/* + * Same as scanint8() but if escontext is ErrorSaveContext then saves error in context and exits + */ +bool +scanint8_safe(const char *str, bool errorOK, int64 *result, Node* escontext) { const char *ptr = str; int64 tmp = 0; @@ -93,7 +101,7 @@ scanint8(const char *str, bool errorOK, int64 *result) if (errorOK) return false; else - ereport(ERROR, + ereturn(escontext, 0, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for integer: \"%s\"", str))); @@ -109,7 +117,7 @@ scanint8(const char *str, bool errorOK, int64 *result) if (errorOK) return false; else - ereport(ERROR, + ereturn(escontext, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("value \"%s\" is out of range for type bigint", str))); @@ -128,7 +136,7 @@ scanint8(const char *str, bool errorOK, int64 *result) if (errorOK) return false; else - ereport(ERROR, + ereturn(escontext, 0, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for integer: \"%s\"", str))); @@ -147,7 +155,7 @@ int8in(PG_FUNCTION_ARGS) char *str = PG_GETARG_CSTRING(0); int64 result; - (void) scanint8(str, false, &result); + (void) scanint8_safe(str, false, &result, fcinfo->context); PG_RETURN_INT64(result); } @@ -495,7 +503,7 @@ int8um(PG_FUNCTION_ARGS) result = -arg; /* overflow check (needed for INT64_MIN) */ if (arg != 0 && SAMESIGN(result, arg)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("bigint out of range"))); PG_RETURN_INT64(result); @@ -1293,7 +1301,7 @@ int84(PG_FUNCTION_ARGS) /* Test for overflow by reverse-conversion. */ if ((int64) result != arg) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("integer out of range"))); @@ -1318,7 +1326,7 @@ int82(PG_FUNCTION_ARGS) /* Test for overflow by reverse-conversion. */ if ((int64) result != arg) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("smallint out of range"))); @@ -1353,7 +1361,7 @@ dtoi8(PG_FUNCTION_ARGS) /* Range check */ if (isnan(num) || !FLOAT8_FITS_IN_INT64(num)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("bigint out of range"))); @@ -1388,7 +1396,7 @@ ftoi8(PG_FUNCTION_ARGS) /* Range check */ if (isnan(num) || !FLOAT4_FITS_IN_INT64(num)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("bigint out of range"))); @@ -1405,7 +1413,7 @@ i8tooid(PG_FUNCTION_ARGS) /* Test for overflow by reverse-conversion. */ if ((int64) result != arg) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("OID out of range"))); diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c index 522ea2d2ec..de7b0c9f8f 100644 --- a/src/backend/utils/adt/numeric.c +++ b/src/backend/utils/adt/numeric.c @@ -405,6 +405,7 @@ static void alloc_var(NumericVar *var, int ndigits); static void zero_var(NumericVar *var); static const char *init_var_from_str(const char *str, const char *cp, NumericVar *dest); +static const char *init_var_from_str_safe(const char *str, const char *cp, NumericVar *dest, Node* escontext); static void set_var_from_var(NumericVar *value, NumericVar *dest); static void init_var_from_var(NumericVar *value, NumericVar *dest); static void init_ro_var_from_var(NumericVar *value, NumericVar *dest); @@ -424,6 +425,7 @@ static Numeric make_result(NumericVar *var); static void apply_typmod(NumericVar *var, int32 typmod); static int32 numericvar_to_int32(NumericVar *var); +static int32 numericvar_to_int32_safe(NumericVar *var, Node* escontext); static bool numericvar_to_int64(NumericVar *var, int64 *result); static void int64_to_numericvar(int64 val, NumericVar *var); #ifdef HAVE_INT128 @@ -519,7 +521,7 @@ numeric_in(PG_FUNCTION_ARGS) while (*cp) { if (!isspace((unsigned char) *cp)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for type numeric: \"%s\"", str))); @@ -534,7 +536,9 @@ numeric_in(PG_FUNCTION_ARGS) */ NumericVar value; - cp = init_var_from_str(str, cp, &value); + cp = init_var_from_str_safe(str, cp, &value, fcinfo->context); + if (cp == NULL) + return 0; /* * We duplicate a few lines of code here because we would like to @@ -545,7 +549,7 @@ numeric_in(PG_FUNCTION_ARGS) while (*cp) { if (!isspace((unsigned char) *cp)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for type numeric: \"%s\"", str))); @@ -970,12 +974,12 @@ numerictypmodin(PG_FUNCTION_ARGS) if (n == 2) { if (tl[0] < 1 || tl[0] > NUMERIC_MAX_PRECISION) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("NUMERIC precision %d must be between 1 and %d", tl[0], NUMERIC_MAX_PRECISION))); if (tl[1] < 0 || tl[1] > tl[0]) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("NUMERIC scale %d must be between 0 and precision %d", tl[1], tl[0]))); @@ -984,7 +988,7 @@ numerictypmodin(PG_FUNCTION_ARGS) else if (n == 1) { if (tl[0] < 1 || tl[0] > NUMERIC_MAX_PRECISION) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("NUMERIC precision %d must be between 1 and %d", tl[0], NUMERIC_MAX_PRECISION))); @@ -993,7 +997,7 @@ numerictypmodin(PG_FUNCTION_ARGS) } else { - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid NUMERIC type modifier"))); typmod = 0; /* keep compiler quiet */ @@ -2596,13 +2600,13 @@ numeric_int4(PG_FUNCTION_ARGS) /* XXX would it be better to return NULL? */ if (NUMERIC_IS_NAN(num)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot convert NaN to integer"))); /* Convert to variable format, then convert to int4 */ init_var_from_num(num, &x); - result = numericvar_to_int32(&x); + result = numericvar_to_int32_safe(&x, fcinfo->context); PG_RETURN_INT32(result); } @@ -2611,14 +2615,21 @@ numeric_int4(PG_FUNCTION_ARGS) * exceeds the range of an int32, raise the appropriate error via * ereport(). The input NumericVar is *not* free'd. */ + static int32 numericvar_to_int32(NumericVar *var) +{ + return numericvar_to_int32_safe(var, NULL); +} + +static int32 +numericvar_to_int32_safe(NumericVar *var, Node* escontext) { int32 result; int64 val = 0; if (!numericvar_to_int64(var, &val)) - ereport(ERROR, + ereturn(escontext, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("integer out of range"))); @@ -2627,7 +2638,7 @@ numericvar_to_int32(NumericVar *var) /* Test for overflow by reverse-conversion. */ if ((int64) result != val) - ereport(ERROR, + ereturn(escontext, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("integer out of range"))); @@ -2660,7 +2671,7 @@ numeric_int8(PG_FUNCTION_ARGS) /* XXX would it be better to return NULL? */ if (NUMERIC_IS_NAN(num)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot convert NaN to bigint"))); @@ -2668,7 +2679,7 @@ numeric_int8(PG_FUNCTION_ARGS) init_var_from_num(num, &x); if (!numericvar_to_int64(&x, &result)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("bigint out of range"))); @@ -2703,7 +2714,7 @@ numeric_int2(PG_FUNCTION_ARGS) /* XXX would it be better to return NULL? */ if (NUMERIC_IS_NAN(num)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot convert NaN to smallint"))); @@ -2711,7 +2722,7 @@ numeric_int2(PG_FUNCTION_ARGS) init_var_from_num(num, &x); if (!numericvar_to_int64(&x, &val)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("smallint out of range"))); @@ -2720,7 +2731,7 @@ numeric_int2(PG_FUNCTION_ARGS) /* Test for overflow by reverse-conversion. */ if ((int64) result != val) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("smallint out of range"))); @@ -2740,7 +2751,7 @@ float8_numeric(PG_FUNCTION_ARGS) PG_RETURN_NUMERIC(make_result(&const_nan)); if (isinf(val)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot convert infinity to numeric"))); @@ -2803,7 +2814,7 @@ float4_numeric(PG_FUNCTION_ARGS) PG_RETURN_NUMERIC(make_result(&const_nan)); if (isinf(val)) - ereport(ERROR, + ereturn(fcinfo->context, 0, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot convert infinity to numeric"))); @@ -5138,6 +5149,15 @@ zero_var(NumericVar *var) */ static const char * init_var_from_str(const char *str, const char *cp, NumericVar *dest) +{ + return init_var_from_str_safe(str, cp, dest, NULL); +} + +/* + * Same as init_var_from_str() but if escontext is ErrorSaveContext then saves error in context and exits + */ +static const char * +init_var_from_str_safe(const char *str, const char *cp, NumericVar *dest, Node* escontext) { bool have_dp = FALSE; int i; @@ -5175,7 +5195,7 @@ init_var_from_str(const char *str, const char *cp, NumericVar *dest) } if (!isdigit((unsigned char) *cp)) - ereport(ERROR, + ereturn(escontext, NULL, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for type numeric: \"%s\"", str))); @@ -5201,7 +5221,7 @@ init_var_from_str(const char *str, const char *cp, NumericVar *dest) else if (*cp == '.') { if (have_dp) - ereport(ERROR, + ereturn(escontext, NULL, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for type numeric: \"%s\"", str))); @@ -5225,7 +5245,7 @@ init_var_from_str(const char *str, const char *cp, NumericVar *dest) cp++; exponent = strtol(cp, &endptr, 10); if (endptr == cp) - ereport(ERROR, + ereturn(escontext, NULL, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for type numeric: \"%s\"", str))); @@ -5240,7 +5260,7 @@ init_var_from_str(const char *str, const char *cp, NumericVar *dest) * for consistency use the same ereport errcode/text as make_result(). */ if (exponent >= INT_MAX / 2 || exponent <= -(INT_MAX / 2)) - ereport(ERROR, + ereturn(escontext, NULL, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("value overflows numeric format"))); dweight += (int) exponent; diff --git a/src/backend/utils/adt/numutils.c b/src/backend/utils/adt/numutils.c index ca5a8a576c..e5274d4cf0 100644 --- a/src/backend/utils/adt/numutils.c +++ b/src/backend/utils/adt/numutils.c @@ -35,6 +35,12 @@ */ int32 pg_atoi(char *s, int size, int c) +{ + return pg_atoi_safe(s, size, c, NULL); +} + +int32 +pg_atoi_safe(char *s, int size, int c, Node *escontext) { long l; char *badp; @@ -46,7 +52,7 @@ pg_atoi(char *s, int size, int c) if (s == NULL) elog(ERROR, "NULL pointer"); if (*s == 0) - ereport(ERROR, + ereturn(escontext, 0, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for integer: \"%s\"", s))); @@ -56,7 +62,7 @@ pg_atoi(char *s, int size, int c) /* We made no progress parsing the string, so bail out */ if (s == badp) - ereport(ERROR, + ereturn(escontext, 0, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for integer: \"%s\"", s))); @@ -70,19 +76,19 @@ pg_atoi(char *s, int size, int c) || l < INT_MIN || l > INT_MAX #endif ) - ereport(ERROR, + ereturn(escontext, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("value \"%s\" is out of range for type integer", s))); break; case sizeof(int16): if (errno == ERANGE || l < SHRT_MIN || l > SHRT_MAX) - ereport(ERROR, + ereturn(escontext, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("value \"%s\" is out of range for type smallint", s))); break; case sizeof(int8): if (errno == ERANGE || l < SCHAR_MIN || l > SCHAR_MAX) - ereport(ERROR, + ereturn(escontext, 0, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("value \"%s\" is out of range for 8-bit integer", s))); break; @@ -98,7 +104,7 @@ pg_atoi(char *s, int size, int c) badp++; if (*badp && *badp != c) - ereport(ERROR, + ereturn(escontext, 0, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for integer: \"%s\"", s))); diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h index 0bca9f7a4b..b909758689 100644 --- a/src/include/utils/builtins.h +++ b/src/include/utils/builtins.h @@ -294,6 +294,7 @@ extern Datum current_schemas(PG_FUNCTION_ARGS); /* numutils.c */ extern int32 pg_atoi(char *s, int size, int c); +extern int32 pg_atoi_safe(char *s, int size, int c, Node* context); extern void pg_itoa(int16 i, char *a); extern void pg_ltoa(int32 l, char *a); extern void pg_lltoa(int64 ll, char *a); diff --git a/src/include/utils/int8.h b/src/include/utils/int8.h index 0e4b949946..8da5f78872 100644 --- a/src/include/utils/int8.h +++ b/src/include/utils/int8.h @@ -24,6 +24,7 @@ extern bool scanint8(const char *str, bool errorOK, int64 *result); +extern bool scanint8_safe(const char *str, bool errorOK, int64 *result, Node* escontext); extern Datum int8in(PG_FUNCTION_ARGS); extern Datum int8out(PG_FUNCTION_ARGS);