Commit to match discussed elog() changes. Only update is that LOG is

[postgresql] / src / test / regress / expected / foreign_key.out

diff --git a/src/test/regress/expected/foreign_key.out b/src/test/regress/expected/foreign_key.out
index fb59fe233c3b60069f55b60e7823467f45b970ac..ac6b7d3dc66e48822f010dcff90d7e77eeb26ac0 100644 (file)
--- a/src/test/regress/expected/foreign_key.out
+++ b/src/test/regress/expected/foreign_key.out
@@ -6,9 +6,9 @@
 -- First test, check and cascade
 --
 CREATE TABLE PKTABLE ( ptest1 int PRIMARY KEY, ptest2 text );
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
 CREATE TABLE FKTABLE ( ftest1 int REFERENCES PKTABLE MATCH FULL ON DELETE CASCADE ON UPDATE CASCADE, ftest2 int );
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 -- Insert test data into PKTABLE
 INSERT INTO PKTABLE VALUES (1, 'Test1');
 INSERT INTO PKTABLE VALUES (2, 'Test2');
@@ -56,16 +56,16 @@ SELECT * FROM FKTABLE;
 (3 rows)
 
 DROP TABLE PKTABLE;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "fktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "fktable"
 DROP TABLE FKTABLE;
 --
 -- check set NULL and table constraint on multiple columns
 --
 CREATE TABLE PKTABLE ( ptest1 int, ptest2 int, ptest3 text, PRIMARY KEY(ptest1, ptest2) );
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
 CREATE TABLE FKTABLE ( ftest1 int, ftest2 int, ftest3 int, CONSTRAINT constrname FOREIGN KEY(ftest1, ftest2) 
                        REFERENCES PKTABLE MATCH FULL ON DELETE SET NULL ON UPDATE SET NULL);
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 -- Insert test data into PKTABLE
 INSERT INTO PKTABLE VALUES (1, 2, 'Test1');
 INSERT INTO PKTABLE VALUES (1, 3, 'Test1-2');
@@ -139,16 +139,16 @@ SELECT * FROM FKTABLE;
 (5 rows)
 
 DROP TABLE PKTABLE;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "fktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "fktable"
 DROP TABLE FKTABLE;
 --
 -- check set default and table constraint on multiple columns
 --
 CREATE TABLE PKTABLE ( ptest1 int, ptest2 int, ptest3 text, PRIMARY KEY(ptest1, ptest2) );
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
 CREATE TABLE FKTABLE ( ftest1 int DEFAULT -1, ftest2 int DEFAULT -2, ftest3 int, CONSTRAINT constrname2 FOREIGN KEY(ftest1, ftest2) 
                        REFERENCES PKTABLE MATCH FULL ON DELETE SET DEFAULT ON UPDATE SET DEFAULT);
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 -- Insert a value in PKTABLE for default
 INSERT INTO PKTABLE VALUES (-1, -2, 'The Default!');
 -- Insert test data into PKTABLE
@@ -224,15 +224,15 @@ SELECT * FROM FKTABLE;
 (5 rows)
 
 DROP TABLE PKTABLE;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "fktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "fktable"
 DROP TABLE FKTABLE;
 --
 -- First test, check with no on delete or on update
 --
 CREATE TABLE PKTABLE ( ptest1 int PRIMARY KEY, ptest2 text );
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
 CREATE TABLE FKTABLE ( ftest1 int REFERENCES PKTABLE MATCH FULL, ftest2 int );
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 -- Insert test data into PKTABLE
 INSERT INTO PKTABLE VALUES (1, 'Test1');
 INSERT INTO PKTABLE VALUES (2, 'Test2');
@@ -299,15 +299,15 @@ SELECT * FROM PKTABLE;
 (4 rows)
 
 DROP TABLE PKTABLE;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "fktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "fktable"
 DROP TABLE FKTABLE;
 -- MATCH unspecified
 -- Base test restricting update/delete
 CREATE TABLE PKTABLE ( ptest1 int, ptest2 int, ptest3 int, ptest4 text, PRIMARY KEY(ptest1, ptest2, ptest3) );
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
 CREATE TABLE FKTABLE ( ftest1 int, ftest2 int, ftest3 int, ftest4 int,  CONSTRAINT constrname3
                        FOREIGN KEY(ftest1, ftest2, ftest3) REFERENCES PKTABLE);
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 -- Insert Primary Key values
 INSERT INTO PKTABLE VALUES (1, 2, 3, 'test1');
 INSERT INTO PKTABLE VALUES (1, 3, 3, 'test2');
