Copy NOT NULL constraints in PG 18.

Author: Antonin Houska

README.md

@@ -139,22 +139,27 @@ table. It's recommended to handle constraints creation this way:
     but it does not hurt to check them in the target table, especially if the
     column data type is being changed.)
 
-2.  Add NOT NULL constraints. `rewrite_table()` by-passes validation of these,
-    but all the rows it inserts into the target table must have been validated
-    in the source table. Even if the column data tape is different in the
-    target table, the data type conversion should not turn non-NULL value to
-    NULL or vice versa.
+2.  If the version of PostgreSQL server is 17 or lower, add NOT NULL
+    constraints. `rewrite_table()` by-passes validation of these, but all the
+    rows it inserts into the target table must have been validated in the
+    source table. Even if the column data tape is different in the target
+    table, the data type conversion should not turn non-NULL value to NULL or
+    vice versa.
 
 3.  CHECK constraints are created automatically by `rewrite_table()` when all
     the data changes have been applied to the target table. However, these
     constraints are created as NOT VALID, so you need to use the `ALTER TABLE
     ... VALIDATE CONSTRAINT ...` command to validate them.
 
     (The function does not create these constraints immediately as valid,
-    because that would imply blocking access to the table for significant
+    because that could imply blocking access to the table for significant
     time.)
 
-4.  FOREIGN KEY constraints are also created automatically and need to be
+4.  If the version of PostgreSQL server is 18 or higher, NOT NULL constraints
+    are also created automatically and need to be validated using the `ALTER
+    TABLE ... VALIDATE CONSTRAINT ...` command.
+
+5.  FOREIGN KEY constraints are also created automatically and need to be
     validated using the `ALTER TABLE ... VALIDATE CONSTRAINT ...` command,
     unless the referencing table is partitioned: the NOT VALID option is
     currently not supported for partitioned tables.
@@ -165,7 +170,7 @@ table. It's recommended to handle constraints creation this way:
     to minimize the risk that applications modify the database in a way that
     violates the constraints.
 
-5.  Drop all foreign keys involving the source table.
+6.  Drop all foreign keys involving the source table.
 
     You probably want to drop the source table anyway, but if you don't, you
     should at least drop its FOREIGN KEY constraints. As the table was

pg_rewrite.c

@@ -152,6 +152,10 @@ static void dump_fk_constraint(HeapTuple tup, Oid relid_dst,
 							   StringInfo buf);
 static void dump_check_constraint(Oid relid_dst, const char *relname_dst,
 								  HeapTuple tup, StringInfo buf);
+#if PG_VERSION_NUM >= 180000
+static void dump_null_constraint(Oid relid_dst, const char *relname_dst,
+								 HeapTuple tup, StringInfo buf);
+#endif
 static void dump_constraint_common(const char *nsp, const char *relname,
 								   Form_pg_constraint con, StringInfo buf);
 static int decompile_column_index_array(Datum column_index_array, Oid relId,
@@ -2916,13 +2920,15 @@ copy_constraints(Oid relid_dst, const char *relname_dst, Oid relid_src)
 					break;
 				}
 
-				/*
-				 * TODO Is it o.k. to assume that no data type conversion can
-				 * change the validity of NOT NULL constraint? The problem is
-				 * that NOT NULL cannot be set NOT VALID in PG < 18. At least
-				 * in PG >= 18 we probably should handle NOT NULL in the same
-				 * way as FK / CHECK constraints.
-				 */
+#if PG_VERSION_NUM >= 180000
+			case CONSTRAINT_NOTNULL:
+				{
+					if (con->conrelid == relid_src)
+						dump_null_constraint(relid_dst, relname_dst, tuple,
+											 buf);
+					break;
+				}
+#endif
 			default:
 				break;
 		}
@@ -3183,6 +3189,31 @@ dump_check_constraint(Oid relid_dst, const char *relname_dst, HeapTuple tup,
 					 con->connoinherit ? " NO INHERIT" : "");
 }
 
+#if PG_VERSION_NUM >= 180000
+static void
+dump_null_constraint(Oid relid_dst, const char *relname_dst,
+					 HeapTuple tup, StringInfo buf)
+{
+	Form_pg_constraint	con = (Form_pg_constraint) GETSTRUCT(tup);
+	const char	*nsp;
+	AttrNumber	attnum;
+
+	Assert(con->contype == CONSTRAINT_NOTNULL);
+
+	nsp = get_namespace_name(relid_dst);
+	dump_constraint_common(nsp, relname_dst, con, buf);
+
+	attnum = extractNotNullColumn(tup);
+
+	appendStringInfo(buf, "NOT NULL %s",
+					 quote_identifier(get_attname(con->conrelid,
+												  attnum, false)));
+	if (((Form_pg_constraint) GETSTRUCT(tup))->connoinherit)
+		appendStringInfoString(buf, " NO INHERIT");
+
+}
+#endif
+
 static void
 dump_constraint_common(const char *nsp, const char *relname,
 					   Form_pg_constraint con, StringInfo buf)