Allow row comparisons to be used as indexscan qualifications.

This completes the project to upgrade our handling of row comparisons.

src/backend/access/nbtree/nbtsearch.c

@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.101 2006/01/23 22:31:40 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.102 2006/01/25 20:29:23 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -551,6 +551,10 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	 * one we use --- by definition, they are either redundant or
 	 * contradictory.
 	 *
+	 * In this loop, row-comparison keys are treated the same as keys on their
+	 * first (leftmost) columns.  We'll add on lower-order columns of the row
+	 * comparison below, if possible.
+	 *
 	 * The selected scan keys (at most one per index column) are remembered by
 	 * storing their addresses into the local startKeys[] array.
 	 *----------
@@ -657,25 +661,71 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	{
 		ScanKey		cur = startKeys[i];
 
+		Assert(cur->sk_attno == i+1);
+
+		if (cur->sk_flags & SK_ROW_HEADER)
+		{
 			/*
-		 * _bt_preprocess_keys disallows it, but it's place to add some code
-		 * later
+			 * Row comparison header: look to the first row member instead.
+			 *
+			 * The member scankeys are already in insertion format (ie, they
+			 * have sk_func = 3-way-comparison function), but we have to
+			 * watch out for nulls, which _bt_preprocess_keys didn't check.
+			 * A null in the first row member makes the condition unmatchable,
+			 * just like qual_ok = false.
 			 */
+			cur = (ScanKey) DatumGetPointer(cur->sk_argument);
+			Assert(cur->sk_flags & SK_ROW_MEMBER);
 			if (cur->sk_flags & SK_ISNULL)
-			elog(ERROR, "btree doesn't support is(not)null, yet");
-
+				return false;
+			memcpy(scankeys + i, cur, sizeof(ScanKeyData));
+			/*
+			 * If the row comparison is the last positioning key we accepted,
+			 * try to add additional keys from the lower-order row members.
+			 * (If we accepted independent conditions on additional index
+			 * columns, we use those instead --- doesn't seem worth trying to
+			 * determine which is more restrictive.)  Note that this is OK
+			 * even if the row comparison is of ">" or "<" type, because the
+			 * condition applied to all but the last row member is effectively
+			 * ">=" or "<=", and so the extra keys don't break the positioning
+			 * scheme.
+			 */
+			if (i == keysCount - 1)
+			{
+				while (!(cur->sk_flags & SK_ROW_END))
+				{
+					cur++;
+					Assert(cur->sk_flags & SK_ROW_MEMBER);
+					if (cur->sk_attno != keysCount + 1)
+						break;	/* out-of-sequence, can't use it */
+					if (cur->sk_flags & SK_ISNULL)
+						break;	/* can't use null keys */
+					Assert(keysCount < INDEX_MAX_KEYS);
+					memcpy(scankeys + keysCount, cur, sizeof(ScanKeyData));
+					keysCount++;
+				}
+				break;			/* done with outer loop */
+			}
+		}
+		else
+		{
 			/*
-		 * If scankey operator is of default subtype, we can use the cached
-		 * comparison procedure; otherwise gotta look it up in the catalogs.
+			 * Ordinary comparison key.  Transform the search-style scan key
+			 * to an insertion scan key by replacing the sk_func with the
+			 * appropriate btree comparison function.
+			 *
+			 * If scankey operator is of default subtype, we can use the
+			 * cached comparison function; otherwise gotta look it up in the
+			 * catalogs.
 			 */
 			if (cur->sk_subtype == InvalidOid)
 			{
 				FmgrInfo   *procinfo;
 
-			procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+				procinfo = index_getprocinfo(rel, cur->sk_attno, BTORDER_PROC);
 				ScanKeyEntryInitializeWithInfo(scankeys + i,
 											   cur->sk_flags,
-										   i + 1,
+											   cur->sk_attno,
 											   InvalidStrategy,
 											   InvalidOid,
 											   procinfo,
@@ -690,13 +740,14 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 											BTORDER_PROC);
 				ScanKeyEntryInitialize(scankeys + i,
 									   cur->sk_flags,
-								   i + 1,
+									   cur->sk_attno,
 									   InvalidStrategy,
 									   cur->sk_subtype,
 									   cmp_proc,
 									   cur->sk_argument);
 			}
 		}
+	}
 
 	/*----------
 	 * Examine the selected initial-positioning strategy to determine exactly

src/backend/executor/nodeBitmapIndexscan.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/executor/nodeBitmapIndexscan.c,v 1.14 2005/12/03 05:51:01 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/executor/nodeBitmapIndexscan.c,v 1.15 2006/01/25 20:29:23 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -244,6 +244,20 @@ ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate)
 
 #define BITMAPINDEXSCAN_NSLOTS 0
 
+	/*
+	 * We do not open or lock the base relation here.  We assume that an
+	 * ancestor BitmapHeapScan node is holding AccessShareLock (or better)
+	 * on the heap relation throughout the execution of the plan tree.
+	 */
+
+	indexstate->ss.ss_currentRelation = NULL;
+	indexstate->ss.ss_currentScanDesc = NULL;
+
+	/*
+	 * Open the index relation.
+	 */
+	indexstate->biss_RelationDesc = index_open(node->indexid);
+
 	/*
 	 * Initialize index-specific scan state
 	 */