@@ -363,16 +363,16 @@ SELECT * from FKTABLE;
 (5 rows)
 
 DROP TABLE FKTABLE;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
 DROP TABLE PKTABLE;
 -- cascade update/delete
 CREATE TABLE PKTABLE ( ptest1 int, ptest2 int, ptest3 int, ptest4 text, PRIMARY KEY(ptest1, ptest2, ptest3) );
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
 CREATE TABLE FKTABLE ( ftest1 int, ftest2 int, ftest3 int, ftest4 int,  CONSTRAINT constrname3
                        FOREIGN KEY(ftest1, ftest2, ftest3) REFERENCES PKTABLE
                        ON DELETE CASCADE ON UPDATE CASCADE);
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 -- Insert Primary Key values
 INSERT INTO PKTABLE VALUES (1, 2, 3, 'test1');
 INSERT INTO PKTABLE VALUES (1, 3, 3, 'test2');
@@ -462,16 +462,16 @@ SELECT * from FKTABLE;
 (4 rows)
 
 DROP TABLE FKTABLE;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
 DROP TABLE PKTABLE;
 -- set null update / set default delete
 CREATE TABLE PKTABLE ( ptest1 int, ptest2 int, ptest3 int, ptest4 text, PRIMARY KEY(ptest1, ptest2, ptest3) );
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
 CREATE TABLE FKTABLE ( ftest1 int DEFAULT 0, ftest2 int, ftest3 int, ftest4 int,  CONSTRAINT constrname3
                        FOREIGN KEY(ftest1, ftest2, ftest3) REFERENCES PKTABLE
                        ON DELETE SET DEFAULT ON UPDATE SET NULL);
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 -- Insert Primary Key values
 INSERT INTO PKTABLE VALUES (1, 2, 3, 'test1');
 INSERT INTO PKTABLE VALUES (1, 3, 3, 'test2');
@@ -568,16 +568,16 @@ SELECT * from FKTABLE;
 (6 rows)
 
 DROP TABLE FKTABLE;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
 DROP TABLE PKTABLE;
 -- set default update / set null delete
 CREATE TABLE PKTABLE ( ptest1 int, ptest2 int, ptest3 int, ptest4 text, PRIMARY KEY(ptest1, ptest2, ptest3) );
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
 CREATE TABLE FKTABLE ( ftest1 int DEFAULT 0, ftest2 int DEFAULT -1, ftest3 int, ftest4 int,  CONSTRAINT constrname3
                        FOREIGN KEY(ftest1, ftest2, ftest3) REFERENCES PKTABLE
                        ON DELETE SET NULL ON UPDATE SET DEFAULT);
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 -- Insert Primary Key values
 INSERT INTO PKTABLE VALUES (1, 2, 3, 'test1');
 INSERT INTO PKTABLE VALUES (1, 3, 3, 'test2');
@@ -687,16 +687,16 @@ SELECT * from FKTABLE;
 (7 rows)
 
 DROP TABLE FKTABLE;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
 DROP TABLE PKTABLE;
 CREATE TABLE PKTABLE (ptest1 int PRIMARY KEY);
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
 CREATE TABLE FKTABLE_FAIL1 ( ftest1 int, CONSTRAINT fkfail1 FOREIGN KEY (ftest2) REFERENCES PKTABLE);
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  CREATE TABLE: column "ftest2" referenced in foreign key constraint does not exist
 CREATE TABLE FKTABLE_FAIL2 ( ftest1 int, CONSTRAINT fkfail1 FOREIGN KEY (ftest1) REFERENCES PKTABLE(ptest2));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  UNIQUE constraint matching given keys for referenced table "pktable" not found
 DROP TABLE FKTABLE_FAIL1;
 ERROR:  table "fktable_fail1" does not exist
@@ -705,9 +705,9 @@ ERROR:  table "fktable_fail2" does not exist
 DROP TABLE PKTABLE;
 -- Test for referencing column number smaller than referenced constraint
 CREATE TABLE PKTABLE (ptest1 int, ptest2 int, UNIQUE(ptest1, ptest2));
-NOTICE:  CREATE TABLE / UNIQUE will create implicit index 'pktable_ptest1_key' for table 'pktable'
+INFO:  CREATE TABLE / UNIQUE will create implicit index 'pktable_ptest1_key' for table 'pktable'
 CREATE TABLE FKTABLE_FAIL1 (ftest1 int REFERENCES pktable(ptest1));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  UNIQUE constraint matching given keys for referenced table "pktable" not found
 DROP TABLE FKTABLE_FAIL1;
 ERROR:  table "fktable_fail1" does not exist
