Don't trust deferred-unique indexes for join removal.

The uniqueness condition might fail to hold intra-transaction, and assuming
it does can give incorrect query results.  Per report from Marti Raudsepp,
though this is not his proposed patch.

Back-patch to 9.0, where both these features were introduced.  In the
released branches, add the new IndexOptInfo field to the end of the struct,
to try to minimize ABI breakage for third-party code that may be examining
that struct.

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 681f5f85bc740ba6ab1922941eaac6e58bb5e0b3..96b09fbce7183304b9f34b47ba62028c851ffd71 100644 (file)
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -1764,6 +1764,7 @@ _outIndexOptInfo(StringInfo str, IndexOptInfo *node)
        WRITE_NODE_FIELD(indpred);
        WRITE_BOOL_FIELD(predOK);
        WRITE_BOOL_FIELD(unique);
+       WRITE_BOOL_FIELD(immediate);
        WRITE_BOOL_FIELD(hypothetical);
 }
 

diff --git a/src/backend/optimizer/path/indxpath.c b/src/backend/optimizer/path/indxpath.c
index fc96f4f1dacb7d5fa0beda76ed945685f0186659..58b8797b7383cadc1bb4da235773449570a073bb 100644 (file)
--- a/src/backend/optimizer/path/indxpath.c
+++ b/src/backend/optimizer/path/indxpath.c
@@ -2179,10 +2179,11 @@ relation_has_unique_index_for(PlannerInfo *root, RelOptInfo *rel,
                int                     c;
 
                /*
-                * If the index is not unique or if it's a partial index that doesn't
-                * match the query, it's useless here.
+                * If the index is not unique, or not immediately enforced, or if it's
+                * a partial index that doesn't match the query, it's useless here.
                 */
-               if (!ind->unique || (ind->indpred != NIL && !ind->predOK))
+               if (!ind->unique || !ind->immediate ||
+                       (ind->indpred != NIL && !ind->predOK))
                        continue;
 
                /*

diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 513b6e4d7400a3b6821e385610b2df74402364ca..a92d24852898145dd4d2b4a4d0f3667b4abda5c1 100644 (file)
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -316,6 +316,7 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
                                ChangeVarNodes((Node *) info->indpred, 1, varno, 0);
                        info->predOK = false;           /* set later in indxpath.c */
                        info->unique = index->indisunique;
+                       info->immediate = index->indimmediate;
                        info->hypothetical = false;
 
                        /*
@@ -973,6 +974,11 @@ join_selectivity(PlannerInfo *root,
  * Detect whether there is a unique index on the specified attribute
  * of the specified relation, thus allowing us to conclude that all
  * the (non-null) values of the attribute are distinct.
+ *
+ * This function does not check the index's indimmediate property, which
+ * means that uniqueness may transiently fail to hold intra-transaction.
+ * That's appropriate when we are making statistical estimates, but beware
+ * of using this for any correctness proofs.
  */
 bool
 has_unique_index(RelOptInfo *rel, AttrNumber attno)

diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c
index 8e304097db8fc6cbfd622ea3161f682eee83c718..7a42ff03466a66b12f351393f465c5961cdc2b0b 100644 (file)
--- a/src/backend/utils/adt/selfuncs.c
+++ b/src/backend/utils/adt/selfuncs.c
@@ -4121,7 +4121,9 @@ get_join_variables(PlannerInfo *root, List *args, SpecialJoinInfo *sjinfo,
  *             commonly the same as the exposed type of the variable argument,
  *             but can be different in binary-compatible-type cases.
  *     isunique: TRUE if we were able to match the var to a unique index,
- *             implying its values are unique for this query.
+ *             implying its values are unique for this query.  (Caution: this
+ *             should be trusted for statistical purposes only, since we do not
+ *             check indimmediate.)
  *
  * Caller is responsible for doing ReleaseVariableStats() before exiting.
  */

diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index f6592697e44557d2b0850a3bcea0de7d4507df83..0aec1637c93b1da6e112b59d4a8fbb5e3de1c763 100644 (file)
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -491,6 +491,9 @@ typedef struct IndexOptInfo
        bool            amsearchnulls;  /* can AM search for NULL/NOT NULL entries? */
        bool            amhasgettuple;  /* does AM have amgettuple interface? */
        bool            amhasgetbitmap; /* does AM have amgetbitmap interface? */
+
+       /* Added at end of struct to avoid ABI breakage in released branches */
+       bool            immediate;              /* is uniqueness enforced immediately? */
 } IndexOptInfo;