Ordering by key works for partial, regular and full scan

Author: za-arthur

src/btree_rum.c

@@ -322,7 +322,38 @@ rum_##type##_outer_distance(PG_FUNCTION_ARGS)								\
 									   PG_GETARG_DATUM(1));					\
 			break;															\
 		default:															\
-			elog(ERROR, "rum_outer_distance_%s: unknown strategy %u",		\
+			elog(ERROR, "rum_%s_outer_distance: unknown strategy %u",		\
+						#type, strategy);									\
+	}																		\
+																			\
+	PG_RETURN_DATUM(diff);													\
+}																			\
+PG_FUNCTION_INFO_V1(rum_##type##_key_distance);								\
+Datum																		\
+rum_##type##_key_distance(PG_FUNCTION_ARGS)									\
+{																			\
+	StrategyNumber	strategy = PG_GETARG_UINT16(3);							\
+	Datum			diff;													\
+																			\
+	switch (strategy)														\
+	{																		\
+		case RUM_DISTANCE:													\
+			diff = DirectFunctionCall2(rum_##type##_distance,				\
+									   PG_GETARG_DATUM(2),					\
+									   PG_GETARG_DATUM(4));					\
+			break;															\
+		case RUM_LEFT_DISTANCE:												\
+			diff = DirectFunctionCall2(rum_##type##_left_distance,			\
+									   PG_GETARG_DATUM(2),					\
+									   PG_GETARG_DATUM(4));					\
+			break;															\
+		case RUM_RIGHT_DISTANCE:											\
+			diff = DirectFunctionCall2(rum_##type##_right_distance,			\
+									   PG_GETARG_DATUM(2),					\
+									   PG_GETARG_DATUM(4));					\
+			break;															\
+		default:															\
+			elog(ERROR, "rum_%s_key_distance: unknown strategy %u",			\
 						#type, strategy);									\
 	}																		\
 																			\

src/rum.h

@@ -553,6 +553,13 @@ extern void rumPrepareDataScan(RumBtree btree, Relation index, OffsetNumber attn
 
 /* rumscan.c */
 
+typedef struct RumScanItem
+{
+	RumItem		item;
+	Datum		keyValue;
+	RumNullCategory keyCategory;
+}	RumScanItem;
+
 /*
  * RumScanKeyData describes a single RUM index qualifier expression.
  *
@@ -656,7 +663,7 @@ typedef struct RumScanEntryData
 	 * and additional information here
 	 */
 	Tuplesortstate *matchSortstate;
-	RumItem		collectRumItem;
+	RumScanItem	collectRumItem;
 
 	/* for full-scan query with order-by */
 	RumBtreeStack *stack;

src/rum_ts_utils.c

@@ -1412,7 +1412,7 @@ rum_tsquery_distance(PG_FUNCTION_ARGS)
 	bool	   *check = (bool *) PG_GETARG_POINTER(0);
 
 	/* RumNullCategory keyCategory = PG_GETARG_CHAR(1); */
-	/* Datum	   key = PG_GETARG_DATUM(2); */
+	/* Datum		key = PG_GETARG_DATUM(2); */
 	TSQuery		query = PG_GETARG_TSQUERY(4);
 	int			nkeys = PG_GETARG_INT32(5);
 	Pointer	   *extra_data = (Pointer *) PG_GETARG_POINTER(6);

src/rumget.c

@@ -31,6 +31,34 @@ static void insertScanItem(RumScanOpaque so, bool recheck);
 static int	scan_entry_cmp(const void *p1, const void *p2, void *arg);
 static void entryGetItem(RumState * rumstate, RumScanEntry entry, bool *nextEntryList);
 
+/*
+ * Extract key value for ordering.
+ *
+ * XXX FIXME only pass-by-value!!! Value should be copied to
+ * long-lived memory context and, somehow, freeed. Seems, the
+ * last is real problem.
+ */
+#define SCAN_ENTRY_GET_KEY(entry, rumstate, itup)							\
+do {																		\
+	if ((entry)->useCurKey)													\
+		(entry)->curKey = rumtuple_get_key(rumstate, itup, &(entry)->curKeyCategory); \
+} while(0)
+
+/*
+ * Assign key value for ordering.
+ *
+ * XXX FIXME only pass-by-value!!! Value should be copied to
+ * long-lived memory context and, somehow, freeed. Seems, the
+ * last is real problem.
+ */
+#define SCAN_ITEM_PUT_KEY(entry, item, key, category)						\
+do {																		\
+	if ((entry)->useCurKey)													\
+	{																		\
+		(item).keyValue = key;												\
+		(item).keyCategory = category;										\
+	}																		\
+} while(0)
 
 static bool
 callAddInfoConsistentFn(RumState * rumstate, RumScanKey key)
@@ -151,23 +179,6 @@ callConsistentFn(RumState * rumstate, RumScanKey key)
 	return res && callAddInfoConsistentFn(rumstate, key);
 }
 
-/*
- * Extract key value for ordering
- */
-static void
-scanEntryGetKey(RumScanEntry entry, RumState *rumstate, IndexTuple itup)
-{
-	if (entry->useCurKey == false)
-		return;
-
-	/*
-	 * XXX FIXME only pass-by-value!!! Value should be copied to
-	 * long-lived memory context and, somehow, freeed. Seems, the
-	 * last is real problem.
-	 */
-	entry->curKey = rumtuple_get_key(rumstate, itup, &entry->curKeyCategory);
-}
-
 /*
  * Goes to the next page if current offset is outside of bounds
  */
@@ -199,7 +210,8 @@ moveRightIfItNeeded(RumBtreeData * btree, RumBtreeStack * stack)
  */
 static void
 scanPostingTree(Relation index, RumScanEntry scanEntry,
-	   BlockNumber rootPostingTree, OffsetNumber attnum, RumState * rumstate)
+				BlockNumber rootPostingTree, OffsetNumber attnum,
+				RumState * rumstate, Datum idatum, RumNullCategory icategory)
 {
 	RumPostingTreeScan *gdi;
 	Buffer		buffer;
@@ -230,15 +242,16 @@ scanPostingTree(Relation index, RumScanEntry scanEntry,
 		if ((RumPageGetOpaque(page)->flags & RUM_DELETED) == 0 &&
 			maxoff >= FirstOffsetNumber)
 		{
-			RumItem		item;
+			RumScanItem	item;
 			Pointer		ptr;
 
-			ItemPointerSetMin(&item.iptr);
+			ItemPointerSetMin(&item.item.iptr);
 
 			ptr = RumDataPageGetData(page);
 			for (i = FirstOffsetNumber; i <= maxoff; i++)
 			{
-				ptr = rumDataPageLeafRead(ptr, attnum, &item, rumstate);
+				ptr = rumDataPageLeafRead(ptr, attnum, &item.item, rumstate);
+				SCAN_ITEM_PUT_KEY(scanEntry, item, idatum, icategory);
 				rum_tuplesort_putrumitem(scanEntry->matchSortstate, &item);
 			}
 
@@ -387,7 +400,8 @@ collectMatchBitmap(RumBtreeData * btree, RumBtreeStack * stack,
 			LockBuffer(stack->buffer, RUM_UNLOCK);
 
 			/* Collect all the TIDs in this entry's posting tree */
-			scanPostingTree(btree->index, scanEntry, rootPostingTree, attnum, rumstate);
+			scanPostingTree(btree->index, scanEntry, rootPostingTree, attnum,
+							rumstate, idatum, icategory);
 
 			/*
 			 * We lock again the entry page and while it was unlocked insert
@@ -437,13 +451,14 @@ collectMatchBitmap(RumBtreeData * btree, RumBtreeStack * stack,
 		{
 			int	i;
 			char	*ptr = RumGetPosting(itup);
-			RumItem	item;
+			RumScanItem item;
 
-			ItemPointerSetMin(&item.iptr);
+			ItemPointerSetMin(&item.item.iptr);
 			for (i = 0; i < RumGetNPosting(itup); i++)
 			{
-				ptr = rumDataPageLeafRead(ptr, scanEntry->attnum, &item,
+				ptr = rumDataPageLeafRead(ptr, scanEntry->attnum, &item.item,
 										  rumstate);
+				SCAN_ITEM_PUT_KEY(scanEntry, item, idatum, icategory);
 				rum_tuplesort_putrumitem(scanEntry->matchSortstate, &item);
 			}
 
@@ -576,7 +591,7 @@ startScanEntry(RumState * rumstate, RumScanEntry entry)
 		if (entry->matchSortstate)
 		{
 			rum_tuplesort_performsort(entry->matchSortstate);
-			ItemPointerSetMin(&entry->collectRumItem.iptr);
+			ItemPointerSetMin(&entry->collectRumItem.item.iptr);
 			entry->isFinished = FALSE;
 		}
 	}
@@ -659,7 +674,7 @@ startScanEntry(RumState * rumstate, RumScanEntry entry)
 			entry->scanWithAddInfo)
 			entry->stack = stackEntry;
 
-		scanEntryGetKey(entry, rumstate, itup);
+		SCAN_ENTRY_GET_KEY(entry, rumstate, itup);
 	}
 
 	if (needUnlock)
@@ -1066,7 +1081,7 @@ entryGetNextItemList(RumState * rumstate, RumScanEntry entry)
 	entry->curItem = entry->list[entry->offset];
 	entry->offset += entry->scanDirection;
 
-	scanEntryGetKey(entry, rumstate, itup);
+	SCAN_ENTRY_GET_KEY(entry, rumstate, itup);
 
 	/*
 	 * Done with this entry, go to the next for the future.
@@ -1102,11 +1117,11 @@ entryGetItem(RumState * rumstate, RumScanEntry entry, bool *nextEntryList)
 
 		do
 		{
-			RumItem	collected;
-			RumItem	*current_collected;
+			RumScanItem	collected;
+			RumScanItem *current_collected;
 
 			/* We are finished, but should return last result */
-			if (ItemPointerIsMax(&entry->collectRumItem.iptr))
+			if (ItemPointerIsMax(&entry->collectRumItem.item.iptr))
 			{
 				entry->isFinished = TRUE;
 				rum_tuplesort_end(entry->matchSortstate);
@@ -1115,10 +1130,10 @@ entryGetItem(RumState * rumstate, RumScanEntry entry, bool *nextEntryList)
 			}
 
 			/* collectRumItem could store the begining of current result */
-			if (!ItemPointerIsMin(&entry->collectRumItem.iptr))
+			if (!ItemPointerIsMin(&entry->collectRumItem.item.iptr))
 				collected = entry->collectRumItem;
 			else
-				ItemPointerSetMin(&collected.iptr);
+				ItemPointerSetMin(&collected.item.iptr);
 
 			ItemPointerSetMin(&entry->curItem.iptr);
 
@@ -1133,60 +1148,76 @@ entryGetItem(RumState * rumstate, RumScanEntry entry, bool *nextEntryList)
 
 				if (current_collected == NULL)
 				{
-					entry->curItem = collected;
+					entry->curItem = collected.item;
+					if (entry->useCurKey)
+					{
+						entry->curKey = collected.keyValue;
+						entry->curKeyCategory = collected.keyCategory;
+					}
 					break;
 				}
 
-				if (ItemPointerIsMin(&collected.iptr) ||
-					rumCompareItemPointers(&collected.iptr,
-										   &current_collected->iptr) == 0)
+				if (ItemPointerIsMin(&collected.item.iptr) ||
+					rumCompareItemPointers(&collected.item.iptr,
+										   &current_collected->item.iptr) == 0)
 				{
 					Datum	joinedAddInfo = (Datum)0;
 					bool	joinedAddInfoIsNull;
 
-					if (ItemPointerIsMin(&collected.iptr))
+					if (ItemPointerIsMin(&collected.item.iptr))
 					{
 						joinedAddInfoIsNull = true; /* will change later */
-						collected.addInfoIsNull = true;
+						collected.item.addInfoIsNull = true;
 					}
 					else
-						joinedAddInfoIsNull = collected.addInfoIsNull ||
-											current_collected->addInfoIsNull;
+						joinedAddInfoIsNull = collected.item.addInfoIsNull ||
+										current_collected->item.addInfoIsNull;
 
 					if (joinedAddInfoIsNull)
 					{
 						joinedAddInfoIsNull =
-							(collected.addInfoIsNull && current_collected->addInfoIsNull);
+							(collected.item.addInfoIsNull &&
+							 current_collected->item.addInfoIsNull);
 
-						if (collected.addInfoIsNull == false)
-							joinedAddInfo = collected.addInfo;
-						else if (current_collected->addInfoIsNull == false)
-							joinedAddInfo = current_collected->addInfo;
+						if (collected.item.addInfoIsNull == false)
+							joinedAddInfo = collected.item.addInfo;
+						else if (current_collected->item.addInfoIsNull == false)
+							joinedAddInfo = current_collected->item.addInfo;
 					}
 					else if (rumstate->canJoinAddInfo[entry->attnumOrig - 1])
 					{
 						joinedAddInfo =
 							FunctionCall2(
 								&rumstate->joinAddInfoFn[entry->attnumOrig - 1],
-								collected.addInfo,
-								current_collected->addInfo);
+								collected.item.addInfo,
+								current_collected->item.addInfo);
 					}
 					else
 					{
-						joinedAddInfo = current_collected->addInfo;
+						joinedAddInfo = current_collected->item.addInfo;
 					}
 
-					collected.iptr = current_collected->iptr;
-					collected.addInfoIsNull = joinedAddInfoIsNull;
-					collected.addInfo = joinedAddInfo;
+					collected.item.iptr = current_collected->item.iptr;
+					collected.item.addInfoIsNull = joinedAddInfoIsNull;
+					collected.item.addInfo = joinedAddInfo;
+					if (entry->useCurKey)
+					{
+						collected.keyValue = current_collected->keyValue;
+						collected.keyCategory = current_collected->keyCategory;
+					}
 
 					if (should_free)
 						pfree(current_collected);
 				}
 				else
 				{
-					entry->curItem = collected;
+					entry->curItem = collected.item;
 					entry->collectRumItem = *current_collected;
+					if (entry->useCurKey)
+					{
+						entry->curKey = collected.keyValue;
+						entry->curKeyCategory = collected.keyCategory;
+					}
 					if (should_free)
 						pfree(current_collected);
 					break;
@@ -1196,7 +1227,7 @@ entryGetItem(RumState * rumstate, RumScanEntry entry, bool *nextEntryList)
 			if (current_collected == NULL)
 			{
 				/* mark next call as last */
-				ItemPointerSetMax(&entry->collectRumItem.iptr);
+				ItemPointerSetMax(&entry->collectRumItem.item.iptr);
 
 				/* even current call is last */
 				if (ItemPointerIsMin(&entry->curItem.iptr))

src/rumscan.c

@@ -169,14 +169,19 @@ rumFillScanKey(RumScanOpaque so, OffsetNumber attnum,
 
 	if (key->orderBy)
 	{
+		if (key->attnum != rumstate->attrnAttachColumn)
+			key->useCurKey = rumstate->canOrdering[attnum - 1] &&
+				(strategy == RUM_DISTANCE || strategy == RUM_LEFT_DISTANCE ||
+				 strategy == RUM_RIGHT_DISTANCE);
+
 		/* Add key to order by additional information... */
 		if (key->attnum == rumstate->attrnAttachColumn ||
 			/* ...add key to order by index key value */
-			(strategy == RUM_DISTANCE && rumstate->canOrdering[attnum - 1]))
+			key->useCurKey)
 		{
 			if (nQueryValues != 1)
 				elog(ERROR, "extractQuery should return only one value for ordering");
-			if (rumstate->origTupdesc->attrs[rumstate->attrnAttachColumn - 1]->attbyval == false)
+			if (rumstate->origTupdesc->attrs[key->attnum - 1]->attbyval == false)
 				elog(ERROR, "doesn't support order by over pass-by-reference column");
 
 			if (key->attnum == rumstate->attrnAttachColumn)
@@ -188,7 +193,7 @@ rumFillScanKey(RumScanOpaque so, OffsetNumber attnum,
 				key->outerAddInfoIsNull = true;
 				key->attnum = rumstate->attrnAddToColumn;
 			}
-			else if (strategy == RUM_DISTANCE && rumstate->canOrdering[attnum - 1])
+			else if (key->useCurKey)
 			{
 				RumScanKey	scanKey = NULL;
 
@@ -202,7 +207,6 @@ rumFillScanKey(RumScanOpaque so, OffsetNumber attnum,
 					}
 				}
 
-				elog(INFO, "test");
 				if (scanKey == NULL)
 					elog(ERROR, "cannot order without attribute %d in WHERE clause",
 						 key->attnum);