2006-04-06 00:11:58 +02:00
|
|
|
--
|
|
|
|
-- Test domains.
|
|
|
|
--
|
2002-03-19 03:18:25 +01:00
|
|
|
|
|
|
|
-- Test Comment / Drop
|
|
|
|
create domain domaindroptest int4;
|
|
|
|
comment on domain domaindroptest is 'About to drop this..';
|
|
|
|
|
2006-04-06 00:11:58 +02:00
|
|
|
create domain dependenttypetest domaindroptest;
|
2002-03-19 03:18:25 +01:00
|
|
|
|
2006-04-06 00:11:58 +02:00
|
|
|
-- fail because of dependent type
|
2002-03-19 03:18:25 +01:00
|
|
|
drop domain domaindroptest;
|
|
|
|
|
2006-04-06 00:11:58 +02:00
|
|
|
drop domain domaindroptest cascade;
|
|
|
|
|
2002-07-12 20:43:19 +02:00
|
|
|
-- this should fail because already gone
|
|
|
|
drop domain domaindroptest cascade;
|
|
|
|
|
2002-03-19 03:18:25 +01:00
|
|
|
|
2007-03-19 17:30:32 +01:00
|
|
|
-- Test domain input.
|
|
|
|
|
|
|
|
-- Note: the point of checking both INSERT and COPY FROM is that INSERT
|
|
|
|
-- exercises CoerceToDomain while COPY exercises domain_in.
|
2002-03-19 03:18:25 +01:00
|
|
|
|
|
|
|
create domain domainvarchar varchar(5);
|
|
|
|
create domain domainnumeric numeric(8,2);
|
|
|
|
create domain domainint4 int4;
|
|
|
|
create domain domaintext text;
|
|
|
|
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
-- Test explicit coercions --- these should succeed (and truncate)
|
|
|
|
SELECT cast('123456' as domainvarchar);
|
|
|
|
SELECT cast('12345' as domainvarchar);
|
2002-03-19 03:18:25 +01:00
|
|
|
|
|
|
|
-- Test tables using domains
|
|
|
|
create table basictest
|
|
|
|
( testint4 domainint4
|
|
|
|
, testtext domaintext
|
|
|
|
, testvarchar domainvarchar
|
|
|
|
, testnumeric domainnumeric
|
|
|
|
);
|
|
|
|
|
|
|
|
INSERT INTO basictest values ('88', 'haha', 'short', '123.12'); -- Good
|
|
|
|
INSERT INTO basictest values ('88', 'haha', 'short text', '123.12'); -- Bad varchar
|
|
|
|
INSERT INTO basictest values ('88', 'haha', 'short', '123.1212'); -- Truncate numeric
|
2002-09-20 05:52:50 +02:00
|
|
|
|
|
|
|
-- Test copy
|
|
|
|
COPY basictest (testvarchar) FROM stdin; -- fail
|
|
|
|
notsoshorttext
|
|
|
|
\.
|
|
|
|
|
|
|
|
COPY basictest (testvarchar) FROM stdin;
|
|
|
|
short
|
|
|
|
\.
|
|
|
|
|
2002-03-19 03:18:25 +01:00
|
|
|
select * from basictest;
|
|
|
|
|
2002-03-20 20:45:13 +01:00
|
|
|
-- check that domains inherit operations from base types
|
2002-09-01 00:10:48 +02:00
|
|
|
select testtext || testvarchar as concat, testnumeric + 42 as sum
|
2002-03-20 20:45:13 +01:00
|
|
|
from basictest;
|
|
|
|
|
Fix select_common_type() so that it can select a domain type, if all inputs
to a UNION, CASE, or related construct are of the same domain type. The
main part of this routine smashes domains to their base types, which seems
necessary because the logic involves TypeCategory() and IsPreferredType(),
neither of which work usefully on domains. However, we can add a first
pass that just detects whether all the inputs are exactly the same type,
and if so accept that without question (so long as it's not UNKNOWN).
Per recent gripe from Dean Rasheed.
In passing, remove some tests for InvalidOid, which have clearly been dead
code for quite some time now, because getBaseType() would fail on that input.
Also, clarify the manual's not-very-precise description of the existing
algorithm's behavior.
2007-11-26 17:46:51 +01:00
|
|
|
-- check that union/case/coalesce type resolution handles domains properly
|
Remove undocumented IS [NOT] OF syntax.
This feature was added a long time ago, in 7c1e67bd5 and eb121ba2c,
but never documented in any user-facing way. (Documentation added
in 6126d3e70 was commented out almost immediately, in 8272fc3f7.)
That's because, while this syntax is defined by SQL:99, our
implementation is only vaguely related to the standard's semantics.
The standard appears to intend a run-time not parse-time test, and
it definitely intends that the test should understand subtype
relationships.
No one has stepped up to fix that in the intervening years, but
people keep coming across the code and asking why it's not documented.
Let's just get rid of it: if anyone ever wants to make it work per
spec, they can easily recover whatever parts of this code are still
of value from our git history.
If there's anyone out there who's actually using this despite its
undocumented status, they can switch to using pg_typeof() instead,
eg. "pg_typeof(something) = 'mytype'::regtype". That gives
essentially the same semantics as what our IS OF code did.
(We didn't have that function last time this was discussed, or
we would have ripped out IS OF then.)
Discussion: https://postgr.es/m/CAKFQuwZ2pTc-DSkOiTfjauqLYkNREeNZvWmeg12Q-_69D+sYZA@mail.gmail.com
Discussion: https://postgr.es/m/BAY20-F23E9F2B4DAB3E4E88D3623F99B0@phx.gbl
Discussion: https://postgr.es/m/3E7CF81D.1000203@joeconway.com
2020-11-19 23:39:39 +01:00
|
|
|
select pg_typeof(coalesce(4::domainint4, 7));
|
|
|
|
select pg_typeof(coalesce(4::domainint4, 7::domainint4));
|
Fix select_common_type() so that it can select a domain type, if all inputs
to a UNION, CASE, or related construct are of the same domain type. The
main part of this routine smashes domains to their base types, which seems
necessary because the logic involves TypeCategory() and IsPreferredType(),
neither of which work usefully on domains. However, we can add a first
pass that just detects whether all the inputs are exactly the same type,
and if so accept that without question (so long as it's not UNKNOWN).
Per recent gripe from Dean Rasheed.
In passing, remove some tests for InvalidOid, which have clearly been dead
code for quite some time now, because getBaseType() would fail on that input.
Also, clarify the manual's not-very-precise description of the existing
algorithm's behavior.
2007-11-26 17:46:51 +01:00
|
|
|
|
2002-03-19 03:18:25 +01:00
|
|
|
drop table basictest;
|
|
|
|
drop domain domainvarchar restrict;
|
|
|
|
drop domain domainnumeric restrict;
|
|
|
|
drop domain domainint4 restrict;
|
2002-03-20 20:45:13 +01:00
|
|
|
drop domain domaintext;
|
2002-03-19 03:18:25 +01:00
|
|
|
|
|
|
|
|
2022-12-11 18:56:54 +01:00
|
|
|
-- Test non-error-throwing input
|
|
|
|
|
|
|
|
create domain positiveint int4 check(value > 0);
|
|
|
|
create domain weirdfloat float8 check((1 / value) < 10);
|
|
|
|
|
|
|
|
select pg_input_is_valid('1', 'positiveint');
|
|
|
|
select pg_input_is_valid('junk', 'positiveint');
|
|
|
|
select pg_input_is_valid('-1', 'positiveint');
|
2023-02-28 00:04:13 +01:00
|
|
|
select * from pg_input_error_info('junk', 'positiveint');
|
|
|
|
select * from pg_input_error_info('-1', 'positiveint');
|
|
|
|
select * from pg_input_error_info('junk', 'weirdfloat');
|
|
|
|
select * from pg_input_error_info('0.01', 'weirdfloat');
|
2022-12-11 18:56:54 +01:00
|
|
|
-- We currently can't trap errors raised in the CHECK expression itself
|
2023-02-28 00:04:13 +01:00
|
|
|
select * from pg_input_error_info('0', 'weirdfloat');
|
2022-12-11 18:56:54 +01:00
|
|
|
|
|
|
|
drop domain positiveint;
|
|
|
|
drop domain weirdfloat;
|
|
|
|
|
|
|
|
|
2007-03-19 17:30:32 +01:00
|
|
|
-- Test domains over array types
|
|
|
|
|
2002-03-19 03:18:25 +01:00
|
|
|
create domain domainint4arr int4[1];
|
2007-03-19 17:30:32 +01:00
|
|
|
create domain domainchar4arr varchar(4)[2][3];
|
2002-03-19 03:18:25 +01:00
|
|
|
|
|
|
|
create table domarrtest
|
|
|
|
( testint4arr domainint4arr
|
2007-03-19 17:30:32 +01:00
|
|
|
, testchar4arr domainchar4arr
|
2002-03-19 03:18:25 +01:00
|
|
|
);
|
2004-08-05 05:30:44 +02:00
|
|
|
INSERT INTO domarrtest values ('{2,2}', '{{"a","b"},{"c","d"}}');
|
|
|
|
INSERT INTO domarrtest values ('{{2,2},{2,2}}', '{{"a","b"}}');
|
|
|
|
INSERT INTO domarrtest values ('{2,2}', '{{"a","b"},{"c","d"},{"e","f"}}');
|
|
|
|
INSERT INTO domarrtest values ('{2,2}', '{{"a"},{"c"}}');
|
|
|
|
INSERT INTO domarrtest values (NULL, '{{"a","b","c"},{"d","e","f"}}');
|
2007-03-19 17:30:32 +01:00
|
|
|
INSERT INTO domarrtest values (NULL, '{{"toolong","b","c"},{"d","e","f"}}');
|
2017-07-11 22:48:59 +02:00
|
|
|
INSERT INTO domarrtest (testint4arr[1], testint4arr[3]) values (11,22);
|
2007-03-19 17:30:32 +01:00
|
|
|
select * from domarrtest;
|
|
|
|
select testint4arr[1], testchar4arr[2:2] from domarrtest;
|
2011-06-08 18:52:12 +02:00
|
|
|
select array_dims(testint4arr), array_dims(testchar4arr) from domarrtest;
|
2007-03-19 17:30:32 +01:00
|
|
|
|
|
|
|
COPY domarrtest FROM stdin;
|
|
|
|
{3,4} {q,w,e}
|
|
|
|
\N \N
|
|
|
|
\.
|
|
|
|
|
|
|
|
COPY domarrtest FROM stdin; -- fail
|
|
|
|
{3,4} {qwerty,w,e}
|
|
|
|
\.
|
|
|
|
|
2002-03-20 20:45:13 +01:00
|
|
|
select * from domarrtest;
|
2002-03-19 03:18:25 +01:00
|
|
|
|
2017-07-11 22:48:59 +02:00
|
|
|
update domarrtest set
|
|
|
|
testint4arr[1] = testint4arr[1] + 1,
|
|
|
|
testint4arr[3] = testint4arr[3] - 1
|
|
|
|
where testchar4arr is null;
|
|
|
|
|
|
|
|
select * from domarrtest where testchar4arr is null;
|
|
|
|
|
2002-03-19 03:18:25 +01:00
|
|
|
drop table domarrtest;
|
|
|
|
drop domain domainint4arr restrict;
|
2007-03-19 17:30:32 +01:00
|
|
|
drop domain domainchar4arr restrict;
|
2002-03-19 03:18:25 +01:00
|
|
|
|
2011-06-08 18:52:12 +02:00
|
|
|
create domain dia as int[];
|
|
|
|
select '{1,2,3}'::dia;
|
|
|
|
select array_dims('{1,2,3}'::dia);
|
|
|
|
select pg_typeof('{1,2,3}'::dia);
|
|
|
|
select pg_typeof('{1,2,3}'::dia || 42); -- should be int[] not dia
|
|
|
|
drop domain dia;
|
2002-03-19 03:18:25 +01:00
|
|
|
|
2017-07-11 22:48:59 +02:00
|
|
|
|
2017-10-26 19:47:45 +02:00
|
|
|
-- Test domains over composites
|
|
|
|
|
|
|
|
create type comptype as (r float8, i float8);
|
|
|
|
create domain dcomptype as comptype;
|
|
|
|
create table dcomptable (d1 dcomptype unique);
|
|
|
|
|
|
|
|
insert into dcomptable values (row(1,2)::dcomptype);
|
|
|
|
insert into dcomptable values (row(3,4)::comptype);
|
|
|
|
insert into dcomptable values (row(1,2)::dcomptype); -- fail on uniqueness
|
|
|
|
insert into dcomptable (d1.r) values(11);
|
|
|
|
|
|
|
|
select * from dcomptable;
|
|
|
|
select (d1).r, (d1).i, (d1).* from dcomptable;
|
|
|
|
update dcomptable set d1.r = (d1).r + 1 where (d1).i > 0;
|
|
|
|
select * from dcomptable;
|
|
|
|
|
|
|
|
alter domain dcomptype add constraint c1 check ((value).r <= (value).i);
|
|
|
|
alter domain dcomptype add constraint c2 check ((value).r > (value).i); -- fail
|
|
|
|
|
|
|
|
select row(2,1)::dcomptype; -- fail
|
|
|
|
insert into dcomptable values (row(1,2)::comptype);
|
|
|
|
insert into dcomptable values (row(2,1)::comptype); -- fail
|
|
|
|
insert into dcomptable (d1.r) values(99);
|
|
|
|
insert into dcomptable (d1.r, d1.i) values(99, 100);
|
|
|
|
insert into dcomptable (d1.r, d1.i) values(100, 99); -- fail
|
|
|
|
update dcomptable set d1.r = (d1).r + 1 where (d1).i > 0; -- fail
|
|
|
|
update dcomptable set d1.r = (d1).r - 1, d1.i = (d1).i + 1 where (d1).i > 0;
|
|
|
|
select * from dcomptable;
|
|
|
|
|
|
|
|
explain (verbose, costs off)
|
|
|
|
update dcomptable set d1.r = (d1).r - 1, d1.i = (d1).i + 1 where (d1).i > 0;
|
|
|
|
create rule silly as on delete to dcomptable do instead
|
|
|
|
update dcomptable set d1.r = (d1).r - 1, d1.i = (d1).i + 1 where (d1).i > 0;
|
|
|
|
\d+ dcomptable
|
|
|
|
|
2022-06-10 16:35:57 +02:00
|
|
|
create function makedcomp(r float8, i float8) returns dcomptype
|
|
|
|
as 'select row(r, i)' language sql;
|
|
|
|
|
|
|
|
select makedcomp(1,2);
|
|
|
|
select makedcomp(2,1); -- fail
|
|
|
|
select * from makedcomp(1,2) m;
|
|
|
|
select m, m is not null from makedcomp(1,2) m;
|
|
|
|
|
|
|
|
drop function makedcomp(float8, float8);
|
2017-10-26 19:47:45 +02:00
|
|
|
drop table dcomptable;
|
|
|
|
drop type comptype cascade;
|
|
|
|
|
|
|
|
|
2017-11-01 18:32:23 +01:00
|
|
|
-- check altering and dropping columns used by domain constraints
|
|
|
|
create type comptype as (r float8, i float8);
|
|
|
|
create domain dcomptype as comptype;
|
|
|
|
alter domain dcomptype add constraint c1 check ((value).r > 0);
|
|
|
|
comment on constraint c1 on domain dcomptype is 'random commentary';
|
|
|
|
|
|
|
|
select row(0,1)::dcomptype; -- fail
|
|
|
|
|
|
|
|
alter type comptype alter attribute r type varchar; -- fail
|
|
|
|
alter type comptype alter attribute r type bigint;
|
|
|
|
|
|
|
|
alter type comptype drop attribute r; -- fail
|
|
|
|
alter type comptype drop attribute i;
|
|
|
|
|
|
|
|
select conname, obj_description(oid, 'pg_constraint') from pg_constraint
|
|
|
|
where contypid = 'dcomptype'::regtype; -- check comment is still there
|
|
|
|
|
|
|
|
drop type comptype cascade;
|
|
|
|
|
|
|
|
|
2017-07-11 22:48:59 +02:00
|
|
|
-- Test domains over arrays of composite
|
|
|
|
|
|
|
|
create type comptype as (r float8, i float8);
|
|
|
|
create domain dcomptypea as comptype[];
|
|
|
|
create table dcomptable (d1 dcomptypea unique);
|
|
|
|
|
|
|
|
insert into dcomptable values (array[row(1,2)]::dcomptypea);
|
|
|
|
insert into dcomptable values (array[row(3,4), row(5,6)]::comptype[]);
|
|
|
|
insert into dcomptable values (array[row(7,8)::comptype, row(9,10)::comptype]);
|
|
|
|
insert into dcomptable values (array[row(1,2)]::dcomptypea); -- fail on uniqueness
|
|
|
|
insert into dcomptable (d1[1]) values(row(9,10));
|
|
|
|
insert into dcomptable (d1[1].r) values(11);
|
|
|
|
|
|
|
|
select * from dcomptable;
|
|
|
|
select d1[2], d1[1].r, d1[1].i from dcomptable;
|
|
|
|
update dcomptable set d1[2] = row(d1[2].i, d1[2].r);
|
|
|
|
select * from dcomptable;
|
|
|
|
update dcomptable set d1[1].r = d1[1].r + 1 where d1[1].i > 0;
|
|
|
|
select * from dcomptable;
|
|
|
|
|
|
|
|
alter domain dcomptypea add constraint c1 check (value[1].r <= value[1].i);
|
|
|
|
alter domain dcomptypea add constraint c2 check (value[1].r > value[1].i); -- fail
|
|
|
|
|
|
|
|
select array[row(2,1)]::dcomptypea; -- fail
|
|
|
|
insert into dcomptable values (array[row(1,2)]::comptype[]);
|
|
|
|
insert into dcomptable values (array[row(2,1)]::comptype[]); -- fail
|
|
|
|
insert into dcomptable (d1[1].r) values(99);
|
|
|
|
insert into dcomptable (d1[1].r, d1[1].i) values(99, 100);
|
|
|
|
insert into dcomptable (d1[1].r, d1[1].i) values(100, 99); -- fail
|
|
|
|
update dcomptable set d1[1].r = d1[1].r + 1 where d1[1].i > 0; -- fail
|
2017-07-13 00:00:04 +02:00
|
|
|
update dcomptable set d1[1].r = d1[1].r - 1, d1[1].i = d1[1].i + 1
|
|
|
|
where d1[1].i > 0;
|
2017-07-11 22:48:59 +02:00
|
|
|
select * from dcomptable;
|
|
|
|
|
2017-07-13 00:00:04 +02:00
|
|
|
explain (verbose, costs off)
|
|
|
|
update dcomptable set d1[1].r = d1[1].r - 1, d1[1].i = d1[1].i + 1
|
|
|
|
where d1[1].i > 0;
|
|
|
|
create rule silly as on delete to dcomptable do instead
|
|
|
|
update dcomptable set d1[1].r = d1[1].r - 1, d1[1].i = d1[1].i + 1
|
|
|
|
where d1[1].i > 0;
|
|
|
|
\d+ dcomptable
|
|
|
|
|
2017-07-11 22:48:59 +02:00
|
|
|
drop table dcomptable;
|
|
|
|
drop type comptype cascade;
|
|
|
|
|
|
|
|
|
Support arrays over domains.
Allowing arrays with a domain type as their element type was left un-done
in the original domain patch, but not for any very good reason. This
omission leads to such surprising results as array_agg() not working on
a domain column, because the parser can't identify a suitable output type
for the polymorphic aggregate.
In order to fix this, first clean up the APIs of coerce_to_domain() and
some internal functions in parse_coerce.c so that we consistently pass
around a CoercionContext along with CoercionForm. Previously, we sometimes
passed an "isExplicit" boolean flag instead, which is strictly less
information; and coerce_to_domain() didn't even get that, but instead had
to reverse-engineer isExplicit from CoercionForm. That's contrary to the
documentation in primnodes.h that says that CoercionForm only affects
display and not semantics. I don't think this change fixes any live bugs,
but it makes things more consistent. The main reason for doing it though
is that now build_coercion_expression() receives ccontext, which it needs
in order to be able to recursively invoke coerce_to_target_type().
Next, reimplement ArrayCoerceExpr so that the node does not directly know
any details of what has to be done to the individual array elements while
performing the array coercion. Instead, the per-element processing is
represented by a sub-expression whose input is a source array element and
whose output is a target array element. This simplifies life in
parse_coerce.c, because it can build that sub-expression by a recursive
invocation of coerce_to_target_type(). The executor now handles the
per-element processing as a compiled expression instead of hard-wired code.
The main advantage of this is that we can use a single ArrayCoerceExpr to
handle as many as three successive steps per element: base type conversion,
typmod coercion, and domain constraint checking. The old code used two
stacked ArrayCoerceExprs to handle type + typmod coercion, which was pretty
inefficient, and adding yet another array deconstruction to do domain
constraint checking seemed very unappetizing.
In the case where we just need a single, very simple coercion function,
doing this straightforwardly leads to a noticeable increase in the
per-array-element runtime cost. Hence, add an additional shortcut evalfunc
in execExprInterp.c that skips unnecessary overhead for that specific form
of expression. The runtime speed of simple cases is within 1% or so of
where it was before, while cases that previously required two levels of
array processing are significantly faster.
Finally, create an implicit array type for every domain type, as we do for
base types, enums, etc. Everything except the array-coercion case seems
to just work without further effort.
Tom Lane, reviewed by Andrew Dunstan
Discussion: https://postgr.es/m/9852.1499791473@sss.pgh.pa.us
2017-09-30 19:40:56 +02:00
|
|
|
-- Test arrays over domains
|
|
|
|
|
|
|
|
create domain posint as int check (value > 0);
|
|
|
|
|
|
|
|
create table pitable (f1 posint[]);
|
|
|
|
insert into pitable values(array[42]);
|
|
|
|
insert into pitable values(array[-1]); -- fail
|
|
|
|
insert into pitable values('{0}'); -- fail
|
|
|
|
update pitable set f1[1] = f1[1] + 1;
|
|
|
|
update pitable set f1[1] = 0; -- fail
|
|
|
|
select * from pitable;
|
|
|
|
drop table pitable;
|
|
|
|
|
|
|
|
create domain vc4 as varchar(4);
|
|
|
|
create table vc4table (f1 vc4[]);
|
|
|
|
insert into vc4table values(array['too long']); -- fail
|
|
|
|
insert into vc4table values(array['too long']::vc4[]); -- cast truncates
|
|
|
|
select * from vc4table;
|
|
|
|
drop table vc4table;
|
|
|
|
drop type vc4;
|
|
|
|
|
|
|
|
-- You can sort of fake arrays-of-arrays by putting a domain in between
|
|
|
|
create domain dposinta as posint[];
|
|
|
|
create table dposintatable (f1 dposinta[]);
|
|
|
|
insert into dposintatable values(array[array[42]]); -- fail
|
|
|
|
insert into dposintatable values(array[array[42]::posint[]]); -- still fail
|
|
|
|
insert into dposintatable values(array[array[42]::dposinta]); -- but this works
|
|
|
|
select f1, f1[1], (f1[1])[1] from dposintatable;
|
|
|
|
select pg_typeof(f1) from dposintatable;
|
|
|
|
select pg_typeof(f1[1]) from dposintatable;
|
|
|
|
select pg_typeof(f1[1][1]) from dposintatable;
|
|
|
|
select pg_typeof((f1[1])[1]) from dposintatable;
|
|
|
|
update dposintatable set f1[2] = array[99];
|
|
|
|
select f1, f1[1], (f1[2])[1] from dposintatable;
|
|
|
|
-- it'd be nice if you could do something like this, but for now you can't:
|
|
|
|
update dposintatable set f1[2][1] = array[97];
|
|
|
|
-- maybe someday we can make this syntax work:
|
|
|
|
update dposintatable set (f1[2])[1] = array[98];
|
|
|
|
|
|
|
|
drop table dposintatable;
|
|
|
|
drop domain posint cascade;
|
|
|
|
|
|
|
|
|
2021-10-19 19:54:45 +02:00
|
|
|
-- Test arrays over domains of composite
|
|
|
|
|
|
|
|
create type comptype as (cf1 int, cf2 int);
|
|
|
|
create domain dcomptype as comptype check ((value).cf1 > 0);
|
|
|
|
|
|
|
|
create table dcomptable (f1 dcomptype[]);
|
|
|
|
insert into dcomptable values (null);
|
|
|
|
update dcomptable set f1[1].cf2 = 5;
|
|
|
|
table dcomptable;
|
|
|
|
update dcomptable set f1[1].cf1 = -1; -- fail
|
|
|
|
update dcomptable set f1[1].cf1 = 1;
|
|
|
|
table dcomptable;
|
2023-04-15 18:01:39 +02:00
|
|
|
-- if there's no constraints, a different code path is taken:
|
|
|
|
alter domain dcomptype drop constraint dcomptype_check;
|
|
|
|
update dcomptable set f1[1].cf1 = -1; -- now ok
|
|
|
|
table dcomptable;
|
2021-10-19 19:54:45 +02:00
|
|
|
|
|
|
|
drop table dcomptable;
|
|
|
|
drop type comptype cascade;
|
|
|
|
|
|
|
|
|
2017-07-11 22:48:59 +02:00
|
|
|
-- Test not-null restrictions
|
|
|
|
|
2002-03-19 03:18:25 +01:00
|
|
|
create domain dnotnull varchar(15) NOT NULL;
|
2002-07-06 22:16:36 +02:00
|
|
|
create domain dnull varchar(15);
|
2002-11-15 03:50:21 +01:00
|
|
|
create domain dcheck varchar(15) NOT NULL CHECK (VALUE = 'a' OR VALUE = 'c' OR VALUE = 'd');
|
2002-03-19 03:18:25 +01:00
|
|
|
|
|
|
|
create table nulltest
|
|
|
|
( col1 dnotnull
|
|
|
|
, col2 dnotnull NULL -- NOT NULL in the domain cannot be overridden
|
|
|
|
, col3 dnull NOT NULL
|
|
|
|
, col4 dnull
|
2002-11-15 03:50:21 +01:00
|
|
|
, col5 dcheck CHECK (col5 IN ('c', 'd'))
|
2002-03-19 03:18:25 +01:00
|
|
|
);
|
|
|
|
INSERT INTO nulltest DEFAULT VALUES;
|
2002-11-15 03:50:21 +01:00
|
|
|
INSERT INTO nulltest values ('a', 'b', 'c', 'd', 'c'); -- Good
|
|
|
|
insert into nulltest values ('a', 'b', 'c', 'd', NULL);
|
|
|
|
insert into nulltest values ('a', 'b', 'c', 'd', 'a');
|
|
|
|
INSERT INTO nulltest values (NULL, 'b', 'c', 'd', 'd');
|
|
|
|
INSERT INTO nulltest values ('a', NULL, 'c', 'd', 'c');
|
|
|
|
INSERT INTO nulltest values ('a', 'b', NULL, 'd', 'c');
|
|
|
|
INSERT INTO nulltest values ('a', 'b', 'c', NULL, 'd'); -- Good
|
2002-09-20 05:52:50 +02:00
|
|
|
|
|
|
|
-- Test copy
|
|
|
|
COPY nulltest FROM stdin; --fail
|
2006-04-06 00:11:58 +02:00
|
|
|
a b \N d d
|
|
|
|
\.
|
|
|
|
|
|
|
|
COPY nulltest FROM stdin; --fail
|
|
|
|
a b c d \N
|
2002-09-20 05:52:50 +02:00
|
|
|
\.
|
|
|
|
|
2002-11-15 03:50:21 +01:00
|
|
|
-- Last row is bad
|
2002-09-20 05:52:50 +02:00
|
|
|
COPY nulltest FROM stdin;
|
2002-11-15 03:50:21 +01:00
|
|
|
a b c \N c
|
|
|
|
a b c \N d
|
|
|
|
a b c \N a
|
2002-09-20 05:52:50 +02:00
|
|
|
\.
|
|
|
|
|
2002-03-19 03:18:25 +01:00
|
|
|
select * from nulltest;
|
|
|
|
|
2002-07-06 22:16:36 +02:00
|
|
|
-- Test out coerced (casted) constraints
|
|
|
|
SELECT cast('1' as dnotnull);
|
|
|
|
SELECT cast(NULL as dnotnull); -- fail
|
|
|
|
SELECT cast(cast(NULL as dnull) as dnotnull); -- fail
|
|
|
|
SELECT cast(col4 as dnotnull) from nulltest; -- fail
|
|
|
|
|
|
|
|
-- cleanup
|
2002-03-19 03:18:25 +01:00
|
|
|
drop table nulltest;
|
|
|
|
drop domain dnotnull restrict;
|
|
|
|
drop domain dnull restrict;
|
2002-12-06 06:00:34 +01:00
|
|
|
drop domain dcheck restrict;
|
2002-03-19 03:18:25 +01:00
|
|
|
|
|
|
|
|
|
|
|
create domain ddef1 int4 DEFAULT 3;
|
|
|
|
create domain ddef2 oid DEFAULT '12';
|
|
|
|
-- Type mixing, function returns int8
|
|
|
|
create domain ddef3 text DEFAULT 5;
|
|
|
|
create sequence ddef4_seq;
|
2005-10-03 01:50:16 +02:00
|
|
|
create domain ddef4 int4 DEFAULT nextval('ddef4_seq');
|
2002-03-19 03:18:25 +01:00
|
|
|
create domain ddef5 numeric(8,2) NOT NULL DEFAULT '12.12';
|
|
|
|
|
|
|
|
create table defaulttest
|
|
|
|
( col1 ddef1
|
|
|
|
, col2 ddef2
|
|
|
|
, col3 ddef3
|
2002-08-20 06:48:36 +02:00
|
|
|
, col4 ddef4 PRIMARY KEY
|
2002-03-19 03:18:25 +01:00
|
|
|
, col5 ddef1 NOT NULL DEFAULT NULL
|
|
|
|
, col6 ddef2 DEFAULT '88'
|
|
|
|
, col7 ddef4 DEFAULT 8000
|
2002-08-20 06:48:36 +02:00
|
|
|
, col8 ddef5
|
2002-03-19 03:18:25 +01:00
|
|
|
);
|
2007-10-29 20:40:40 +01:00
|
|
|
insert into defaulttest(col4) values(0); -- fails, col5 defaults to null
|
|
|
|
alter table defaulttest alter column col5 drop default;
|
|
|
|
insert into defaulttest default values; -- succeeds, inserts domain default
|
|
|
|
-- We used to treat SET DEFAULT NULL as equivalent to DROP DEFAULT; wrong
|
|
|
|
alter table defaulttest alter column col5 set default null;
|
|
|
|
insert into defaulttest(col4) values(0); -- fails
|
|
|
|
alter table defaulttest alter column col5 drop default;
|
2002-03-19 03:18:25 +01:00
|
|
|
insert into defaulttest default values;
|
|
|
|
insert into defaulttest default values;
|
2002-09-20 05:52:50 +02:00
|
|
|
|
|
|
|
-- Test defaults with copy
|
|
|
|
COPY defaulttest(col5) FROM stdin;
|
|
|
|
42
|
|
|
|
\.
|
|
|
|
|
2002-03-19 03:18:25 +01:00
|
|
|
select * from defaulttest;
|
|
|
|
|
2002-12-06 06:00:34 +01:00
|
|
|
drop table defaulttest cascade;
|
|
|
|
|
|
|
|
-- Test ALTER DOMAIN .. NOT NULL
|
|
|
|
create domain dnotnulltest integer;
|
|
|
|
create table domnotnull
|
|
|
|
( col1 dnotnulltest
|
|
|
|
, col2 dnotnulltest
|
|
|
|
);
|
|
|
|
|
|
|
|
insert into domnotnull default values;
|
|
|
|
alter domain dnotnulltest set not null; -- fails
|
|
|
|
|
|
|
|
update domnotnull set col1 = 5;
|
|
|
|
alter domain dnotnulltest set not null; -- fails
|
|
|
|
|
|
|
|
update domnotnull set col2 = 6;
|
|
|
|
|
|
|
|
alter domain dnotnulltest set not null;
|
|
|
|
|
|
|
|
update domnotnull set col1 = null; -- fails
|
|
|
|
|
|
|
|
alter domain dnotnulltest drop not null;
|
|
|
|
|
|
|
|
update domnotnull set col1 = null;
|
|
|
|
|
|
|
|
drop domain dnotnulltest cascade;
|
|
|
|
|
|
|
|
-- Test ALTER DOMAIN .. DEFAULT ..
|
|
|
|
create table domdeftest (col1 ddef1);
|
|
|
|
|
|
|
|
insert into domdeftest default values;
|
|
|
|
select * from domdeftest;
|
|
|
|
|
|
|
|
alter domain ddef1 set default '42';
|
|
|
|
insert into domdeftest default values;
|
|
|
|
select * from domdeftest;
|
|
|
|
|
|
|
|
alter domain ddef1 drop default;
|
|
|
|
insert into domdeftest default values;
|
|
|
|
select * from domdeftest;
|
|
|
|
|
|
|
|
drop table domdeftest;
|
|
|
|
|
|
|
|
-- Test ALTER DOMAIN .. CONSTRAINT ..
|
|
|
|
create domain con as integer;
|
|
|
|
create table domcontest (col1 con);
|
|
|
|
|
|
|
|
insert into domcontest values (1);
|
|
|
|
insert into domcontest values (2);
|
|
|
|
alter domain con add constraint t check (VALUE < 1); -- fails
|
|
|
|
|
|
|
|
alter domain con add constraint t check (VALUE < 34);
|
|
|
|
alter domain con add check (VALUE > 0);
|
|
|
|
|
|
|
|
insert into domcontest values (-5); -- fails
|
|
|
|
insert into domcontest values (42); -- fails
|
|
|
|
insert into domcontest values (5);
|
|
|
|
|
|
|
|
alter domain con drop constraint t;
|
|
|
|
insert into domcontest values (-5); --fails
|
|
|
|
insert into domcontest values (42);
|
|
|
|
|
2012-01-05 18:48:55 +01:00
|
|
|
alter domain con drop constraint nonexistent;
|
|
|
|
alter domain con drop constraint if exists nonexistent;
|
|
|
|
|
2024-03-20 09:29:08 +01:00
|
|
|
-- not-null constraints
|
|
|
|
create domain connotnull integer;
|
|
|
|
create table domconnotnulltest
|
|
|
|
( col1 connotnull
|
|
|
|
, col2 connotnull
|
|
|
|
);
|
|
|
|
|
|
|
|
insert into domconnotnulltest default values;
|
|
|
|
alter domain connotnull add not null value; -- fails
|
|
|
|
|
|
|
|
update domconnotnulltest set col1 = 5;
|
|
|
|
alter domain connotnull add not null value; -- fails
|
|
|
|
|
|
|
|
update domconnotnulltest set col2 = 6;
|
|
|
|
|
|
|
|
alter domain connotnull add constraint constr1 not null value;
|
|
|
|
select count(*) from pg_constraint where contypid = 'connotnull'::regtype and contype = 'n';
|
|
|
|
alter domain connotnull add constraint constr1bis not null value; -- redundant
|
|
|
|
select count(*) from pg_constraint where contypid = 'connotnull'::regtype and contype = 'n';
|
|
|
|
|
|
|
|
update domconnotnulltest set col1 = null; -- fails
|
|
|
|
|
|
|
|
alter domain connotnull drop constraint constr1;
|
|
|
|
|
|
|
|
update domconnotnulltest set col1 = null;
|
|
|
|
|
|
|
|
drop domain connotnull cascade;
|
|
|
|
drop table domconnotnulltest;
|
|
|
|
|
2011-06-02 00:43:50 +02:00
|
|
|
-- Test ALTER DOMAIN .. CONSTRAINT .. NOT VALID
|
|
|
|
create domain things AS INT;
|
|
|
|
CREATE TABLE thethings (stuff things);
|
|
|
|
INSERT INTO thethings (stuff) VALUES (55);
|
|
|
|
ALTER DOMAIN things ADD CONSTRAINT meow CHECK (VALUE < 11);
|
|
|
|
ALTER DOMAIN things ADD CONSTRAINT meow CHECK (VALUE < 11) NOT VALID;
|
|
|
|
ALTER DOMAIN things VALIDATE CONSTRAINT meow;
|
|
|
|
UPDATE thethings SET stuff = 10;
|
|
|
|
ALTER DOMAIN things VALIDATE CONSTRAINT meow;
|
|
|
|
|
2003-02-03 22:15:45 +01:00
|
|
|
-- Confirm ALTER DOMAIN with RULES.
|
|
|
|
create table domtab (col1 integer);
|
|
|
|
create domain dom as integer;
|
|
|
|
create view domview as select cast(col1 as dom) from domtab;
|
|
|
|
insert into domtab (col1) values (null);
|
|
|
|
insert into domtab (col1) values (5);
|
|
|
|
select * from domview;
|
|
|
|
|
|
|
|
alter domain dom set not null;
|
|
|
|
select * from domview; -- fail
|
|
|
|
|
|
|
|
alter domain dom drop not null;
|
|
|
|
select * from domview;
|
|
|
|
|
|
|
|
alter domain dom add constraint domchkgt6 check(value > 6);
|
|
|
|
select * from domview; --fail
|
|
|
|
|
|
|
|
alter domain dom drop constraint domchkgt6 restrict;
|
|
|
|
select * from domview;
|
|
|
|
|
2002-12-06 06:00:34 +01:00
|
|
|
-- cleanup
|
2002-03-19 03:18:25 +01:00
|
|
|
drop domain ddef1 restrict;
|
|
|
|
drop domain ddef2 restrict;
|
|
|
|
drop domain ddef3 restrict;
|
|
|
|
drop domain ddef4 restrict;
|
|
|
|
drop domain ddef5 restrict;
|
2005-10-03 01:50:16 +02:00
|
|
|
drop sequence ddef4_seq;
|
2005-01-25 04:22:19 +01:00
|
|
|
|
2006-04-06 00:11:58 +02:00
|
|
|
-- Test domains over domains
|
|
|
|
create domain vchar4 varchar(4);
|
|
|
|
create domain dinter vchar4 check (substring(VALUE, 1, 1) = 'x');
|
|
|
|
create domain dtop dinter check (substring(VALUE, 2, 1) = '1');
|
|
|
|
|
|
|
|
select 'x123'::dtop;
|
|
|
|
select 'x1234'::dtop; -- explicit coercion should truncate
|
|
|
|
select 'y1234'::dtop; -- fail
|
|
|
|
select 'y123'::dtop; -- fail
|
|
|
|
select 'yz23'::dtop; -- fail
|
|
|
|
select 'xz23'::dtop; -- fail
|
|
|
|
|
|
|
|
create temp table dtest(f1 dtop);
|
|
|
|
|
|
|
|
insert into dtest values('x123');
|
|
|
|
insert into dtest values('x1234'); -- fail, implicit coercion
|
|
|
|
insert into dtest values('y1234'); -- fail, implicit coercion
|
|
|
|
insert into dtest values('y123'); -- fail
|
|
|
|
insert into dtest values('yz23'); -- fail
|
|
|
|
insert into dtest values('xz23'); -- fail
|
|
|
|
|
|
|
|
drop table dtest;
|
|
|
|
drop domain vchar4 cascade;
|
|
|
|
|
2005-01-25 04:22:19 +01:00
|
|
|
-- Make sure that constraints of newly-added domain columns are
|
|
|
|
-- enforced correctly, even if there's no default value for the new
|
|
|
|
-- column. Per bug #1433
|
|
|
|
create domain str_domain as text not null;
|
|
|
|
|
|
|
|
create table domain_test (a int, b int);
|
|
|
|
|
|
|
|
insert into domain_test values (1, 2);
|
|
|
|
insert into domain_test values (1, 2);
|
|
|
|
|
|
|
|
-- should fail
|
|
|
|
alter table domain_test add column c str_domain;
|
|
|
|
|
|
|
|
create domain str_domain2 as text check (value <> 'foo') default 'foo';
|
|
|
|
|
|
|
|
-- should fail
|
|
|
|
alter table domain_test add column d str_domain2;
|
2006-01-15 23:34:49 +01:00
|
|
|
|
|
|
|
-- Check that domain constraints on prepared statement parameters of
|
|
|
|
-- unknown type are enforced correctly.
|
|
|
|
create domain pos_int as int4 check (value > 0) not null;
|
|
|
|
prepare s1 as select $1::pos_int = 10 as "is_ten";
|
|
|
|
|
|
|
|
execute s1(10);
|
|
|
|
execute s1(0); -- should fail
|
|
|
|
execute s1(NULL); -- should fail
|
2006-04-06 00:11:58 +02:00
|
|
|
|
|
|
|
-- Check that domain constraints on plpgsql function parameters, results,
|
|
|
|
-- and local variables are enforced correctly.
|
|
|
|
|
|
|
|
create function doubledecrement(p1 pos_int) returns pos_int as $$
|
|
|
|
declare v pos_int;
|
2007-02-01 20:22:07 +01:00
|
|
|
begin
|
|
|
|
return p1;
|
|
|
|
end$$ language plpgsql;
|
|
|
|
|
|
|
|
select doubledecrement(3); -- fail because of implicit null assignment
|
|
|
|
|
|
|
|
create or replace function doubledecrement(p1 pos_int) returns pos_int as $$
|
|
|
|
declare v pos_int := 0;
|
|
|
|
begin
|
|
|
|
return p1;
|
|
|
|
end$$ language plpgsql;
|
|
|
|
|
|
|
|
select doubledecrement(3); -- fail at initialization assignment
|
|
|
|
|
|
|
|
create or replace function doubledecrement(p1 pos_int) returns pos_int as $$
|
|
|
|
declare v pos_int := 1;
|
2006-04-06 00:11:58 +02:00
|
|
|
begin
|
|
|
|
v := p1 - 1;
|
|
|
|
return v - 1;
|
|
|
|
end$$ language plpgsql;
|
|
|
|
|
|
|
|
select doubledecrement(null); -- fail before call
|
|
|
|
select doubledecrement(0); -- fail before call
|
|
|
|
select doubledecrement(1); -- fail at assignment to v
|
|
|
|
select doubledecrement(2); -- fail at return
|
|
|
|
select doubledecrement(3); -- good
|
2007-05-11 22:17:15 +02:00
|
|
|
|
|
|
|
-- Check that ALTER DOMAIN tests columns of derived types
|
|
|
|
|
|
|
|
create domain posint as int4;
|
|
|
|
|
|
|
|
-- Currently, this doesn't work for composite types, but verify it complains
|
|
|
|
create type ddtest1 as (f1 posint);
|
|
|
|
create table ddtest2(f1 ddtest1);
|
|
|
|
insert into ddtest2 values(row(-1));
|
|
|
|
alter domain posint add constraint c1 check(value >= 0);
|
|
|
|
drop table ddtest2;
|
|
|
|
|
2017-08-09 23:03:09 +02:00
|
|
|
-- Likewise for domains within arrays of composite
|
2007-05-11 22:17:15 +02:00
|
|
|
create table ddtest2(f1 ddtest1[]);
|
|
|
|
insert into ddtest2 values('{(-1)}');
|
|
|
|
alter domain posint add constraint c1 check(value >= 0);
|
|
|
|
drop table ddtest2;
|
|
|
|
|
2017-10-26 19:47:45 +02:00
|
|
|
-- Likewise for domains within domains over composite
|
|
|
|
create domain ddtest1d as ddtest1;
|
|
|
|
create table ddtest2(f1 ddtest1d);
|
|
|
|
insert into ddtest2 values('(-1)');
|
|
|
|
alter domain posint add constraint c1 check(value >= 0);
|
|
|
|
drop table ddtest2;
|
|
|
|
drop domain ddtest1d;
|
|
|
|
|
2017-08-09 23:03:09 +02:00
|
|
|
-- Likewise for domains within domains over array of composite
|
|
|
|
create domain ddtest1d as ddtest1[];
|
|
|
|
create table ddtest2(f1 ddtest1d);
|
|
|
|
insert into ddtest2 values('{(-1)}');
|
|
|
|
alter domain posint add constraint c1 check(value >= 0);
|
|
|
|
drop table ddtest2;
|
|
|
|
drop domain ddtest1d;
|
|
|
|
|
|
|
|
-- Doesn't work for ranges, either
|
|
|
|
create type rposint as range (subtype = posint);
|
|
|
|
create table ddtest2(f1 rposint);
|
|
|
|
insert into ddtest2 values('(-1,3]');
|
|
|
|
alter domain posint add constraint c1 check(value >= 0);
|
|
|
|
drop table ddtest2;
|
|
|
|
drop type rposint;
|
|
|
|
|
2007-05-11 22:17:15 +02:00
|
|
|
alter domain posint add constraint c1 check(value >= 0);
|
|
|
|
|
|
|
|
create domain posint2 as posint check (value % 2 = 0);
|
|
|
|
create table ddtest2(f1 posint2);
|
|
|
|
insert into ddtest2 values(11); -- fail
|
|
|
|
insert into ddtest2 values(-2); -- fail
|
|
|
|
insert into ddtest2 values(2);
|
|
|
|
|
|
|
|
alter domain posint add constraint c2 check(value >= 10); -- fail
|
|
|
|
alter domain posint add constraint c2 check(value > 0); -- OK
|
|
|
|
|
|
|
|
drop table ddtest2;
|
|
|
|
drop type ddtest1;
|
|
|
|
drop domain posint cascade;
|
Improve handling of domains over arrays.
This patch eliminates various bizarre behaviors caused by sloppy thinking
about the difference between a domain type and its underlying array type.
In particular, the operation of updating one element of such an array
has to be considered as yielding a value of the underlying array type,
*not* a value of the domain, because there's no assurance that the
domain's CHECK constraints are still satisfied. If we're intending to
store the result back into a domain column, we have to re-cast to the
domain type so that constraints are re-checked.
For similar reasons, such a domain can't be blindly matched to an ANYARRAY
polymorphic parameter, because the polymorphic function is likely to apply
array-ish operations that could invalidate the domain constraints. For the
moment, we just forbid such matching. We might later wish to insert an
automatic downcast to the underlying array type, but such a change should
also change matching of domains to ANYELEMENT for consistency.
To ensure that all such logic is rechecked, this patch removes the original
hack of setting a domain's pg_type.typelem field to match its base type;
the typelem will always be zero instead. In those places where it's really
okay to look through the domain type with no other logic changes, use the
newly added get_base_element_type function in place of get_element_type.
catversion bumped due to change in pg_type contents.
Per bug #5717 from Richard Huxton and subsequent discussion.
2010-10-21 22:07:17 +02:00
|
|
|
|
|
|
|
--
|
|
|
|
-- Check enforcement of domain-related typmod in plpgsql (bug #5717)
|
|
|
|
--
|
|
|
|
|
|
|
|
create or replace function array_elem_check(numeric) returns numeric as $$
|
|
|
|
declare
|
|
|
|
x numeric(4,2)[1];
|
|
|
|
begin
|
|
|
|
x[1] := $1;
|
|
|
|
return x[1];
|
|
|
|
end$$ language plpgsql;
|
|
|
|
|
|
|
|
select array_elem_check(121.00);
|
|
|
|
select array_elem_check(1.23456);
|
|
|
|
|
|
|
|
create domain mynums as numeric(4,2)[1];
|
|
|
|
|
|
|
|
create or replace function array_elem_check(numeric) returns numeric as $$
|
|
|
|
declare
|
|
|
|
x mynums;
|
|
|
|
begin
|
|
|
|
x[1] := $1;
|
|
|
|
return x[1];
|
|
|
|
end$$ language plpgsql;
|
|
|
|
|
|
|
|
select array_elem_check(121.00);
|
|
|
|
select array_elem_check(1.23456);
|
|
|
|
|
|
|
|
create domain mynums2 as mynums;
|
|
|
|
|
|
|
|
create or replace function array_elem_check(numeric) returns numeric as $$
|
|
|
|
declare
|
|
|
|
x mynums2;
|
|
|
|
begin
|
|
|
|
x[1] := $1;
|
|
|
|
return x[1];
|
|
|
|
end$$ language plpgsql;
|
|
|
|
|
|
|
|
select array_elem_check(121.00);
|
|
|
|
select array_elem_check(1.23456);
|
|
|
|
|
|
|
|
drop function array_elem_check(numeric);
|
|
|
|
|
|
|
|
--
|
|
|
|
-- Check enforcement of array-level domain constraints
|
|
|
|
--
|
|
|
|
|
|
|
|
create domain orderedpair as int[2] check (value[1] < value[2]);
|
|
|
|
|
|
|
|
select array[1,2]::orderedpair;
|
|
|
|
select array[2,1]::orderedpair; -- fail
|
|
|
|
|
|
|
|
create temp table op (f1 orderedpair);
|
|
|
|
insert into op values (array[1,2]);
|
|
|
|
insert into op values (array[2,1]); -- fail
|
|
|
|
|
|
|
|
update op set f1[2] = 3;
|
|
|
|
update op set f1[2] = 0; -- fail
|
|
|
|
select * from op;
|
|
|
|
|
|
|
|
create or replace function array_elem_check(int) returns int as $$
|
|
|
|
declare
|
|
|
|
x orderedpair := '{1,2}';
|
|
|
|
begin
|
|
|
|
x[2] := $1;
|
|
|
|
return x[2];
|
|
|
|
end$$ language plpgsql;
|
|
|
|
|
|
|
|
select array_elem_check(3);
|
|
|
|
select array_elem_check(-1);
|
|
|
|
|
|
|
|
drop function array_elem_check(int);
|
2011-12-22 21:43:56 +01:00
|
|
|
|
Use the typcache to cache constraints for domain types.
Previously, we cached domain constraints for the life of a query, or
really for the life of the FmgrInfo struct that was used to invoke
domain_in() or domain_check(). But plpgsql (and probably other places)
are set up to cache such FmgrInfos for the whole lifespan of a session,
which meant they could be enforcing really stale sets of constraints.
On the other hand, searching pg_constraint once per query gets kind of
expensive too: testing says that as much as half the runtime of a
trivial query such as "SELECT 0::domaintype" went into that.
To fix this, delegate the responsibility for tracking a domain's
constraints to the typcache, which has the infrastructure needed to
detect syscache invalidation events that signal possible changes.
This not only removes unnecessary repeat reads of pg_constraint,
but ensures that we never apply stale constraint data: whatever we
use is the current data according to syscache rules.
Unfortunately, the current configuration of the system catalogs means
we have to flush cached domain-constraint data whenever either pg_type
or pg_constraint changes, which happens rather a lot (eg, creation or
deletion of a temp table will do it). It might be worth rearranging
things to split pg_constraint into two catalogs, of which the domain
constraint one would probably be very low-traffic. That's a job for
another patch though, and in any case this patch should improve matters
materially even with that handicap.
This patch makes use of the recently-added memory context reset callback
feature to manage the lifespan of domain constraint caches, so that we
don't risk deleting a cache that might be in the midst of evaluation.
Although this is a bug fix as well as a performance improvement, no
back-patch. There haven't been many if any field complaints about
stale domain constraint checks, so it doesn't seem worth taking the
risk of modifying data structures as basic as MemoryContexts in back
branches.
2015-03-01 20:06:50 +01:00
|
|
|
--
|
|
|
|
-- Check enforcement of changing constraints in plpgsql
|
|
|
|
--
|
|
|
|
|
|
|
|
create domain di as int;
|
|
|
|
|
|
|
|
create function dom_check(int) returns di as $$
|
|
|
|
declare d di;
|
Drop no-op CoerceToDomain nodes from expressions at planning time.
If a domain has no constraints, then CoerceToDomain doesn't really do
anything and can be simplified to a RelabelType. This not only
eliminates cycles at execution, but allows the planner to optimize better
(for instance, match the coerced expression to an index on the underlying
column). However, we do have to support invalidating the plan later if
a constraint gets added to the domain. That's comparable to the case of
a change to a SQL function that had been inlined into a plan, so all the
necessary logic already exists for plans depending on functions. We
need only duplicate or share that logic for domains.
ALTER DOMAIN ADD/DROP CONSTRAINT need to be taught to send out sinval
messages for the domain's pg_type entry, since those operations don't
update that row. (ALTER DOMAIN SET/DROP NOT NULL do update that row,
so no code change is needed for them.)
Testing this revealed what's really a pre-existing bug in plpgsql:
it caches the SQL-expression-tree expansion of type coercions and
had no provision for invalidating entries in that cache. Up to now
that was only a problem if such an expression had inlined a SQL
function that got changed, which is unlikely though not impossible.
But failing to track changes of domain constraints breaks an existing
regression test case and would likely cause practical problems too.
We could fix that locally in plpgsql, but what seems like a better
idea is to build some generic infrastructure in plancache.c to store
standalone expressions and track invalidation events for them.
(It's tempting to wonder whether plpgsql's "simple expression" stuff
could use this code with lower overhead than its current use of the
heavyweight plancache APIs. But I've left that idea for later.)
Other stuff fixed in passing:
* Allow estimate_expression_value() to drop CoerceToDomain
unconditionally, effectively assuming that the coercion will succeed.
This will improve planner selectivity estimates for cases involving
estimatable expressions that are coerced to domains. We could have
done this independently of everything else here, but there wasn't
previously any need for eval_const_expressions_mutator to know about
CoerceToDomain at all.
* Use a dlist for plancache.c's list of cached plans, rather than a
manually threaded singly-linked list. That eliminates a potential
performance problem in DropCachedPlan.
* Fix a couple of inconsistencies in typecmds.c about whether
operations on domains drop RowExclusiveLock on pg_type. Our common
practice is that DDL operations do drop catalog locks, so standardize
on that choice.
Discussion: https://postgr.es/m/19958.1544122124@sss.pgh.pa.us
2018-12-13 19:24:43 +01:00
|
|
|
begin
|
|
|
|
d := $1::di;
|
|
|
|
return d;
|
|
|
|
end
|
|
|
|
$$ language plpgsql immutable;
|
|
|
|
|
|
|
|
select dom_check(0);
|
|
|
|
|
|
|
|
alter domain di add constraint pos check (value > 0);
|
|
|
|
|
|
|
|
select dom_check(0); -- fail
|
|
|
|
|
|
|
|
alter domain di drop constraint pos;
|
|
|
|
|
|
|
|
select dom_check(0);
|
|
|
|
|
|
|
|
-- implicit cast during assignment is a separate code path, test that too
|
|
|
|
|
|
|
|
create or replace function dom_check(int) returns di as $$
|
|
|
|
declare d di;
|
Use the typcache to cache constraints for domain types.
Previously, we cached domain constraints for the life of a query, or
really for the life of the FmgrInfo struct that was used to invoke
domain_in() or domain_check(). But plpgsql (and probably other places)
are set up to cache such FmgrInfos for the whole lifespan of a session,
which meant they could be enforcing really stale sets of constraints.
On the other hand, searching pg_constraint once per query gets kind of
expensive too: testing says that as much as half the runtime of a
trivial query such as "SELECT 0::domaintype" went into that.
To fix this, delegate the responsibility for tracking a domain's
constraints to the typcache, which has the infrastructure needed to
detect syscache invalidation events that signal possible changes.
This not only removes unnecessary repeat reads of pg_constraint,
but ensures that we never apply stale constraint data: whatever we
use is the current data according to syscache rules.
Unfortunately, the current configuration of the system catalogs means
we have to flush cached domain-constraint data whenever either pg_type
or pg_constraint changes, which happens rather a lot (eg, creation or
deletion of a temp table will do it). It might be worth rearranging
things to split pg_constraint into two catalogs, of which the domain
constraint one would probably be very low-traffic. That's a job for
another patch though, and in any case this patch should improve matters
materially even with that handicap.
This patch makes use of the recently-added memory context reset callback
feature to manage the lifespan of domain constraint caches, so that we
don't risk deleting a cache that might be in the midst of evaluation.
Although this is a bug fix as well as a performance improvement, no
back-patch. There haven't been many if any field complaints about
stale domain constraint checks, so it doesn't seem worth taking the
risk of modifying data structures as basic as MemoryContexts in back
branches.
2015-03-01 20:06:50 +01:00
|
|
|
begin
|
|
|
|
d := $1;
|
|
|
|
return d;
|
|
|
|
end
|
|
|
|
$$ language plpgsql immutable;
|
|
|
|
|
|
|
|
select dom_check(0);
|
|
|
|
|
|
|
|
alter domain di add constraint pos check (value > 0);
|
|
|
|
|
|
|
|
select dom_check(0); -- fail
|
|
|
|
|
|
|
|
alter domain di drop constraint pos;
|
|
|
|
|
|
|
|
select dom_check(0);
|
|
|
|
|
|
|
|
drop function dom_check(int);
|
|
|
|
|
|
|
|
drop domain di;
|
2011-12-22 21:43:56 +01:00
|
|
|
|
2015-11-30 00:18:42 +01:00
|
|
|
--
|
|
|
|
-- Check use of a (non-inline-able) SQL function in a domain constraint;
|
|
|
|
-- this has caused issues in the past
|
|
|
|
--
|
|
|
|
|
|
|
|
create function sql_is_distinct_from(anyelement, anyelement)
|
|
|
|
returns boolean language sql
|
|
|
|
as 'select $1 is distinct from $2 limit 1';
|
|
|
|
|
|
|
|
create domain inotnull int
|
|
|
|
check (sql_is_distinct_from(value, null));
|
|
|
|
|
|
|
|
select 1::inotnull;
|
|
|
|
select null::inotnull;
|
|
|
|
|
|
|
|
create table dom_table (x inotnull);
|
|
|
|
insert into dom_table values ('1');
|
|
|
|
insert into dom_table values (1);
|
|
|
|
insert into dom_table values (null);
|
|
|
|
|
|
|
|
drop table dom_table;
|
|
|
|
drop domain inotnull;
|
|
|
|
drop function sql_is_distinct_from(anyelement, anyelement);
|
|
|
|
|
2011-12-22 21:43:56 +01:00
|
|
|
--
|
|
|
|
-- Renaming
|
|
|
|
--
|
|
|
|
|
|
|
|
create domain testdomain1 as int;
|
|
|
|
alter domain testdomain1 rename to testdomain2;
|
|
|
|
alter type testdomain2 rename to testdomain3; -- alter type also works
|
|
|
|
drop domain testdomain3;
|
2012-04-03 07:11:51 +02:00
|
|
|
|
|
|
|
|
|
|
|
--
|
|
|
|
-- Renaming domain constraints
|
|
|
|
--
|
|
|
|
|
|
|
|
create domain testdomain1 as int constraint unsigned check (value > 0);
|
|
|
|
alter domain testdomain1 rename constraint unsigned to unsigned_foo;
|
|
|
|
alter domain testdomain1 drop constraint unsigned_foo;
|
|
|
|
drop domain testdomain1;
|
2024-03-20 07:08:01 +01:00
|
|
|
|
|
|
|
|
|
|
|
--
|
|
|
|
-- Information schema
|
|
|
|
--
|
|
|
|
|
|
|
|
SELECT * FROM information_schema.column_domain_usage
|
|
|
|
WHERE domain_name IN ('con', 'dom', 'pos_int', 'things')
|
|
|
|
ORDER BY domain_name;
|
|
|
|
|
|
|
|
SELECT * FROM information_schema.domain_constraints
|
|
|
|
WHERE domain_name IN ('con', 'dom', 'pos_int', 'things')
|
|
|
|
ORDER BY constraint_name;
|
|
|
|
|
|
|
|
SELECT * FROM information_schema.domains
|
|
|
|
WHERE domain_name IN ('con', 'dom', 'pos_int', 'things')
|
|
|
|
ORDER BY domain_name;
|
|
|
|
|
|
|
|
SELECT * FROM information_schema.check_constraints
|
|
|
|
WHERE (constraint_schema, constraint_name)
|
|
|
|
IN (SELECT constraint_schema, constraint_name
|
|
|
|
FROM information_schema.domain_constraints
|
|
|
|
WHERE domain_name IN ('con', 'dom', 'pos_int', 'things'))
|
|
|
|
ORDER BY constraint_name;
|