1343 lines
36 KiB
Plaintext
1343 lines
36 KiB
Plaintext
--
|
|
-- ROWTYPES
|
|
--
|
|
-- Make both a standalone composite type and a table rowtype
|
|
create type complex as (r float8, i float8);
|
|
create temp table fullname (first text, last text);
|
|
-- Nested composite
|
|
create type quad as (c1 complex, c2 complex);
|
|
-- Some simple tests of I/O conversions and row construction
|
|
select (1.1,2.2)::complex, row((3.3,4.4),(5.5,null))::quad;
|
|
row | row
|
|
-----------+------------------------
|
|
(1.1,2.2) | ("(3.3,4.4)","(5.5,)")
|
|
(1 row)
|
|
|
|
select row('Joe', 'Blow')::fullname, '(Joe,Blow)'::fullname;
|
|
row | fullname
|
|
------------+------------
|
|
(Joe,Blow) | (Joe,Blow)
|
|
(1 row)
|
|
|
|
select '(Joe,von Blow)'::fullname, '(Joe,d''Blow)'::fullname;
|
|
fullname | fullname
|
|
------------------+--------------
|
|
(Joe,"von Blow") | (Joe,d'Blow)
|
|
(1 row)
|
|
|
|
select '(Joe,"von""Blow")'::fullname, E'(Joe,d\\\\Blow)'::fullname;
|
|
fullname | fullname
|
|
-------------------+-----------------
|
|
(Joe,"von""Blow") | (Joe,"d\\Blow")
|
|
(1 row)
|
|
|
|
select '(Joe,"Blow,Jr")'::fullname;
|
|
fullname
|
|
-----------------
|
|
(Joe,"Blow,Jr")
|
|
(1 row)
|
|
|
|
select '(Joe,)'::fullname; -- ok, null 2nd column
|
|
fullname
|
|
----------
|
|
(Joe,)
|
|
(1 row)
|
|
|
|
select '(Joe)'::fullname; -- bad
|
|
ERROR: malformed record literal: "(Joe)"
|
|
LINE 1: select '(Joe)'::fullname;
|
|
^
|
|
DETAIL: Too few columns.
|
|
select '(Joe,,)'::fullname; -- bad
|
|
ERROR: malformed record literal: "(Joe,,)"
|
|
LINE 1: select '(Joe,,)'::fullname;
|
|
^
|
|
DETAIL: Too many columns.
|
|
select '[]'::fullname; -- bad
|
|
ERROR: malformed record literal: "[]"
|
|
LINE 1: select '[]'::fullname;
|
|
^
|
|
DETAIL: Missing left parenthesis.
|
|
select ' (Joe,Blow) '::fullname; -- ok, extra whitespace
|
|
fullname
|
|
------------
|
|
(Joe,Blow)
|
|
(1 row)
|
|
|
|
select '(Joe,Blow) /'::fullname; -- bad
|
|
ERROR: malformed record literal: "(Joe,Blow) /"
|
|
LINE 1: select '(Joe,Blow) /'::fullname;
|
|
^
|
|
DETAIL: Junk after right parenthesis.
|
|
-- test non-error-throwing API
|
|
SELECT pg_input_is_valid('(1,2)', 'complex');
|
|
pg_input_is_valid
|
|
-------------------
|
|
t
|
|
(1 row)
|
|
|
|
SELECT pg_input_is_valid('(1,2', 'complex');
|
|
pg_input_is_valid
|
|
-------------------
|
|
f
|
|
(1 row)
|
|
|
|
SELECT pg_input_is_valid('(1,zed)', 'complex');
|
|
pg_input_is_valid
|
|
-------------------
|
|
f
|
|
(1 row)
|
|
|
|
SELECT * FROM pg_input_error_info('(1,zed)', 'complex');
|
|
message | detail | hint | sql_error_code
|
|
-------------------------------------------------------+--------+------+----------------
|
|
invalid input syntax for type double precision: "zed" | | | 22P02
|
|
(1 row)
|
|
|
|
SELECT * FROM pg_input_error_info('(1,1e400)', 'complex');
|
|
message | detail | hint | sql_error_code
|
|
---------------------------------------------------+--------+------+----------------
|
|
"1e400" is out of range for type double precision | | | 22003
|
|
(1 row)
|
|
|
|
create temp table quadtable(f1 int, q quad);
|
|
insert into quadtable values (1, ((3.3,4.4),(5.5,6.6)));
|
|
insert into quadtable values (2, ((null,4.4),(5.5,6.6)));
|
|
select * from quadtable;
|
|
f1 | q
|
|
----+---------------------------
|
|
1 | ("(3.3,4.4)","(5.5,6.6)")
|
|
2 | ("(,4.4)","(5.5,6.6)")
|
|
(2 rows)
|
|
|
|
select f1, q.c1 from quadtable; -- fails, q is a table reference
|
|
ERROR: missing FROM-clause entry for table "q"
|
|
LINE 1: select f1, q.c1 from quadtable;
|
|
^
|
|
select f1, (q).c1, (qq.q).c1.i from quadtable qq;
|
|
f1 | c1 | i
|
|
----+-----------+-----
|
|
1 | (3.3,4.4) | 4.4
|
|
2 | (,4.4) | 4.4
|
|
(2 rows)
|
|
|
|
create temp table people (fn fullname, bd date);
|
|
insert into people values ('(Joe,Blow)', '1984-01-10');
|
|
select * from people;
|
|
fn | bd
|
|
------------+------------
|
|
(Joe,Blow) | 01-10-1984
|
|
(1 row)
|
|
|
|
-- at the moment this will not work due to ALTER TABLE inadequacy:
|
|
alter table fullname add column suffix text default '';
|
|
ERROR: cannot alter table "fullname" because column "people.fn" uses its row type
|
|
-- but this should work:
|
|
alter table fullname add column suffix text default null;
|
|
select * from people;
|
|
fn | bd
|
|
-------------+------------
|
|
(Joe,Blow,) | 01-10-1984
|
|
(1 row)
|
|
|
|
-- test insertion/updating of subfields
|
|
update people set fn.suffix = 'Jr';
|
|
select * from people;
|
|
fn | bd
|
|
---------------+------------
|
|
(Joe,Blow,Jr) | 01-10-1984
|
|
(1 row)
|
|
|
|
insert into quadtable (f1, q.c1.r, q.c2.i) values(44,55,66);
|
|
update quadtable set q.c1.r = 12 where f1 = 2;
|
|
update quadtable set q.c1 = 12; -- error, type mismatch
|
|
ERROR: subfield "c1" is of type complex but expression is of type integer
|
|
LINE 1: update quadtable set q.c1 = 12;
|
|
^
|
|
HINT: You will need to rewrite or cast the expression.
|
|
select * from quadtable;
|
|
f1 | q
|
|
----+---------------------------
|
|
1 | ("(3.3,4.4)","(5.5,6.6)")
|
|
44 | ("(55,)","(,66)")
|
|
2 | ("(12,4.4)","(5.5,6.6)")
|
|
(3 rows)
|
|
|
|
-- The object here is to ensure that toasted references inside
|
|
-- composite values don't cause problems. The large f1 value will
|
|
-- be toasted inside pp, it must still work after being copied to people.
|
|
create temp table pp (f1 text);
|
|
insert into pp values (repeat('abcdefghijkl', 100000));
|
|
insert into people select ('Jim', f1, null)::fullname, current_date from pp;
|
|
select (fn).first, substr((fn).last, 1, 20), length((fn).last) from people;
|
|
first | substr | length
|
|
-------+----------------------+---------
|
|
Joe | Blow | 4
|
|
Jim | abcdefghijklabcdefgh | 1200000
|
|
(2 rows)
|
|
|
|
-- try an update on a toasted composite value, too
|
|
update people set fn.first = 'Jack';
|
|
select (fn).first, substr((fn).last, 1, 20), length((fn).last) from people;
|
|
first | substr | length
|
|
-------+----------------------+---------
|
|
Jack | Blow | 4
|
|
Jack | abcdefghijklabcdefgh | 1200000
|
|
(2 rows)
|
|
|
|
-- Test row comparison semantics. Prior to PG 8.2 we did this in a totally
|
|
-- non-spec-compliant way.
|
|
select ROW(1,2) < ROW(1,3) as true;
|
|
true
|
|
------
|
|
t
|
|
(1 row)
|
|
|
|
select ROW(1,2) < ROW(1,1) as false;
|
|
false
|
|
-------
|
|
f
|
|
(1 row)
|
|
|
|
select ROW(1,2) < ROW(1,NULL) as null;
|
|
null
|
|
------
|
|
|
|
(1 row)
|
|
|
|
select ROW(1,2,3) < ROW(1,3,NULL) as true; -- the NULL is not examined
|
|
true
|
|
------
|
|
t
|
|
(1 row)
|
|
|
|
select ROW(11,'ABC') < ROW(11,'DEF') as true;
|
|
true
|
|
------
|
|
t
|
|
(1 row)
|
|
|
|
select ROW(11,'ABC') > ROW(11,'DEF') as false;
|
|
false
|
|
-------
|
|
f
|
|
(1 row)
|
|
|
|
select ROW(12,'ABC') > ROW(11,'DEF') as true;
|
|
true
|
|
------
|
|
t
|
|
(1 row)
|
|
|
|
-- = and <> have different NULL-behavior than < etc
|
|
select ROW(1,2,3) < ROW(1,NULL,4) as null;
|
|
null
|
|
------
|
|
|
|
(1 row)
|
|
|
|
select ROW(1,2,3) = ROW(1,NULL,4) as false;
|
|
false
|
|
-------
|
|
f
|
|
(1 row)
|
|
|
|
select ROW(1,2,3) <> ROW(1,NULL,4) as true;
|
|
true
|
|
------
|
|
t
|
|
(1 row)
|
|
|
|
-- We allow operators beyond the six standard ones, if they have btree
|
|
-- operator classes.
|
|
select ROW('ABC','DEF') ~<=~ ROW('DEF','ABC') as true;
|
|
true
|
|
------
|
|
t
|
|
(1 row)
|
|
|
|
select ROW('ABC','DEF') ~>=~ ROW('DEF','ABC') as false;
|
|
false
|
|
-------
|
|
f
|
|
(1 row)
|
|
|
|
select ROW('ABC','DEF') ~~ ROW('DEF','ABC') as fail;
|
|
ERROR: could not determine interpretation of row comparison operator ~~
|
|
LINE 1: select ROW('ABC','DEF') ~~ ROW('DEF','ABC') as fail;
|
|
^
|
|
HINT: Row comparison operators must be associated with btree operator families.
|
|
-- Comparisons of ROW() expressions can cope with some type mismatches
|
|
select ROW(1,2) = ROW(1,2::int8);
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select ROW(1,2) in (ROW(3,4), ROW(1,2));
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select ROW(1,2) in (ROW(3,4), ROW(1,2::int8));
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
-- Check row comparison with a subselect
|
|
select unique1, unique2 from tenk1
|
|
where (unique1, unique2) < any (select ten, ten from tenk1 where hundred < 3)
|
|
and unique1 <= 20
|
|
order by 1;
|
|
unique1 | unique2
|
|
---------+---------
|
|
0 | 9998
|
|
1 | 2838
|
|
(2 rows)
|
|
|
|
-- Also check row comparison with an indexable condition
|
|
explain (costs off)
|
|
select thousand, tenthous from tenk1
|
|
where (thousand, tenthous) >= (997, 5000)
|
|
order by thousand, tenthous;
|
|
QUERY PLAN
|
|
-----------------------------------------------------------
|
|
Index Only Scan using tenk1_thous_tenthous on tenk1
|
|
Index Cond: (ROW(thousand, tenthous) >= ROW(997, 5000))
|
|
(2 rows)
|
|
|
|
select thousand, tenthous from tenk1
|
|
where (thousand, tenthous) >= (997, 5000)
|
|
order by thousand, tenthous;
|
|
thousand | tenthous
|
|
----------+----------
|
|
997 | 5997
|
|
997 | 6997
|
|
997 | 7997
|
|
997 | 8997
|
|
997 | 9997
|
|
998 | 998
|
|
998 | 1998
|
|
998 | 2998
|
|
998 | 3998
|
|
998 | 4998
|
|
998 | 5998
|
|
998 | 6998
|
|
998 | 7998
|
|
998 | 8998
|
|
998 | 9998
|
|
999 | 999
|
|
999 | 1999
|
|
999 | 2999
|
|
999 | 3999
|
|
999 | 4999
|
|
999 | 5999
|
|
999 | 6999
|
|
999 | 7999
|
|
999 | 8999
|
|
999 | 9999
|
|
(25 rows)
|
|
|
|
explain (costs off)
|
|
select thousand, tenthous, four from tenk1
|
|
where (thousand, tenthous, four) > (998, 5000, 3)
|
|
order by thousand, tenthous;
|
|
QUERY PLAN
|
|
-----------------------------------------------------------------------
|
|
Sort
|
|
Sort Key: thousand, tenthous
|
|
-> Bitmap Heap Scan on tenk1
|
|
Filter: (ROW(thousand, tenthous, four) > ROW(998, 5000, 3))
|
|
-> Bitmap Index Scan on tenk1_thous_tenthous
|
|
Index Cond: (ROW(thousand, tenthous) >= ROW(998, 5000))
|
|
(6 rows)
|
|
|
|
select thousand, tenthous, four from tenk1
|
|
where (thousand, tenthous, four) > (998, 5000, 3)
|
|
order by thousand, tenthous;
|
|
thousand | tenthous | four
|
|
----------+----------+------
|
|
998 | 5998 | 2
|
|
998 | 6998 | 2
|
|
998 | 7998 | 2
|
|
998 | 8998 | 2
|
|
998 | 9998 | 2
|
|
999 | 999 | 3
|
|
999 | 1999 | 3
|
|
999 | 2999 | 3
|
|
999 | 3999 | 3
|
|
999 | 4999 | 3
|
|
999 | 5999 | 3
|
|
999 | 6999 | 3
|
|
999 | 7999 | 3
|
|
999 | 8999 | 3
|
|
999 | 9999 | 3
|
|
(15 rows)
|
|
|
|
explain (costs off)
|
|
select thousand, tenthous from tenk1
|
|
where (998, 5000) < (thousand, tenthous)
|
|
order by thousand, tenthous;
|
|
QUERY PLAN
|
|
----------------------------------------------------------
|
|
Index Only Scan using tenk1_thous_tenthous on tenk1
|
|
Index Cond: (ROW(thousand, tenthous) > ROW(998, 5000))
|
|
(2 rows)
|
|
|
|
select thousand, tenthous from tenk1
|
|
where (998, 5000) < (thousand, tenthous)
|
|
order by thousand, tenthous;
|
|
thousand | tenthous
|
|
----------+----------
|
|
998 | 5998
|
|
998 | 6998
|
|
998 | 7998
|
|
998 | 8998
|
|
998 | 9998
|
|
999 | 999
|
|
999 | 1999
|
|
999 | 2999
|
|
999 | 3999
|
|
999 | 4999
|
|
999 | 5999
|
|
999 | 6999
|
|
999 | 7999
|
|
999 | 8999
|
|
999 | 9999
|
|
(15 rows)
|
|
|
|
explain (costs off)
|
|
select thousand, hundred from tenk1
|
|
where (998, 5000) < (thousand, hundred)
|
|
order by thousand, hundred;
|
|
QUERY PLAN
|
|
-----------------------------------------------------------
|
|
Sort
|
|
Sort Key: thousand, hundred
|
|
-> Bitmap Heap Scan on tenk1
|
|
Filter: (ROW(998, 5000) < ROW(thousand, hundred))
|
|
-> Bitmap Index Scan on tenk1_thous_tenthous
|
|
Index Cond: (thousand >= 998)
|
|
(6 rows)
|
|
|
|
select thousand, hundred from tenk1
|
|
where (998, 5000) < (thousand, hundred)
|
|
order by thousand, hundred;
|
|
thousand | hundred
|
|
----------+---------
|
|
999 | 99
|
|
999 | 99
|
|
999 | 99
|
|
999 | 99
|
|
999 | 99
|
|
999 | 99
|
|
999 | 99
|
|
999 | 99
|
|
999 | 99
|
|
999 | 99
|
|
(10 rows)
|
|
|
|
-- Test case for bug #14010: indexed row comparisons fail with nulls
|
|
create temp table test_table (a text, b text);
|
|
insert into test_table values ('a', 'b');
|
|
insert into test_table select 'a', null from generate_series(1,1000);
|
|
insert into test_table values ('b', 'a');
|
|
create index on test_table (a,b);
|
|
set enable_sort = off;
|
|
explain (costs off)
|
|
select a,b from test_table where (a,b) > ('a','a') order by a,b;
|
|
QUERY PLAN
|
|
--------------------------------------------------------
|
|
Index Only Scan using test_table_a_b_idx on test_table
|
|
Index Cond: (ROW(a, b) > ROW('a'::text, 'a'::text))
|
|
(2 rows)
|
|
|
|
select a,b from test_table where (a,b) > ('a','a') order by a,b;
|
|
a | b
|
|
---+---
|
|
a | b
|
|
b | a
|
|
(2 rows)
|
|
|
|
reset enable_sort;
|
|
-- Check row comparisons with IN
|
|
select * from int8_tbl i8 where i8 in (row(123,456)); -- fail, type mismatch
|
|
ERROR: cannot compare dissimilar column types bigint and integer at record column 1
|
|
explain (costs off)
|
|
select * from int8_tbl i8
|
|
where i8 in (row(123,456)::int8_tbl, '(4567890123456789,123)');
|
|
QUERY PLAN
|
|
-------------------------------------------------------------------------------
|
|
Seq Scan on int8_tbl i8
|
|
Filter: (i8.* = ANY ('{"(123,456)","(4567890123456789,123)"}'::int8_tbl[]))
|
|
(2 rows)
|
|
|
|
select * from int8_tbl i8
|
|
where i8 in (row(123,456)::int8_tbl, '(4567890123456789,123)');
|
|
q1 | q2
|
|
------------------+-----
|
|
123 | 456
|
|
4567890123456789 | 123
|
|
(2 rows)
|
|
|
|
-- Check ability to select columns from an anonymous rowtype
|
|
select (row(1, 2.0)).f1;
|
|
f1
|
|
----
|
|
1
|
|
(1 row)
|
|
|
|
select (row(1, 2.0)).f2;
|
|
f2
|
|
-----
|
|
2.0
|
|
(1 row)
|
|
|
|
select (row(1, 2.0)).nosuch; -- fail
|
|
ERROR: could not identify column "nosuch" in record data type
|
|
LINE 1: select (row(1, 2.0)).nosuch;
|
|
^
|
|
select (row(1, 2.0)).*;
|
|
f1 | f2
|
|
----+-----
|
|
1 | 2.0
|
|
(1 row)
|
|
|
|
select (r).f1 from (select row(1, 2.0) as r) ss;
|
|
f1
|
|
----
|
|
1
|
|
(1 row)
|
|
|
|
select (r).f3 from (select row(1, 2.0) as r) ss; -- fail
|
|
ERROR: could not identify column "f3" in record data type
|
|
LINE 1: select (r).f3 from (select row(1, 2.0) as r) ss;
|
|
^
|
|
select (r).* from (select row(1, 2.0) as r) ss;
|
|
f1 | f2
|
|
----+-----
|
|
1 | 2.0
|
|
(1 row)
|
|
|
|
-- Check some corner cases involving empty rowtypes
|
|
select ROW();
|
|
row
|
|
-----
|
|
()
|
|
(1 row)
|
|
|
|
select ROW() IS NULL;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select ROW() = ROW();
|
|
ERROR: cannot compare rows of zero length
|
|
LINE 1: select ROW() = ROW();
|
|
^
|
|
-- Check ability to create arrays of anonymous rowtypes
|
|
select array[ row(1,2), row(3,4), row(5,6) ];
|
|
array
|
|
---------------------------
|
|
{"(1,2)","(3,4)","(5,6)"}
|
|
(1 row)
|
|
|
|
-- Check ability to compare an anonymous row to elements of an array
|
|
select row(1,1.1) = any (array[ row(7,7.7), row(1,1.1), row(0,0.0) ]);
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1,1.1) = any (array[ row(7,7.7), row(1,1.0), row(0,0.0) ]);
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
-- Check behavior with a non-comparable rowtype
|
|
create type cantcompare as (p point, r float8);
|
|
create temp table cc (f1 cantcompare);
|
|
insert into cc values('("(1,2)",3)');
|
|
insert into cc values('("(4,5)",6)');
|
|
select * from cc order by f1; -- fail, but should complain about cantcompare
|
|
ERROR: could not identify an ordering operator for type cantcompare
|
|
LINE 1: select * from cc order by f1;
|
|
^
|
|
HINT: Use an explicit ordering operator or modify the query.
|
|
--
|
|
-- Tests for record_{eq,cmp}
|
|
--
|
|
create type testtype1 as (a int, b int);
|
|
-- all true
|
|
select row(1, 2)::testtype1 < row(1, 3)::testtype1;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, 2)::testtype1 <= row(1, 3)::testtype1;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, 2)::testtype1 = row(1, 2)::testtype1;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, 2)::testtype1 <> row(1, 3)::testtype1;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, 3)::testtype1 >= row(1, 2)::testtype1;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, 3)::testtype1 > row(1, 2)::testtype1;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
-- all false
|
|
select row(1, -2)::testtype1 < row(1, -3)::testtype1;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
select row(1, -2)::testtype1 <= row(1, -3)::testtype1;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
select row(1, -2)::testtype1 = row(1, -3)::testtype1;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
select row(1, -2)::testtype1 <> row(1, -2)::testtype1;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
select row(1, -3)::testtype1 >= row(1, -2)::testtype1;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
select row(1, -3)::testtype1 > row(1, -2)::testtype1;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
-- true, but see *< below
|
|
select row(1, -2)::testtype1 < row(1, 3)::testtype1;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
-- mismatches
|
|
create type testtype3 as (a int, b text);
|
|
select row(1, 2)::testtype1 < row(1, 'abc')::testtype3;
|
|
ERROR: cannot compare dissimilar column types integer and text at record column 2
|
|
select row(1, 2)::testtype1 <> row(1, 'abc')::testtype3;
|
|
ERROR: cannot compare dissimilar column types integer and text at record column 2
|
|
create type testtype5 as (a int);
|
|
select row(1, 2)::testtype1 < row(1)::testtype5;
|
|
ERROR: cannot compare record types with different numbers of columns
|
|
select row(1, 2)::testtype1 <> row(1)::testtype5;
|
|
ERROR: cannot compare record types with different numbers of columns
|
|
-- non-comparable types
|
|
create type testtype6 as (a int, b point);
|
|
select row(1, '(1,2)')::testtype6 < row(1, '(1,3)')::testtype6;
|
|
ERROR: could not identify a comparison function for type point
|
|
select row(1, '(1,2)')::testtype6 <> row(1, '(1,3)')::testtype6;
|
|
ERROR: could not identify an equality operator for type point
|
|
drop type testtype1, testtype3, testtype5, testtype6;
|
|
--
|
|
-- Tests for record_image_{eq,cmp}
|
|
--
|
|
create type testtype1 as (a int, b int);
|
|
-- all true
|
|
select row(1, 2)::testtype1 *< row(1, 3)::testtype1;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, 2)::testtype1 *<= row(1, 3)::testtype1;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, 2)::testtype1 *= row(1, 2)::testtype1;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, 2)::testtype1 *<> row(1, 3)::testtype1;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, 3)::testtype1 *>= row(1, 2)::testtype1;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, 3)::testtype1 *> row(1, 2)::testtype1;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
-- all false
|
|
select row(1, -2)::testtype1 *< row(1, -3)::testtype1;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
select row(1, -2)::testtype1 *<= row(1, -3)::testtype1;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
select row(1, -2)::testtype1 *= row(1, -3)::testtype1;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
select row(1, -2)::testtype1 *<> row(1, -2)::testtype1;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
select row(1, -3)::testtype1 *>= row(1, -2)::testtype1;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
select row(1, -3)::testtype1 *> row(1, -2)::testtype1;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
-- This returns the "wrong" order because record_image_cmp works on
|
|
-- unsigned datums without knowing about the actual data type.
|
|
select row(1, -2)::testtype1 *< row(1, 3)::testtype1;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
-- other types
|
|
create type testtype2 as (a smallint, b bool); -- byval different sizes
|
|
select row(1, true)::testtype2 *< row(2, true)::testtype2;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(-2, true)::testtype2 *< row(-1, true)::testtype2;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(0, false)::testtype2 *< row(0, true)::testtype2;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(0, false)::testtype2 *<> row(0, true)::testtype2;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
create type testtype3 as (a int, b text); -- variable length
|
|
select row(1, 'abc')::testtype3 *< row(1, 'abd')::testtype3;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, 'abc')::testtype3 *< row(1, 'abcd')::testtype3;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, 'abc')::testtype3 *> row(1, 'abd')::testtype3;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
select row(1, 'abc')::testtype3 *<> row(1, 'abd')::testtype3;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
create type testtype4 as (a int, b point); -- by ref, fixed length
|
|
select row(1, '(1,2)')::testtype4 *< row(1, '(1,3)')::testtype4;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, '(1,2)')::testtype4 *<> row(1, '(1,3)')::testtype4;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
-- mismatches
|
|
select row(1, 2)::testtype1 *< row(1, 'abc')::testtype3;
|
|
ERROR: cannot compare dissimilar column types integer and text at record column 2
|
|
select row(1, 2)::testtype1 *<> row(1, 'abc')::testtype3;
|
|
ERROR: cannot compare dissimilar column types integer and text at record column 2
|
|
create type testtype5 as (a int);
|
|
select row(1, 2)::testtype1 *< row(1)::testtype5;
|
|
ERROR: cannot compare record types with different numbers of columns
|
|
select row(1, 2)::testtype1 *<> row(1)::testtype5;
|
|
ERROR: cannot compare record types with different numbers of columns
|
|
-- non-comparable types
|
|
create type testtype6 as (a int, b point);
|
|
select row(1, '(1,2)')::testtype6 *< row(1, '(1,3)')::testtype6;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
select row(1, '(1,2)')::testtype6 *>= row(1, '(1,3)')::testtype6;
|
|
?column?
|
|
----------
|
|
f
|
|
(1 row)
|
|
|
|
select row(1, '(1,2)')::testtype6 *<> row(1, '(1,3)')::testtype6;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
-- anonymous rowtypes in coldeflists
|
|
select q.a, q.b = row(2), q.c = array[row(3)], q.d = row(row(4)) from
|
|
unnest(array[row(1, row(2), array[row(3)], row(row(4))),
|
|
row(2, row(3), array[row(4)], row(row(5)))])
|
|
as q(a int, b record, c record[], d record);
|
|
a | ?column? | ?column? | ?column?
|
|
---+----------+----------+----------
|
|
1 | t | t | t
|
|
2 | f | f | f
|
|
(2 rows)
|
|
|
|
drop type testtype1, testtype2, testtype3, testtype4, testtype5, testtype6;
|
|
--
|
|
-- Test case derived from bug #5716: check multiple uses of a rowtype result
|
|
--
|
|
BEGIN;
|
|
CREATE TABLE price (
|
|
id SERIAL PRIMARY KEY,
|
|
active BOOLEAN NOT NULL,
|
|
price NUMERIC
|
|
);
|
|
CREATE TYPE price_input AS (
|
|
id INTEGER,
|
|
price NUMERIC
|
|
);
|
|
CREATE TYPE price_key AS (
|
|
id INTEGER
|
|
);
|
|
CREATE FUNCTION price_key_from_table(price) RETURNS price_key AS $$
|
|
SELECT $1.id
|
|
$$ LANGUAGE SQL;
|
|
CREATE FUNCTION price_key_from_input(price_input) RETURNS price_key AS $$
|
|
SELECT $1.id
|
|
$$ LANGUAGE SQL;
|
|
insert into price values (1,false,42), (10,false,100), (11,true,17.99);
|
|
UPDATE price
|
|
SET active = true, price = input_prices.price
|
|
FROM unnest(ARRAY[(10, 123.00), (11, 99.99)]::price_input[]) input_prices
|
|
WHERE price_key_from_table(price.*) = price_key_from_input(input_prices.*);
|
|
select * from price;
|
|
id | active | price
|
|
----+--------+--------
|
|
1 | f | 42
|
|
10 | t | 123.00
|
|
11 | t | 99.99
|
|
(3 rows)
|
|
|
|
rollback;
|
|
--
|
|
-- Test case derived from bug #9085: check * qualification of composite
|
|
-- parameters for SQL functions
|
|
--
|
|
create temp table compos (f1 int, f2 text);
|
|
create function fcompos1(v compos) returns void as $$
|
|
insert into compos values (v); -- fail
|
|
$$ language sql;
|
|
ERROR: column "f1" is of type integer but expression is of type compos
|
|
LINE 2: insert into compos values (v); -- fail
|
|
^
|
|
HINT: You will need to rewrite or cast the expression.
|
|
create function fcompos1(v compos) returns void as $$
|
|
insert into compos values (v.*);
|
|
$$ language sql;
|
|
create function fcompos2(v compos) returns void as $$
|
|
select fcompos1(v);
|
|
$$ language sql;
|
|
create function fcompos3(v compos) returns void as $$
|
|
select fcompos1(fcompos3.v.*);
|
|
$$ language sql;
|
|
select fcompos1(row(1,'one'));
|
|
fcompos1
|
|
----------
|
|
|
|
(1 row)
|
|
|
|
select fcompos2(row(2,'two'));
|
|
fcompos2
|
|
----------
|
|
|
|
(1 row)
|
|
|
|
select fcompos3(row(3,'three'));
|
|
fcompos3
|
|
----------
|
|
|
|
(1 row)
|
|
|
|
select * from compos;
|
|
f1 | f2
|
|
----+-------
|
|
1 | one
|
|
2 | two
|
|
3 | three
|
|
(3 rows)
|
|
|
|
--
|
|
-- We allow I/O conversion casts from composite types to strings to be
|
|
-- invoked via cast syntax, but not functional syntax. This is because
|
|
-- the latter is too prone to be invoked unintentionally.
|
|
--
|
|
select cast (fullname as text) from fullname;
|
|
fullname
|
|
----------
|
|
(0 rows)
|
|
|
|
select fullname::text from fullname;
|
|
fullname
|
|
----------
|
|
(0 rows)
|
|
|
|
select text(fullname) from fullname; -- error
|
|
ERROR: function text(fullname) does not exist
|
|
LINE 1: select text(fullname) from fullname;
|
|
^
|
|
HINT: No function matches the given name and argument types. You might need to add explicit type casts.
|
|
select fullname.text from fullname; -- error
|
|
ERROR: column fullname.text does not exist
|
|
LINE 1: select fullname.text from fullname;
|
|
^
|
|
-- same, but RECORD instead of named composite type:
|
|
select cast (row('Jim', 'Beam') as text);
|
|
row
|
|
------------
|
|
(Jim,Beam)
|
|
(1 row)
|
|
|
|
select (row('Jim', 'Beam'))::text;
|
|
row
|
|
------------
|
|
(Jim,Beam)
|
|
(1 row)
|
|
|
|
select text(row('Jim', 'Beam')); -- error
|
|
ERROR: function text(record) does not exist
|
|
LINE 1: select text(row('Jim', 'Beam'));
|
|
^
|
|
HINT: No function matches the given name and argument types. You might need to add explicit type casts.
|
|
select (row('Jim', 'Beam')).text; -- error
|
|
ERROR: could not identify column "text" in record data type
|
|
LINE 1: select (row('Jim', 'Beam')).text;
|
|
^
|
|
--
|
|
-- Check the equivalence of functional and column notation
|
|
--
|
|
insert into fullname values ('Joe', 'Blow');
|
|
select f.last from fullname f;
|
|
last
|
|
------
|
|
Blow
|
|
(1 row)
|
|
|
|
select last(f) from fullname f;
|
|
last
|
|
------
|
|
Blow
|
|
(1 row)
|
|
|
|
create function longname(fullname) returns text language sql
|
|
as $$select $1.first || ' ' || $1.last$$;
|
|
select f.longname from fullname f;
|
|
longname
|
|
----------
|
|
Joe Blow
|
|
(1 row)
|
|
|
|
select longname(f) from fullname f;
|
|
longname
|
|
----------
|
|
Joe Blow
|
|
(1 row)
|
|
|
|
-- Starting in v11, the notational form does matter if there's ambiguity
|
|
alter table fullname add column longname text;
|
|
select f.longname from fullname f;
|
|
longname
|
|
----------
|
|
|
|
(1 row)
|
|
|
|
select longname(f) from fullname f;
|
|
longname
|
|
----------
|
|
Joe Blow
|
|
(1 row)
|
|
|
|
--
|
|
-- Test that composite values are seen to have the correct column names
|
|
-- (bug #11210 and other reports)
|
|
--
|
|
select row_to_json(i) from int8_tbl i;
|
|
row_to_json
|
|
------------------------------------------------
|
|
{"q1":123,"q2":456}
|
|
{"q1":123,"q2":4567890123456789}
|
|
{"q1":4567890123456789,"q2":123}
|
|
{"q1":4567890123456789,"q2":4567890123456789}
|
|
{"q1":4567890123456789,"q2":-4567890123456789}
|
|
(5 rows)
|
|
|
|
-- since "i" is of type "int8_tbl", attaching aliases doesn't change anything:
|
|
select row_to_json(i) from int8_tbl i(x,y);
|
|
row_to_json
|
|
------------------------------------------------
|
|
{"q1":123,"q2":456}
|
|
{"q1":123,"q2":4567890123456789}
|
|
{"q1":4567890123456789,"q2":123}
|
|
{"q1":4567890123456789,"q2":4567890123456789}
|
|
{"q1":4567890123456789,"q2":-4567890123456789}
|
|
(5 rows)
|
|
|
|
-- in these examples, we'll report the exposed column names of the subselect:
|
|
select row_to_json(ss) from
|
|
(select q1, q2 from int8_tbl) as ss;
|
|
row_to_json
|
|
------------------------------------------------
|
|
{"q1":123,"q2":456}
|
|
{"q1":123,"q2":4567890123456789}
|
|
{"q1":4567890123456789,"q2":123}
|
|
{"q1":4567890123456789,"q2":4567890123456789}
|
|
{"q1":4567890123456789,"q2":-4567890123456789}
|
|
(5 rows)
|
|
|
|
select row_to_json(ss) from
|
|
(select q1, q2 from int8_tbl offset 0) as ss;
|
|
row_to_json
|
|
------------------------------------------------
|
|
{"q1":123,"q2":456}
|
|
{"q1":123,"q2":4567890123456789}
|
|
{"q1":4567890123456789,"q2":123}
|
|
{"q1":4567890123456789,"q2":4567890123456789}
|
|
{"q1":4567890123456789,"q2":-4567890123456789}
|
|
(5 rows)
|
|
|
|
select row_to_json(ss) from
|
|
(select q1 as a, q2 as b from int8_tbl) as ss;
|
|
row_to_json
|
|
----------------------------------------------
|
|
{"a":123,"b":456}
|
|
{"a":123,"b":4567890123456789}
|
|
{"a":4567890123456789,"b":123}
|
|
{"a":4567890123456789,"b":4567890123456789}
|
|
{"a":4567890123456789,"b":-4567890123456789}
|
|
(5 rows)
|
|
|
|
select row_to_json(ss) from
|
|
(select q1 as a, q2 as b from int8_tbl offset 0) as ss;
|
|
row_to_json
|
|
----------------------------------------------
|
|
{"a":123,"b":456}
|
|
{"a":123,"b":4567890123456789}
|
|
{"a":4567890123456789,"b":123}
|
|
{"a":4567890123456789,"b":4567890123456789}
|
|
{"a":4567890123456789,"b":-4567890123456789}
|
|
(5 rows)
|
|
|
|
select row_to_json(ss) from
|
|
(select q1 as a, q2 as b from int8_tbl) as ss(x,y);
|
|
row_to_json
|
|
----------------------------------------------
|
|
{"x":123,"y":456}
|
|
{"x":123,"y":4567890123456789}
|
|
{"x":4567890123456789,"y":123}
|
|
{"x":4567890123456789,"y":4567890123456789}
|
|
{"x":4567890123456789,"y":-4567890123456789}
|
|
(5 rows)
|
|
|
|
select row_to_json(ss) from
|
|
(select q1 as a, q2 as b from int8_tbl offset 0) as ss(x,y);
|
|
row_to_json
|
|
----------------------------------------------
|
|
{"x":123,"y":456}
|
|
{"x":123,"y":4567890123456789}
|
|
{"x":4567890123456789,"y":123}
|
|
{"x":4567890123456789,"y":4567890123456789}
|
|
{"x":4567890123456789,"y":-4567890123456789}
|
|
(5 rows)
|
|
|
|
explain (costs off)
|
|
select row_to_json(q) from
|
|
(select thousand, tenthous from tenk1
|
|
where thousand = 42 and tenthous < 2000 offset 0) q;
|
|
QUERY PLAN
|
|
-------------------------------------------------------------
|
|
Subquery Scan on q
|
|
-> Index Only Scan using tenk1_thous_tenthous on tenk1
|
|
Index Cond: ((thousand = 42) AND (tenthous < 2000))
|
|
(3 rows)
|
|
|
|
select row_to_json(q) from
|
|
(select thousand, tenthous from tenk1
|
|
where thousand = 42 and tenthous < 2000 offset 0) q;
|
|
row_to_json
|
|
---------------------------------
|
|
{"thousand":42,"tenthous":42}
|
|
{"thousand":42,"tenthous":1042}
|
|
(2 rows)
|
|
|
|
select row_to_json(q) from
|
|
(select thousand as x, tenthous as y from tenk1
|
|
where thousand = 42 and tenthous < 2000 offset 0) q;
|
|
row_to_json
|
|
-------------------
|
|
{"x":42,"y":42}
|
|
{"x":42,"y":1042}
|
|
(2 rows)
|
|
|
|
select row_to_json(q) from
|
|
(select thousand as x, tenthous as y from tenk1
|
|
where thousand = 42 and tenthous < 2000 offset 0) q(a,b);
|
|
row_to_json
|
|
-------------------
|
|
{"a":42,"b":42}
|
|
{"a":42,"b":1042}
|
|
(2 rows)
|
|
|
|
create temp table tt1 as select * from int8_tbl limit 2;
|
|
create temp table tt2 () inherits(tt1);
|
|
insert into tt2 values(0,0);
|
|
select row_to_json(r) from (select q2,q1 from tt1 offset 0) r;
|
|
row_to_json
|
|
----------------------------------
|
|
{"q2":456,"q1":123}
|
|
{"q2":4567890123456789,"q1":123}
|
|
{"q2":0,"q1":0}
|
|
(3 rows)
|
|
|
|
-- check no-op rowtype conversions
|
|
create temp table tt3 () inherits(tt2);
|
|
insert into tt3 values(33,44);
|
|
select row_to_json(tt3::tt2::tt1) from tt3;
|
|
row_to_json
|
|
-------------------
|
|
{"q1":33,"q2":44}
|
|
(1 row)
|
|
|
|
--
|
|
-- IS [NOT] NULL should not recurse into nested composites (bug #14235)
|
|
--
|
|
explain (verbose, costs off)
|
|
select r, r is null as isnull, r is not null as isnotnull
|
|
from (values (1,row(1,2)), (1,row(null,null)), (1,null),
|
|
(null,row(1,2)), (null,row(null,null)), (null,null) ) r(a,b);
|
|
QUERY PLAN
|
|
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
Values Scan on "*VALUES*"
|
|
Output: ROW("*VALUES*".column1, "*VALUES*".column2), (("*VALUES*".column1 IS NULL) AND ("*VALUES*".column2 IS NOT DISTINCT FROM NULL)), (("*VALUES*".column1 IS NOT NULL) AND ("*VALUES*".column2 IS DISTINCT FROM NULL))
|
|
(2 rows)
|
|
|
|
select r, r is null as isnull, r is not null as isnotnull
|
|
from (values (1,row(1,2)), (1,row(null,null)), (1,null),
|
|
(null,row(1,2)), (null,row(null,null)), (null,null) ) r(a,b);
|
|
r | isnull | isnotnull
|
|
-------------+--------+-----------
|
|
(1,"(1,2)") | f | t
|
|
(1,"(,)") | f | t
|
|
(1,) | f | f
|
|
(,"(1,2)") | f | f
|
|
(,"(,)") | f | f
|
|
(,) | t | f
|
|
(6 rows)
|
|
|
|
explain (verbose, costs off)
|
|
with r(a,b) as materialized
|
|
(values (1,row(1,2)), (1,row(null,null)), (1,null),
|
|
(null,row(1,2)), (null,row(null,null)), (null,null) )
|
|
select r, r is null as isnull, r is not null as isnotnull from r;
|
|
QUERY PLAN
|
|
----------------------------------------------------------
|
|
CTE Scan on r
|
|
Output: r.*, (r.* IS NULL), (r.* IS NOT NULL)
|
|
CTE r
|
|
-> Values Scan on "*VALUES*"
|
|
Output: "*VALUES*".column1, "*VALUES*".column2
|
|
(5 rows)
|
|
|
|
with r(a,b) as materialized
|
|
(values (1,row(1,2)), (1,row(null,null)), (1,null),
|
|
(null,row(1,2)), (null,row(null,null)), (null,null) )
|
|
select r, r is null as isnull, r is not null as isnotnull from r;
|
|
r | isnull | isnotnull
|
|
-------------+--------+-----------
|
|
(1,"(1,2)") | f | t
|
|
(1,"(,)") | f | t
|
|
(1,) | f | f
|
|
(,"(1,2)") | f | f
|
|
(,"(,)") | f | f
|
|
(,) | t | f
|
|
(6 rows)
|
|
|
|
--
|
|
-- Check parsing of indirect references to composite values (bug #18077)
|
|
--
|
|
explain (verbose, costs off)
|
|
with cte(c) as materialized (select row(1, 2)),
|
|
cte2(c) as (select * from cte)
|
|
select * from cte2 as t
|
|
where (select * from (select c as c1) s
|
|
where (select (c1).f1 > 0)) is not null;
|
|
QUERY PLAN
|
|
--------------------------------------------
|
|
CTE Scan on cte
|
|
Output: cte.c
|
|
Filter: ((SubPlan 3) IS NOT NULL)
|
|
CTE cte
|
|
-> Result
|
|
Output: '(1,2)'::record
|
|
SubPlan 3
|
|
-> Result
|
|
Output: cte.c
|
|
One-Time Filter: $2
|
|
InitPlan 2 (returns $2)
|
|
-> Result
|
|
Output: ((cte.c).f1 > 0)
|
|
(13 rows)
|
|
|
|
with cte(c) as materialized (select row(1, 2)),
|
|
cte2(c) as (select * from cte)
|
|
select * from cte2 as t
|
|
where (select * from (select c as c1) s
|
|
where (select (c1).f1 > 0)) is not null;
|
|
c
|
|
-------
|
|
(1,2)
|
|
(1 row)
|
|
|
|
-- Also check deparsing of such cases
|
|
create view composite_v as
|
|
with cte(c) as materialized (select row(1, 2)),
|
|
cte2(c) as (select * from cte)
|
|
select 1 as one from cte2 as t
|
|
where (select * from (select c as c1) s
|
|
where (select (c1).f1 > 0)) is not null;
|
|
select pg_get_viewdef('composite_v', true);
|
|
pg_get_viewdef
|
|
--------------------------------------------------------
|
|
WITH cte(c) AS MATERIALIZED ( +
|
|
SELECT ROW(1, 2) AS "row" +
|
|
), cte2(c) AS ( +
|
|
SELECT cte.c +
|
|
FROM cte +
|
|
) +
|
|
SELECT 1 AS one +
|
|
FROM cte2 t +
|
|
WHERE (( SELECT s.c1 +
|
|
FROM ( SELECT t.c AS c1) s +
|
|
WHERE ( SELECT (s.c1).f1 > 0))) IS NOT NULL;
|
|
(1 row)
|
|
|
|
drop view composite_v;
|
|
--
|
|
-- Tests for component access / FieldSelect
|
|
--
|
|
CREATE TABLE compositetable(a text, b text);
|
|
INSERT INTO compositetable(a, b) VALUES('fa', 'fb');
|
|
-- composite type columns can't directly be accessed (error)
|
|
SELECT d.a FROM (SELECT compositetable AS d FROM compositetable) s;
|
|
ERROR: missing FROM-clause entry for table "d"
|
|
LINE 1: SELECT d.a FROM (SELECT compositetable AS d FROM compositeta...
|
|
^
|
|
-- but can be accessed with proper parens
|
|
SELECT (d).a, (d).b FROM (SELECT compositetable AS d FROM compositetable) s;
|
|
a | b
|
|
----+----
|
|
fa | fb
|
|
(1 row)
|
|
|
|
-- system columns can't be accessed in composite types (error)
|
|
SELECT (d).ctid FROM (SELECT compositetable AS d FROM compositetable) s;
|
|
ERROR: column "ctid" not found in data type compositetable
|
|
LINE 1: SELECT (d).ctid FROM (SELECT compositetable AS d FROM compos...
|
|
^
|
|
-- accessing non-existing column in NULL datum errors out
|
|
SELECT (NULL::compositetable).nonexistent;
|
|
ERROR: column "nonexistent" not found in data type compositetable
|
|
LINE 1: SELECT (NULL::compositetable).nonexistent;
|
|
^
|
|
-- existing column in a NULL composite yield NULL
|
|
SELECT (NULL::compositetable).a;
|
|
a
|
|
---
|
|
|
|
(1 row)
|
|
|
|
-- oids can't be accessed in composite types (error)
|
|
SELECT (NULL::compositetable).oid;
|
|
ERROR: column "oid" not found in data type compositetable
|
|
LINE 1: SELECT (NULL::compositetable).oid;
|
|
^
|
|
DROP TABLE compositetable;
|