Fix failure to enforce partitioning contraint for internal partitions.

When a tuple is inherited into a partitioning root, no partition
constraints need to be enforced; when it is inserted into a leaf, the
parent's partitioning quals needed to be enforced.  The previous
coding got both of those cases right.  When a tuple is inserted into
an intermediate level of the partitioning hierarchy (i.e. a table
which is both a partition itself and in turn partitioned), it must
enforce the partitioning qual inherited from its parent.  That case
got overlooked; repair.

Amit Langote

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 1fd2162794832c76d8c2f0e275724d0cd7cf4b07..75386212e0696fc6bb9596e5265c595fc1c64332 100644 (file)
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2432,7 +2432,6 @@ CopyFrom(CopyState cstate)
    InitResultRelInfo(resultRelInfo,
                      cstate->rel,
                      1,        /* dummy rangetable index */
-                     true,     /* do load partition check expression */
                      NULL,
                      0);
 

diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index e633a50dd2db4f08f3edb7b05273bd9648e4992b..06e43cbb3a273efb9127d65d253adedd91dee59d 100644 (file)
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -1324,7 +1324,6 @@ ExecuteTruncate(TruncateStmt *stmt)
        InitResultRelInfo(resultRelInfo,
                          rel,
                          0,    /* dummy rangetable index */
-                         false,
                          NULL,
                          0);
        resultRelInfo++;

diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index ff277d300a8d553fe6c8cc3aad047bb6988a8cb2..5457f8fbde5d9455514cf7d117737edb516b4790 100644 (file)
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -824,10 +824,10 @@ InitPlan(QueryDesc *queryDesc, int eflags)
 
            resultRelationOid = getrelid(resultRelationIndex, rangeTable);
            resultRelation = heap_open(resultRelationOid, RowExclusiveLock);
+
            InitResultRelInfo(resultRelInfo,
                              resultRelation,
                              resultRelationIndex,
-                             true,
                              NULL,
                              estate->es_instrument);
            resultRelInfo++;
@@ -1218,10 +1218,11 @@ void
 InitResultRelInfo(ResultRelInfo *resultRelInfo,
                  Relation resultRelationDesc,
                  Index resultRelationIndex,
-                 bool load_partition_check,
                  Relation partition_root,
                  int instrument_options)
 {
+   List   *partition_check = NIL;
+
    MemSet(resultRelInfo, 0, sizeof(ResultRelInfo));
    resultRelInfo->type = T_ResultRelInfo;
    resultRelInfo->ri_RangeTableIndex = resultRelationIndex;
@@ -1257,13 +1258,38 @@ InitResultRelInfo(ResultRelInfo *resultRelInfo,
    resultRelInfo->ri_ConstraintExprs = NULL;
    resultRelInfo->ri_junkFilter = NULL;
    resultRelInfo->ri_projectReturning = NULL;
-   if (load_partition_check)
-       resultRelInfo->ri_PartitionCheck =
-                           RelationGetPartitionQual(resultRelationDesc);
+
    /*
-    * The following gets set to NULL unless we are initializing leaf
-    * partitions for tuple-routing.
+    * If partition_root has been specified, that means we are builiding the
+    * ResultRelationInfo for one of its leaf partitions.  In that case, we
+    * need *not* initialize the leaf partition's constraint, but rather the
+    * the partition_root's (if any).  We must do that explicitly like this,
+    * because implicit partition constraints are not inherited like user-
+    * defined constraints and would fail to be enforced by ExecConstraints()
+    * after a tuple is routed to a leaf partition.
     */
+   if (partition_root)
+   {
+       /*
+        * Root table itself may or may not be a partition; partition_check
+        * would be NIL in the latter case.
+        */
+       partition_check = RelationGetPartitionQual(partition_root);
+
+       /*
+        * This is not our own partition constraint, but rather an ancestor's.
+        * So any Vars in it bear the ancestor's attribute numbers.  We must
+        * switch them to our own.
+        */
+       if (partition_check != NIL)
+           partition_check = map_partition_varattnos(partition_check,
+                                                     resultRelationDesc,
+                                                     partition_root);
+   }
+   else
+       partition_check = RelationGetPartitionQual(resultRelationDesc);
+
+   resultRelInfo->ri_PartitionCheck = partition_check;
    resultRelInfo->ri_PartitionRoot = partition_root;
 }
 
@@ -1327,7 +1353,6 @@ ExecGetTriggerResultRel(EState *estate, Oid relid)
    InitResultRelInfo(rInfo,
                      rel,
                      0,        /* dummy rangetable index */
-                     true,
                      NULL,
                      estate->es_instrument);
    estate->es_trig_target_relations =
@@ -3132,7 +3157,6 @@ ExecSetupPartitionTupleRouting(Relation rel,
        InitResultRelInfo(leaf_part_rri,
                          partrel,
                          1,     /* dummy */
-                         false,
                          rel,
                          0);
 

diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index d424031676f966f7f056c1d328abe78f63663d16..eb180fdb631bb72ebf064e88358b3575dd0a6917 100644 (file)
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -189,7 +189,6 @@ extern void CheckValidResultRel(Relation resultRel, CmdType operation);
 extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
                  Relation resultRelationDesc,
                  Index resultRelationIndex,
-                 bool load_partition_check,
                  Relation partition_root,
                  int instrument_options);
 extern ResultRelInfo *ExecGetTriggerResultRel(EState *estate, Oid relid);

diff --git a/src/test/regress/expected/insert.out b/src/test/regress/expected/insert.out
index 0382560d3950a2dbe1719d2e13bf75bf66a1db6a..729d9ebbbc6286e3687c0899cc41cdaf43e956b6 100644 (file)
--- a/src/test/regress/expected/insert.out
+++ b/src/test/regress/expected/insert.out
@@ -358,5 +358,11 @@ alter table p add constraint check_b check (b = 3);
 insert into p values (1, 2);
 ERROR:  new row for relation "p11" violates check constraint "check_b"
 DETAIL:  Failing row contains (1, 2).
+-- check that inserting into an internal partition successfully results in
+-- checking its partition constraint before inserting into the leaf partition
+-- selected by tuple-routing
+insert into p1 (a, b) values (2, 3);
+ERROR:  new row for relation "p11" violates partition constraint
+DETAIL:  Failing row contains (3, 2).
 -- cleanup
 drop table p, p1, p11;

diff --git a/src/test/regress/sql/insert.sql b/src/test/regress/sql/insert.sql
index a6eab8f36566d0d536cc8238c55f3d4c2c3f8767..5509555fc578b4f49592d428153c66fd562dff72 100644 (file)
--- a/src/test/regress/sql/insert.sql
+++ b/src/test/regress/sql/insert.sql
@@ -221,5 +221,10 @@ alter table p add constraint check_b check (b = 3);
 -- after "(1, 2)" is routed to it
 insert into p values (1, 2);
 
+-- check that inserting into an internal partition successfully results in
+-- checking its partition constraint before inserting into the leaf partition
+-- selected by tuple-routing
+insert into p1 (a, b) values (2, 3);
+
 -- cleanup
 drop table p, p1, p11;