@@ -255,6 +269,7 @@ ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate)
 	 * build the index scan keys from the index qualification
 	 */
 	ExecIndexBuildScanKeys((PlanState *) indexstate,
+						   indexstate->biss_RelationDesc,
 						   node->indexqual,
 						   node->indexstrategy,
 						   node->indexsubtype,
@@ -286,16 +301,8 @@ ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate)
 	}
 
 	/*
-	 * We do not open or lock the base relation here.  We assume that an
-	 * ancestor BitmapHeapScan node is holding AccessShareLock (or better)
-	 * on the heap relation throughout the execution of the plan tree.
-	 */
-
-	indexstate->ss.ss_currentRelation = NULL;
-	indexstate->ss.ss_currentScanDesc = NULL;
-
-	/*
-	 * Open the index relation and initialize relation and scan descriptors.
+	 * Initialize scan descriptor.
+	 *
 	 * Note we acquire no locks here; the index machinery does its own locks
 	 * and unlocks.  (We rely on having a lock on the parent table to
 	 * ensure the index won't go away!)  Furthermore, if the parent table
@@ -303,7 +310,6 @@ ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate)
 	 * opened and write-locked the index, so we can tell the index machinery
 	 * not to bother getting an extra lock.
 	 */
-	indexstate->biss_RelationDesc = index_open(node->indexid);
 	relistarget = ExecRelationIsTargetRelation(estate, node->scan.scanrelid);
 	indexstate->biss_ScanDesc =
 		index_beginscan_multi(indexstate->biss_RelationDesc,

src/backend/optimizer/plan/createplan.c

@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.205 2005/11/26 22:14:56 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.206 2006/01/25 20:29:23 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1583,7 +1583,7 @@ fix_indexqual_references(List *indexquals, IndexPath *index_path,
 			 * (only) the base relation.
 			 */
 			if (!bms_equal(rinfo->left_relids, index->rel->relids))
-				CommuteClause(op);
+				CommuteOpExpr(op);
 
 			/*
 			 * Now, determine which index attribute this is, change the
@@ -1594,6 +1594,41 @@ fix_indexqual_references(List *indexquals, IndexPath *index_path,
 													   &opclass);
 			clause_op = op->opno;
 		}
+		else if (IsA(clause, RowCompareExpr))
+		{
+			RowCompareExpr *rc = (RowCompareExpr *) clause;
+			ListCell *lc;
+
+			/*
+			 * Check to see if the indexkey is on the right; if so, commute
+			 * the clause. The indexkey should be the side that refers to
+			 * (only) the base relation.
+			 */
+			if (!bms_overlap(pull_varnos(linitial(rc->largs)),
+							 index->rel->relids))
+				CommuteRowCompareExpr(rc);
+
+			/*
+			 * For each column in the row comparison, determine which index
+			 * attribute this is and change the indexkey operand as needed.
+			 *
+			 * Save the index opclass for only the first column.  We will
+			 * return the operator and opclass info for just the first
+			 * column of the row comparison; the executor will have to
+			 * look up the rest if it needs them.
+			 */
+			foreach(lc, rc->largs)
+			{
+				Oid		tmp_opclass;
+
+				lfirst(lc) = fix_indexqual_operand(lfirst(lc),
+												   index,
+												   &tmp_opclass);
+				if (lc == list_head(rc->largs))
+					opclass = tmp_opclass;
+			}
+			clause_op = linitial_oid(rc->opnos);
+		}
 		else if (IsA(clause, ScalarArrayOpExpr))
 		{
 			ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) clause;
@@ -1745,7 +1780,7 @@ get_switched_clauses(List *clauses, Relids outerrelids)
 			temp->opretset = clause->opretset;
 			temp->args = list_copy(clause->args);
 			/* Commute it --- note this modifies the temp node in-place. */
-			CommuteClause(temp);
+			CommuteOpExpr(temp);
 			t_list = lappend(t_list, temp);
 		}
 		else

