Don't allow CREATE TABLE AS to create a column with invalid collation

It is possible that an expression ends up with a collatable type but
without a collation.  CREATE TABLE AS could then create a table based
on that.  But such a column cannot be dumped with valid SQL syntax, so
we disallow creating such a column.

per test report from Noah Misch

diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index bfffd6ef4c7cc2167358d8f51c56a41cc3e2f32c..50efa4782d640558204e17a381609448e0bd9e33 100644 (file)
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -429,6 +429,7 @@ CheckAttributeNamesTypes(TupleDesc tupdesc, char relkind,
        {
                CheckAttributeType(NameStr(tupdesc->attrs[i]->attname),
                                                   tupdesc->attrs[i]->atttypid,
+                                                  tupdesc->attrs[i]->attcollation,
                                                   allow_system_table_mods);
        }
 }
@@ -442,7 +443,7 @@ CheckAttributeNamesTypes(TupleDesc tupdesc, char relkind,
  * --------------------------------
  */
 void
-CheckAttributeType(const char *attname, Oid atttypid,
+CheckAttributeType(const char *attname, Oid atttypid, Oid attcollation,
                                   bool allow_system_table_mods)
 {
        char            att_typtype = get_typtype(atttypid);
@@ -493,12 +494,24 @@ CheckAttributeType(const char *attname, Oid atttypid,
 
                        if (attr->attisdropped)
                                continue;
-                       CheckAttributeType(NameStr(attr->attname), attr->atttypid,
+                       CheckAttributeType(NameStr(attr->attname), attr->atttypid, attr->attcollation,
                                                           allow_system_table_mods);
                }
 
                relation_close(relation, AccessShareLock);
        }
+
+       /*
+        * This might not be strictly invalid per SQL standard, but it is
+        * pretty useless, and it cannot be dumped, so we must disallow
+        * it.
+        */
+       if (type_is_collatable(atttypid) && !OidIsValid(attcollation))
+                       ereport(ERROR,
+                                       (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+                                        errmsg("no collation was derived for column \"%s\" with collatable type %s",
+                                                       attname, format_type_be(atttypid)),
+                                        errhint("Use the COLLATE clause to set the collation explicitly.")));
 }
 
 /*

diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index 58265129e60d8b215951b597136eddb01f277a0d..7a2629ecd198afa3b4f485ada071b23ed255199e 100644 (file)
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -352,6 +352,8 @@ ConstructTupleDescriptor(Relation heapRelation,
                        to->atthasdef = false;
                        to->attislocal = true;
                        to->attinhcount = 0;
+
+                       to->attcollation = collationObjectId[i];
                }
                else
                {
@@ -388,6 +390,8 @@ ConstructTupleDescriptor(Relation heapRelation,
                        to->atttypmod = -1;
                        to->attislocal = true;
 
+                       to->attcollation = collationObjectId[i];
+
                        ReleaseSysCache(tuple);
 
                        /*
@@ -399,11 +403,9 @@ ConstructTupleDescriptor(Relation heapRelation,
                         * whether a table column is of a safe type (which is why we
                         * needn't check for the non-expression case).
                         */
-                       CheckAttributeType(NameStr(to->attname), to->atttypid, false);
+                       CheckAttributeType(NameStr(to->attname), to->atttypid, to->attcollation, false);
                }
 
-               to->attcollation = collationObjectId[i];
-
                /*
                 * We do not yet have the correct relation OID for the index, so just
                 * set it invalid for now.      InitializeAttributeOids() will fix it

diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index e76ce2ceb13311a261e478c8a65a215ff6a9ce45..3be9a6f34815cd05de00668b61c7ca9eabbf7074 100644 (file)
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -4206,7 +4206,7 @@ ATExecAddColumn(AlteredTableInfo *tab, Relation rel,
        typeOid = HeapTupleGetOid(typeTuple);
 
        /* make sure datatype is legal for a column */
-       CheckAttributeType(colDef->colname, typeOid, false);
+       CheckAttributeType(colDef->colname, typeOid, collOid, false);
 
        /* construct new attribute's pg_attribute entry */
        attribute.attrelid = myrelid;
@@ -6515,7 +6515,7 @@ ATPrepAlterColumnType(List **wqueue,
        typenameTypeIdModColl(NULL, typeName, &targettype, &targettypmod, &targetcollid);
 
        /* make sure datatype is legal for a column */
-       CheckAttributeType(colName, targettype, false);
+       CheckAttributeType(colName, targettype, targetcollid, false);
 
        if (tab->relkind == RELKIND_RELATION)
        {

diff --git a/src/include/catalog/heap.h b/src/include/catalog/heap.h
index f62536a8b214a64c94ccf5c404871f9b430d1023..5f9a864be5f0e6922b1be4dd5d5fbb4b7edf4bc3 100644 (file)
--- a/src/include/catalog/heap.h
+++ b/src/include/catalog/heap.h
@@ -117,7 +117,7 @@ extern Form_pg_attribute SystemAttributeByName(const char *attname,
 extern void CheckAttributeNamesTypes(TupleDesc tupdesc, char relkind,
                                                 bool allow_system_table_mods);
 
-extern void CheckAttributeType(const char *attname, Oid atttypid,
+extern void CheckAttributeType(const char *attname, Oid atttypid, Oid attcollation,
                                   bool allow_system_table_mods);
 
 #endif   /* HEAP_H */

diff --git a/src/test/regress/expected/collate.linux.utf8.out b/src/test/regress/expected/collate.linux.utf8.out
index c793918be4f1d5cde24f0683347a53cf515e5487..caa65b2f37f881cdfa817f6d8c9008cd56c1ab79 100644 (file)
--- a/src/test/regress/expected/collate.linux.utf8.out
+++ b/src/test/regress/expected/collate.linux.utf8.out
@@ -627,6 +627,9 @@ ERROR:  collation mismatch between implicit collations "en_US.utf8" and "C"
 LINE 1: SELECT a, b FROM collate_test1 EXCEPT SELECT a, b FROM colla...
                                                         ^
 HINT:  You can override the collation by applying the COLLATE clause to one or both expressions.
+CREATE TABLE test_u AS SELECT a, b FROM collate_test1 UNION ALL SELECT a, b FROM collate_test3; -- fail
+ERROR:  no collation was derived for column "b" with collatable type text
+HINT:  Use the COLLATE clause to set the collation explicitly.
 -- casting
 SELECT CAST('42' AS text COLLATE "C");
 ERROR:  COLLATE clause not allowed in cast target

diff --git a/src/test/regress/sql/collate.linux.utf8.sql b/src/test/regress/sql/collate.linux.utf8.sql
index 9fd55e817e63f8f1d4397d99809e5110176f0925..c70e5cefd5fca248edea7b7b1ae2e70c6aab2740 100644 (file)
--- a/src/test/regress/sql/collate.linux.utf8.sql
+++ b/src/test/regress/sql/collate.linux.utf8.sql
@@ -188,6 +188,8 @@ SELECT a, b COLLATE "C" FROM collate_test1 UNION SELECT a, b FROM collate_test3
 SELECT a, b FROM collate_test1 INTERSECT SELECT a, b FROM collate_test3 ORDER BY 2; -- fail
 SELECT a, b FROM collate_test1 EXCEPT SELECT a, b FROM collate_test3 ORDER BY 2; -- fail
 
+CREATE TABLE test_u AS SELECT a, b FROM collate_test1 UNION ALL SELECT a, b FROM collate_test3; -- fail
+
 
 -- casting