@@ -717,105 +717,105 @@ DROP TABLE PKTABLE;
 --
 -- Basic one column, two table setup 
 CREATE TABLE PKTABLE (ptest1 int PRIMARY KEY);
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
 -- This next should fail, because text=int does not exist
 CREATE TABLE FKTABLE (ftest1 text REFERENCES pktable);
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'text' and 'integer'
        You will have to retype this query using an explicit cast
 -- This should also fail for the same reason, but here we
 -- give the column name
 CREATE TABLE FKTABLE (ftest1 text REFERENCES pktable(ptest1));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'text' and 'integer'
        You will have to retype this query using an explicit cast
 -- This should succeed, even though they are different types
 -- because varchar=int does exist
 CREATE TABLE FKTABLE (ftest1 varchar REFERENCES pktable);
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 DROP TABLE FKTABLE;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
 -- As should this
 CREATE TABLE FKTABLE (ftest1 varchar REFERENCES pktable(ptest1));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 DROP TABLE FKTABLE;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
 DROP TABLE PKTABLE;
 -- Two columns, two tables
 CREATE TABLE PKTABLE (ptest1 int, ptest2 text, PRIMARY KEY(ptest1, ptest2));
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
 -- This should fail, because we just chose really odd types
 CREATE TABLE FKTABLE (ftest1 cidr, ftest2 datetime, FOREIGN KEY(ftest1, ftest2) REFERENCES pktable);
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'cidr' and 'integer'
        You will have to retype this query using an explicit cast
 -- Again, so should this...
 CREATE TABLE FKTABLE (ftest1 cidr, ftest2 datetime, FOREIGN KEY(ftest1, ftest2) REFERENCES pktable(ptest1, ptest2));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'cidr' and 'integer'
        You will have to retype this query using an explicit cast
 -- This fails because we mixed up the column ordering
 CREATE TABLE FKTABLE (ftest1 int, ftest2 text, FOREIGN KEY(ftest2, ftest1) REFERENCES pktable);
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'text' and 'integer'
        You will have to retype this query using an explicit cast
 -- As does this...
 CREATE TABLE FKTABLE (ftest1 int, ftest2 text, FOREIGN KEY(ftest2, ftest1) REFERENCES pktable(ptest1, ptest2));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'text' and 'integer'
        You will have to retype this query using an explicit cast
 -- And again..
 CREATE TABLE FKTABLE (ftest1 int, ftest2 text, FOREIGN KEY(ftest1, ftest2) REFERENCES pktable(ptest2, ptest1));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'integer' and 'text'
        You will have to retype this query using an explicit cast
 -- This works...
 CREATE TABLE FKTABLE (ftest1 int, ftest2 text, FOREIGN KEY(ftest2, ftest1) REFERENCES pktable(ptest2, ptest1));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 DROP TABLE FKTABLE;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
 -- As does this
 CREATE TABLE FKTABLE (ftest1 int, ftest2 text, FOREIGN KEY(ftest1, ftest2) REFERENCES pktable(ptest1, ptest2));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 DROP TABLE FKTABLE;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
 DROP TABLE PKTABLE;
 -- Two columns, same table
 -- Make sure this still works...
 CREATE TABLE PKTABLE (ptest1 int, ptest2 text, ptest3 int, ptest4 text, PRIMARY KEY(ptest1, ptest2), FOREIGN KEY(ptest3,
 ptest4) REFERENCES pktable(ptest1, ptest2));
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 DROP TABLE PKTABLE;
 -- And this, 
 CREATE TABLE PKTABLE (ptest1 int, ptest2 text, ptest3 int, ptest4 text, PRIMARY KEY(ptest1, ptest2), FOREIGN KEY(ptest3,
 ptest4) REFERENCES pktable);
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 DROP TABLE PKTABLE;
 -- This shouldn't (mixed up columns)
 CREATE TABLE PKTABLE (ptest1 int, ptest2 text, ptest3 int, ptest4 text, PRIMARY KEY(ptest1, ptest2), FOREIGN KEY(ptest3,
 ptest4) REFERENCES pktable(ptest2, ptest1));
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'integer' and 'text'
        You will have to retype this query using an explicit cast
 -- Nor should this... (same reason, we have 4,3 referencing 1,2 which mismatches types
 CREATE TABLE PKTABLE (ptest1 int, ptest2 text, ptest3 int, ptest4 text, PRIMARY KEY(ptest1, ptest2), FOREIGN KEY(ptest4,
 ptest3) REFERENCES pktable(ptest1, ptest2));
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'text' and 'integer'
        You will have to retype this query using an explicit cast
 -- Not this one either... Same as the last one except we didn't defined the columns being referenced.
 CREATE TABLE PKTABLE (ptest1 int, ptest2 text, ptest3 int, ptest4 text, PRIMARY KEY(ptest1, ptest2), FOREIGN KEY(ptest4,
 ptest3) REFERENCES pktable);
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'text' and 'integer'
        You will have to retype this query using an explicit cast
 --
@@ -823,10 +823,10 @@ ERROR:  Unable to identify an operator '=' for types 'text' and 'integer'
 -- Basic 2 table case: 1 column of matching types.
 create table pktable_base (base1 int not null);
 create table pktable (ptest1 int, primary key(base1), unique(base1, ptest1)) inherits (pktable_base);
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
-NOTICE:  CREATE TABLE / UNIQUE will create implicit index 'pktable_base1_key' for table 'pktable'
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE / UNIQUE will create implicit index 'pktable_base1_key' for table 'pktable'
 create table fktable (ftest1 int references pktable(base1));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 -- now some ins, upd, del
 insert into pktable(base1) values (1);
 insert into pktable(base1) values (2);
@@ -849,12 +849,12 @@ update pktable set base1=base1*4 where base1<3;
 delete from pktable where base1>3;
 -- cleanup
 drop table fktable;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
 delete from pktable;
 -- Now 2 columns 2 tables, matching types
 create table fktable (ftest1 int, ftest2 int, foreign key(ftest1, ftest2) references pktable(base1, ptest1));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 -- now some ins, upd, del
 insert into pktable(base1, ptest1) values (1, 1);
 insert into pktable(base1, ptest1) values (2, 2);
@@ -877,16 +877,16 @@ update pktable set base1=base1*4 where base1<3;
 delete from pktable where base1>3;
 -- cleanup
 drop table fktable;
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
-NOTICE:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
+INFO:  DROP TABLE implicitly drops referential integrity trigger from table "pktable"
 drop table pktable;
 drop table pktable_base;
 -- Now we'll do one all in 1 table with 2 columns of matching types
 create table pktable_base(base1 int not null, base2 int);
 create table pktable(ptest1 int, ptest2 int, primary key(base1, ptest1), foreign key(base2, ptest2) references
                                              pktable(base1, ptest1)) inherits (pktable_base);
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 insert into pktable (base1, ptest1, base2, ptest2) values (1, 1, 1, 1);
 insert into pktable (base1, ptest1, base2, ptest2) values (2, 1, 1, 1);
 insert into pktable (base1, ptest1, base2, ptest2) values (2, 2, 2, 1);
@@ -908,27 +908,27 @@ drop table pktable_base;
 -- 2 columns (2 tables), mismatched types
 create table pktable_base(base1 int not null);
 create table pktable(ptest1 text, primary key(base1, ptest1)) inherits (pktable_base);
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
 -- just generally bad types (with and without column references on the referenced table)
 create table fktable(ftest1 cidr, ftest2 int[], foreign key (ftest1, ftest2) references pktable);
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'cidr' and 'integer'
        You will have to retype this query using an explicit cast
 create table fktable(ftest1 cidr, ftest2 int[], foreign key (ftest1, ftest2) references pktable(base1, ptest1));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'cidr' and 'integer'
        You will have to retype this query using an explicit cast
 -- let's mix up which columns reference which
 create table fktable(ftest1 int, ftest2 text, foreign key(ftest2, ftest1) references pktable);
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'text' and 'integer'
        You will have to retype this query using an explicit cast
 create table fktable(ftest1 int, ftest2 text, foreign key(ftest2, ftest1) references pktable(base1, ptest1));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'text' and 'integer'
        You will have to retype this query using an explicit cast
 create table fktable(ftest1 int, ftest2 text, foreign key(ftest1, ftest2) references pktable(ptest1, base1));
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'integer' and 'text'
        You will have to retype this query using an explicit cast
 drop table pktable;
@@ -937,26 +937,26 @@ drop table pktable_base;
 create table pktable_base(base1 int not null, base2 int);
 create table pktable(ptest1 text, ptest2 text[], primary key(base1, ptest1), foreign key(base2, ptest2) references
                                              pktable(base1, ptest1)) inherits (pktable_base);
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'text[]' and 'text'
        You will have to retype this query using an explicit cast
 create table pktable(ptest1 text, ptest2 text, primary key(base1, ptest1), foreign key(base2, ptest2) references
                                              pktable(ptest1, base1)) inherits (pktable_base);
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'integer' and 'text'
        You will have to retype this query using an explicit cast
 create table pktable(ptest1 text, ptest2 text, primary key(base1, ptest1), foreign key(ptest2, base2) references
                                              pktable(base1, ptest1)) inherits (pktable_base);
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'text' and 'integer'
        You will have to retype this query using an explicit cast
 create table pktable(ptest1 text, ptest2 text, primary key(base1, ptest1), foreign key(ptest2, base2) references
                                              pktable(base1, ptest1)) inherits (pktable_base);
-NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
-NOTICE:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
+INFO:  CREATE TABLE / PRIMARY KEY will create implicit index 'pktable_pkey' for table 'pktable'
+INFO:  CREATE TABLE will create implicit trigger(s) for FOREIGN KEY check(s)
 ERROR:  Unable to identify an operator '=' for types 'text' and 'integer'
        You will have to retype this query using an explicit cast
 drop table pktable;