src/backend/optimizer/util/clauses.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.205 2005/12/28 01:30:00 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.206 2006/01/25 20:29:23 tgl Exp $
  *
  * HISTORY
  *	  AUTHOR			DATE			MAJOR EVENT
@@ -1167,12 +1167,12 @@ NumRelids(Node *clause)
 }
 
 /*
- * CommuteClause: commute a binary operator clause
+ * CommuteOpExpr: commute a binary operator clause
  *
  * XXX the clause is destructively modified!
  */
 void
-CommuteClause(OpExpr *clause)
+CommuteOpExpr(OpExpr *clause)
 {
 	Oid			opoid;
 	Node	   *temp;
@@ -1200,6 +1200,73 @@ CommuteClause(OpExpr *clause)
 	lsecond(clause->args) = temp;
 }
 
+/*
+ * CommuteRowCompareExpr: commute a RowCompareExpr clause
+ *
+ * XXX the clause is destructively modified!
+ */
+void
+CommuteRowCompareExpr(RowCompareExpr *clause)
+{
+	List	   *newops;
+	List	   *temp;
+	ListCell   *l;
+
+	/* Sanity checks: caller is at fault if these fail */
+	if (!IsA(clause, RowCompareExpr))
+		elog(ERROR, "expected a RowCompareExpr");
+
+	/* Build list of commuted operators */
+	newops = NIL;
+	foreach(l, clause->opnos)
+	{
+		Oid			opoid = lfirst_oid(l);
+
+		opoid = get_commutator(opoid);
+		if (!OidIsValid(opoid))
+			elog(ERROR, "could not find commutator for operator %u",
+				 lfirst_oid(l));
+		newops = lappend_oid(newops, opoid);
+	}
+
+	/*
+	 * modify the clause in-place!
+	 */
+	switch (clause->rctype)
+	{
+		case ROWCOMPARE_LT:
+			clause->rctype = ROWCOMPARE_GT;
+			break;
+		case ROWCOMPARE_LE:
+			clause->rctype = ROWCOMPARE_GE;
+			break;
+		case ROWCOMPARE_GE:
+			clause->rctype = ROWCOMPARE_LE;
+			break;
+		case ROWCOMPARE_GT:
+			clause->rctype = ROWCOMPARE_LT;
+			break;
+		default:
+			elog(ERROR, "unexpected RowCompare type: %d",
+				 (int) clause->rctype);
+			break;
+	}
+
+	clause->opnos = newops;
+	/*
+	 * Note: we don't bother to update the opclasses list, but just set
+	 * it to empty.  This is OK since this routine is currently only used
+	 * for index quals, and the index machinery won't use the opclass
+	 * information.  The original opclass list is NOT valid if we have
+	 * commuted any cross-type comparisons, so don't leave it in place.
+	 */
+	clause->opclasses = NIL;	/* XXX */
+
+	temp = clause->largs;
+	clause->largs = clause->rargs;
+	clause->rargs = temp;
+}
+
 /*
  * strip_implicit_coercions: remove implicit coercions at top level of tree
  *

src/backend/utils/adt/selfuncs.c

@@ -15,7 +15,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.196 2006/01/14 00:14:11 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.197 2006/01/25 20:29:24 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -4657,6 +4657,9 @@ btcostestimate(PG_FUNCTION_ARGS)
 	 * to find out which ones count as boundary quals.	We rely on the
 	 * knowledge that they are given in index column order.
 	 *
+	 * For a RowCompareExpr, we consider only the first column, just as
+	 * rowcomparesel() does.
+	 *
 	 * If there's a ScalarArrayOpExpr in the quals, we'll actually perform
 	 * N index scans not one, but the ScalarArrayOpExpr's operator can be
 	 * considered to act the same as it normally does.
@@ -4682,6 +4685,14 @@ btcostestimate(PG_FUNCTION_ARGS)
 			rightop = get_rightop(clause);
 			clause_op = ((OpExpr *) clause)->opno;
 		}
+		else if (IsA(clause, RowCompareExpr))
+		{
+			RowCompareExpr *rc = (RowCompareExpr *) clause;
+
+			leftop = (Node *) linitial(rc->largs);
+			rightop = (Node *) linitial(rc->rargs);
+			clause_op = linitial_oid(rc->opnos);
+		}
 		else if (IsA(clause, ScalarArrayOpExpr))
 		{
 			ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) clause;

src/include/access/skey.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/access/skey.h,v 1.30 2006/01/14 22:03:35 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/access/skey.h,v 1.31 2006/01/25 20:29:24 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -69,6 +69,36 @@ typedef struct ScanKeyData
 
 typedef ScanKeyData *ScanKey;
 
+/*
+ * About row comparisons:
+ *
+ * The ScanKey data structure also supports row comparisons, that is ordered
+ * tuple comparisons like (x, y) > (c1, c2), having the SQL-spec semantics
+ * "x > c1 OR (x = c1 AND y > c2)".  Note that this is currently only
+ * implemented for btree index searches, not for heapscans or any other index
+ * type.  A row comparison is represented by a "header" ScanKey entry plus
+ * a separate array of ScanKeys, one for each column of the row comparison.
+ * The header entry has these properties:
+ *		sk_flags = SK_ROW_HEADER
+ *		sk_attno = index column number for leading column of row comparison
+ *		sk_strategy = btree strategy code for semantics of row comparison
+ *				(ie, < <= > or >=)
+ *		sk_subtype, sk_func: not used
+ *		sk_argument: pointer to subsidiary ScanKey array
+ * If the header is part of a ScanKey array that's sorted by attno, it
+ * must be sorted according to the leading column number.
+ *
+ * The subsidiary ScanKey array appears in logical column order of the row
+ * comparison, which may be different from index column order.  The array
+ * elements are like a normal ScanKey array except that:
+ *		sk_flags must include SK_ROW_MEMBER, plus SK_ROW_END in the last
+ *				element (needed since row header does not include a count)
+ *		sk_func points to the btree comparison support function for the
+ *				opclass, NOT the operator's implementation function.
+ * sk_strategy must be the same in all elements of the subsidiary array,
+ * that is, the same as in the header entry.
+ */
+
 /*
  * ScanKeyData sk_flags
  *
@@ -78,6 +108,9 @@ typedef ScanKeyData *ScanKey;
  */
 #define SK_ISNULL		0x0001	/* sk_argument is NULL */
 #define SK_UNARY		0x0002	/* unary operator (currently unsupported) */
+#define SK_ROW_HEADER	0x0004	/* row comparison header (see above) */
+#define SK_ROW_MEMBER	0x0008	/* row comparison member (see above) */
+#define SK_ROW_END		0x0010	/* last row comparison member (see above) */
 
 
 /*

src/include/executor/nodeIndexscan.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/executor/nodeIndexscan.h,v 1.25 2005/11/25 19:47:50 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/executor/nodeIndexscan.h,v 1.26 2006/01/25 20:29:24 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -25,8 +25,8 @@ extern void ExecIndexRestrPos(IndexScanState *node);
 extern void ExecIndexReScan(IndexScanState *node, ExprContext *exprCtxt);
 
 /* routines exported to share code with nodeBitmapIndexscan.c */
-extern void ExecIndexBuildScanKeys(PlanState *planstate, List *quals,
-					   List *strategies, List *subtypes,
+extern void ExecIndexBuildScanKeys(PlanState *planstate, Relation index,
+					   List *quals, List *strategies, List *subtypes,
 					   ScanKey *scanKeys, int *numScanKeys,
 					   IndexRuntimeKeyInfo **runtimeKeys, int *numRuntimeKeys,
 					   IndexArrayKeyInfo **arrayKeys, int *numArrayKeys);

src/include/optimizer/clauses.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/optimizer/clauses.h,v 1.81 2005/12/20 02:30:36 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/optimizer/clauses.h,v 1.82 2006/01/25 20:29:24 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -67,7 +67,9 @@ extern bool has_distinct_clause(Query *query);
 extern bool has_distinct_on_clause(Query *query);
 
 extern int	NumRelids(Node *clause);
-extern void CommuteClause(OpExpr *clause);
+
+extern void CommuteOpExpr(OpExpr *clause);
+extern void CommuteRowCompareExpr(RowCompareExpr *clause);
 
 extern Node *strip_implicit_coercions(Node *node);