//------------------------------------------------------------------------------
// Desc:	Contains specific q-sort code to sort FLAIM's KREF structures.
//
// Tabs:	3
//
//		Copyright (c) 1990-2000, 2002-2006 Novell, Inc. All Rights Reserved.
//
//		This program is free software; you can redistribute it and/or
//		modify it under the terms of version 2 of the GNU General Public
//		License as published by the Free Software Foundation.
//
//		This program is distributed in the hope that it will be useful,
//		but WITHOUT ANY WARRANTY; without even the implied warranty of
//		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//		GNU General Public License for more details.
//
//		You should have received a copy of the GNU General Public License
//		along with this program; if not, contact Novell, Inc.
//
//		To contact Novell about this file by physical or electronic mail,
//		you may find current contact information at www.novell.com
//
// $Id: kyqsort.cpp 3115 2006-01-19 13:24:39 -0700 (Thu, 19 Jan 2006) dsanders $
//------------------------------------------------------------------------------

#include "flaimsys.h"

#define	KY_SWAP( pKrefTbl, leftP, rightP)	\
	pTempKref = pKrefTbl [leftP]; \
	pKrefTbl [leftP] = pKrefTbl [rightP]; \
	pKrefTbl [rightP] = pTempKref
	
FSTATIC RCODE ixKeyGetNodeId(
	IXD *					pIxd,
	const FLMBYTE *	pucKey,
	const FLMBYTE *	pucKeyEnd,
	FLMUINT				uiKeyComponent,
	FLMUINT64 *			pui64NodeId);
	
FSTATIC RCODE ixKeyCompareUnicode(
	ICD *					pIcd,
	FLMUINT				uiLanguage,
	FLMUNICODE *		puzStr1,
	FLMUINT				uiByteLen1,
	FLMUNICODE *		puzStr2,
	FLMUINT				uiByteLen2,
	FLMINT *				piCompare);
	
FSTATIC RCODE ixKeyGetUnicode(
	F_Db *				pDb,
	ICD *					pIcd,
	FLMUINT				uiCollection,
	FLMUINT64			ui64NodeId,
	FLMUINT				uiKeyComponent,
	F_OldNodeList *	pOldNodeList,
	F_DataVector *		pSearchKey,
	F_DynaBuf *			pDynaBuf);
	
FSTATIC RCODE ixKeyGetBinary(
	F_Db *				pDb,
	ICD *					pIcd,
	FLMUINT				uiCollection,
	FLMUINT64			ui64NodeId,
	FLMUINT				uiKeyComponent,
	F_OldNodeList *	pOldNodeList,
	F_DataVector *		pSearchKey,
	F_DynaBuf *			pDynaBuf);
	
FSTATIC RCODE krefQuickSort(
	F_Db *				pDb,
	IXD *					pIxd,
	KREF_ENTRY **		pEntryTbl,
	FLMUINT				uiLowerBounds,
	FLMUINT				uiUpperBounds);

FSTATIC RCODE krefKillDups(
	F_Db *				pDb,
	IXD *					pIxd,
	KREF_ENTRY **		pKrefTbl,
	FLMUINT *			puiKrefTotal);

/***************************************************************************
Desc:	Compares result set entries during the finalization stage to allow
		the result set to be sorted and to remove duplicates.
*****************************************************************************/
FSTATIC RCODE ixKeyGetNodeId(
	IXD *					pIxd,
	const FLMBYTE *	pucKey,
	const FLMBYTE *	pucKeyEnd,
	FLMUINT				uiKeyComponent,
	FLMUINT64 *			pui64NodeId)
{
	RCODE				rc = NE_XFLM_OK;
	FLMUINT			uiComponent;
	FLMUINT			uiComponentLen;

	// Skip past all of the remaining key components so we can get to the
	// node ID list.  We are currently positioned on the key component
	// specified in uiKeyComponent.  NOTE: uiKeyComponent is zero-based,
	// 0=1st component, 1=2nd component, etc.

	uiComponent = uiKeyComponent;
	while (pucKey < pucKeyEnd && uiComponent < pIxd->uiNumKeyComponents)
	{
		uiComponentLen = getKeyComponentLength( pucKey);
		if (uiComponentLen != KEY_HIGH_VALUE && uiComponentLen != KEY_LOW_VALUE)
		{
			pucKey += (uiComponentLen + 2);
		}
		else
		{
			pucKey += 2;
		}
		uiComponent++;
	}
	
	// See if there are node IDs in the key.  A 0xFF could be present if
	// we have set a "high" node ID.
	
	if (pucKey >= pucKeyEnd || *pucKey == 0xFF)
	{
		*pui64NodeId = 0;
		goto Exit;
	}
	
	// At this point, we better have all of the node ids, including
	// document ID.

	// Skip past the document ID

	if (RC_BAD( rc = flmDecodeSEN64( &pucKey, pucKeyEnd, NULL)))
	{
		goto Exit;
	}
	if (pucKey >= pucKeyEnd)
	{
		*pui64NodeId = 0;
		goto Exit;
	}
	
	// Skip all of the node ids up to the one we want
	
	for (uiComponent = 0; uiComponent < uiKeyComponent; uiComponent++)
	{
		// Skip the component node ID - passing a NULL for the last
		// parameter is cheaper than getting it out.
		
		if (RC_BAD( rc = flmDecodeSEN64( &pucKey, pucKeyEnd, NULL)))
		{
			goto Exit;
		}
		if (pucKey >= pucKeyEnd)
		{
			*pui64NodeId = 0;
			goto Exit;
		}
	}
			
	// Should now be positioned on the one we want, extract it.
	
	if (RC_BAD( rc = flmDecodeSEN64( &pucKey, pucKeyEnd, pui64NodeId)))
	{
		goto Exit;
	}

Exit:

	return( rc);
}

/***************************************************************************
Desc:	Compares result set entries during the finalization stage to allow
		the result set to be sorted and to remove duplicates.
*****************************************************************************/
FSTATIC RCODE ixKeyCompareUnicode(
	ICD *				pIcd,
	FLMUINT			uiLanguage,
	FLMUNICODE *	puzStr1,
	FLMUINT			uiByteLen1,
	FLMUNICODE *	puzStr2,
	FLMUINT			uiByteLen2,
	FLMINT *			piCompare)
{
	RCODE						rc = NE_XFLM_OK;
	F_BufferIStream		bufferLStream;
	F_BufferIStream		bufferRStream;
	F_CollIStream			lStream;
	F_CollIStream			rStream;
	
	if (RC_BAD( rc = bufferLStream.open( (FLMBYTE *)puzStr1, uiByteLen1)))
	{
		goto Exit;
	}

	if (RC_BAD( rc = bufferRStream.open( (FLMBYTE *)puzStr2, uiByteLen2)))
	{
		goto Exit;
	}

	if (RC_BAD( rc = lStream.open( &bufferLStream, TRUE, uiLanguage,
		pIcd->uiCompareRules, FALSE)))
	{
		goto Exit;
	}

	if (RC_BAD( rc = rStream.open( &bufferRStream, TRUE, uiLanguage,
		pIcd->uiCompareRules, FALSE)))
	{
		goto Exit;
	}

	if (RC_BAD( rc = fqCompareCollStreams( &lStream, &rStream, FALSE,
								uiLanguage, piCompare)))
	{
		goto Exit;
	}

Exit:

	return( rc);
}

/***************************************************************************
Desc:	Do binary comparison.
*****************************************************************************/
FINLINE FLMINT ixKeyCompareBinary(
	const void *	pvData1,
	FLMUINT			uiLen1,
	const void *	pvData2,
	FLMUINT			uiLen2,
	FLMBOOL			bSortAscending)
{
	FLMINT			iCompare;
	
	if (uiLen1 > uiLen2)
	{
		if ((iCompare = f_memcmp( pvData1, pvData2, uiLen2)) >= 0)
		{
			return( bSortAscending ? 1 : -1);
		}
		else
		{
			return( bSortAscending ? -1 : 1);
		}
	}
	else if (uiLen1 < uiLen2)
	{
		if ((iCompare = f_memcmp( pvData1, pvData2, uiLen1)) <= 0)
		{
			return( bSortAscending ? -1 : 1);
		}
		else
		{
			return( bSortAscending ? 1 : -1);
		}
	}
	else
	{
		if ((iCompare = f_memcmp( pvData1, pvData2, uiLen1)) != 0)
		{
			if (iCompare < 0)
			{
				return( bSortAscending ? -1 : 1);
			}
			else
			{
				return( bSortAscending ? 1 : -1);
			}
		}
	}
	
	return( 0);
}
	
/***************************************************************************
Desc:	Get the unicode value for a particular key component.
*****************************************************************************/
FSTATIC RCODE ixKeyGetUnicode(
	F_Db *				pDb,
	ICD *					pIcd,
	FLMUINT				uiCollection,
	FLMUINT64			ui64NodeId,
	FLMUINT				uiKeyComponent,
	F_OldNodeList *	pOldNodeList,
	F_DataVector *		pSearchKey,
	F_DynaBuf *			pDynaBuf)
{
	RCODE					rc = NE_XFLM_OK;
	IF_DOMNode *		pNode = NULL;
	IF_PosIStream *	pIStream = NULL;
	eDomNodeType		eNodeType;
	
	if (ui64NodeId)
	{
		eNodeType = (pIcd->uiFlags & ICD_IS_ATTRIBUTE) 
												? ATTRIBUTE_NODE 
												: ELEMENT_NODE;

		// If there is an old-node list, first see if we can get the data
		// from there.  If it is not in there, see if we can get it from
		// the database.
		
		if (pOldNodeList)
		{
			FLMBYTE *		pucData;
			FLMUINT			uiDataLen;
			FLMUINT			uiDummy;
			void *			pvBuffer;

			if( pOldNodeList->findNodeInList( eNodeType, uiCollection,
				ui64NodeId, pIcd->uiDictNum, &pucData, &uiDataLen, &uiDummy))
			{
				
				// Allocate the space needed.
				
				if (RC_BAD( rc = pDynaBuf->allocSpace( uiDataLen, &pvBuffer)))
				{
					goto Exit;
				}
				
				f_memcpy( pvBuffer, pucData, uiDataLen);
				goto Exit;
			}
		}
		
		if( eNodeType == ATTRIBUTE_NODE)
		{
			if( RC_BAD( rc = pDb->getAttribute( uiCollection, ui64NodeId, 
				pIcd->uiDictNum, &pNode)))
			{
				flmAssert( rc != NE_XFLM_DOM_NODE_NOT_FOUND);
				goto Exit;
			}
		}
		else
		{
			if( RC_BAD( rc = pDb->getNode( uiCollection, ui64NodeId, &pNode)))
			{
				flmAssert( rc != NE_XFLM_DOM_NODE_NOT_FOUND);
				goto Exit;
			}
		}
		
		if (RC_BAD( rc = pNode->getUnicode( (IF_Db *)pDb, pDynaBuf)))
		{
			goto Exit;
		}
	}
	else
	{
		if (RC_BAD( rc = pSearchKey->getUnicode( uiKeyComponent, pDynaBuf)))
		{
			goto Exit;
		}
	}
	
Exit:

	if (pIStream)
	{
		pIStream->Release();
	}

	if (pNode)
	{
		pNode->Release();
	}

	return( rc);
}
	
/***************************************************************************
Desc:	Get the binary value for a particular key component.
*****************************************************************************/
FSTATIC RCODE ixKeyGetBinary(
	F_Db *				pDb,
	ICD *					pIcd,
	FLMUINT				uiCollection,
	FLMUINT64			ui64NodeId,
	FLMUINT				uiKeyComponent,
	F_OldNodeList *	pOldNodeList,
	F_DataVector *		pSearchKey,
	F_DynaBuf *			pDynaBuf)
{
	RCODE					rc = NE_XFLM_OK;
	IF_DOMNode *		pNode = NULL;
	IF_PosIStream *	pIStream = NULL;
	eDomNodeType		eNodeType;
	
	if (ui64NodeId)
	{
		eNodeType = (pIcd->uiFlags & ICD_IS_ATTRIBUTE) 
												? ATTRIBUTE_NODE 
												: ELEMENT_NODE;

		// If there is an old-node list, first see if we can get the data
		// from there.  If it is not in there, see if we can get it from
		// the database.
		
		if (pOldNodeList)
		{
			FLMBYTE *		pucData;
			FLMUINT			uiDataLen;
			FLMUINT			uiDummy;
			void *			pvBuffer;

			if( pOldNodeList->findNodeInList( eNodeType, uiCollection,
					ui64NodeId, pIcd->uiDictNum, &pucData, &uiDataLen, &uiDummy))
			{
				
				// Allocate the space needed.
				
				if (RC_BAD( rc = pDynaBuf->allocSpace( uiDataLen, &pvBuffer)))
				{
					goto Exit;
				}
				
				f_memcpy( pvBuffer, pucData, uiDataLen);
				goto Exit;
			}
		}
		
		if( eNodeType == ATTRIBUTE_NODE)
		{
			if( RC_BAD( rc = pDb->getAttribute( uiCollection, ui64NodeId, 
				pIcd->uiDictNum, &pNode)))
			{
				flmAssert( rc != NE_XFLM_DOM_NODE_NOT_FOUND);
				goto Exit;
			}
		}
		else
		{
			if( RC_BAD( rc = pDb->getNode( uiCollection, ui64NodeId, &pNode)))
			{
				flmAssert( rc != NE_XFLM_DOM_NODE_NOT_FOUND);
				goto Exit;
			}
		}
		
		if( RC_BAD( rc = pNode->getBinary( (IF_Db *)pDb, pDynaBuf)))
		{
			goto Exit;
		}
	}
	else
	{
		if (RC_BAD( rc = pSearchKey->getBinary( uiKeyComponent, pDynaBuf)))
		{
			goto Exit;
		}
	}
	
Exit:

	if (pIStream)
	{
		pIStream->Release();
	}

	if (pNode)
	{
		pNode->Release();
	}

	return( rc);
}
	
/***************************************************************************
Desc:	Compares result set entries during the finalization stage to allow
		the result set to be sorted and to remove duplicates.
*****************************************************************************/
RCODE ixKeyCompare(
	F_Db *				pDb,
	IXD *					pIxd,
	F_DataVector *		pSearchKey,
	F_OldNodeList *	pOldNodeList1,
	F_OldNodeList *	pOldNodeList2,
	FLMBOOL				bCompareDocId,
	FLMBOOL				bCompareNodeIds,
	const void *		pvKey1,
	FLMUINT				uiKeyLen1,
	const void *		pvKey2,
	FLMUINT				uiKeyLen2,
	FLMINT *				piCompare)
{
	RCODE					rc = NE_XFLM_OK;
	FLMUINT				uiKeyComponent;
	ICD *					pIcd;
	FLMUINT				uiComponentLen1;
	FLMUINT				uiComponentLen2;
	FLMBOOL				bTruncated1;
	FLMBOOL				bTruncated2;
	const FLMBYTE *	pucKey1 = (const FLMBYTE *)pvKey1;
	const FLMBYTE *	pucKey2 = (const FLMBYTE *)pvKey2;
	const FLMBYTE *	pucKeyEnd1 = pucKey1 + uiKeyLen1;
	const FLMBYTE *	pucKeyEnd2 = pucKey2 + uiKeyLen2;
	FLMBOOL				bSortAscending;
	FLMBOOL				bSortMissingHigh;
	FLMUINT64			ui64NodeId1;
	FLMUINT64			ui64NodeId2;
	
	flmAssert( uiKeyLen1 && uiKeyLen2);

	// Loop for each compound piece of key

	uiKeyComponent = 0;
	pIcd = pIxd->pFirstKey;
	for (;;)
	{
		bSortAscending = (pIcd->uiFlags & ICD_DESCENDING) ? FALSE : TRUE;
		bSortMissingHigh = (pIcd->uiFlags & ICD_MISSING_HIGH) ? TRUE : FALSE;
		uiComponentLen1 = getKeyComponentLength( pucKey1);
		uiComponentLen2 = getKeyComponentLength( pucKey2);
		
		// See if either component is a "high" key
		// NOTE: KEY_HIGH_VALUE always sorts highest, regardless of
		// ascending or descending.  It is never actually stored.  It is
		// only passed in for searching.
		
		if (uiComponentLen1 == KEY_HIGH_VALUE)
		{
			if (uiComponentLen2 == KEY_HIGH_VALUE)
			{
				uiComponentLen1 = uiComponentLen2 = 0;
				goto Test_Exclusive;
			}
			else
			{
				*piCompare = 1;
				goto Exit;
			}
		}
		else if (uiComponentLen2 == KEY_HIGH_VALUE)
		{
			*piCompare = -1;
			goto Exit;
		}
		
		// See if either component is a "low" key
		// NOTE: KEY_LOW_VALUE always sorts lowest, regardless of
		// ascending or descending.  It is never actually stored.  It is
		// only passed in for searching.
		
		if (uiComponentLen1 == KEY_LOW_VALUE)
		{
			if (uiComponentLen2 == KEY_LOW_VALUE)
			{
				uiComponentLen1 = uiComponentLen2 = 0;
				goto Test_Exclusive;
			}
			else
			{
				*piCompare = -1;
				goto Exit;
			}
		}
		else if (uiComponentLen2 == KEY_LOW_VALUE)
		{
			*piCompare = 1;
			goto Exit;
		}
		
		// See if either component is missing.  Need to apply the rules for
		// sorting missing components in that case.
	
		if (!uiComponentLen1)
		{
			if (uiComponentLen2)
			{
				if (bSortMissingHigh)
				{
					*piCompare = bSortAscending ? 1 : -1;
				}
				else
				{
					*piCompare = bSortAscending ? -1 : 1;
				}
				goto Exit;
			}
			else
			{
				goto Test_Exclusive;
			}
		}
		else if (!uiComponentLen2)
		{
			if (bSortMissingHigh)
			{
				*piCompare = bSortAscending ? -1 : 1;
			}
			else
			{
				*piCompare = bSortAscending ? 1 : -1;
			}
			goto Exit;
		}
		else
		{
		
			// Component length must not exceed remaining length of key.
			
			flmAssert( pucKey1 + 2 + uiComponentLen1 <= pucKeyEnd1 &&
						  pucKey2 + 2 + uiComponentLen2 <= pucKeyEnd2);
	
			if ((*piCompare = ixKeyCompareBinary( pucKey1 + 2, uiComponentLen1,
										pucKey2 + 2, uiComponentLen2, bSortAscending)) != 0)
			{
				goto Exit;
			}
			
			// Data is equal, see if one or ther other is truncated.
			
			bTruncated1 = isKeyComponentTruncated( pucKey1);
			bTruncated2 = isKeyComponentTruncated( pucKey2);
			
			if (bTruncated1 || bTruncated2)
			{
				if (!bTruncated2)
				{
					*piCompare = bSortAscending ? 1 : -1;
					goto Exit;
				}
				else if (!bTruncated1)
				{
					*piCompare = bSortAscending ? -1 : 1;
					goto Exit;
				}
				
				if (isSearchKeyComponent( pucKey1))
				{
					flmAssert( pSearchKey);
					ui64NodeId1 = pSearchKey->getID( uiKeyComponent);
													  
					// The search key better have a node ID or the untruncated
					// value.
					
					flmAssert( ui64NodeId1 ||
									!pSearchKey->isRightTruncated( uiKeyComponent));
				}
				else
				{
				
					// Need to read the data from the nodes and do a comparison.
					// Get each node ID.
					
					if (RC_BAD( rc = ixKeyGetNodeId( pIxd, pucKey1, pucKeyEnd1,
												uiKeyComponent, &ui64NodeId1)))
					{
						goto Exit;
					}
					flmAssert( ui64NodeId1);
				}
				
				if (isSearchKeyComponent( pucKey2))
				{
					flmAssert( pSearchKey);
					ui64NodeId2 = pSearchKey->getID( uiKeyComponent);
													  
					// The search key better have a node ID or the untruncated
					// value.
					
					flmAssert( ui64NodeId2 ||
									!pSearchKey->isRightTruncated( uiKeyComponent));
				}
				else
				{
					// Need to read the data from the nodes and do a comparison.
					// Get each node ID.
					
					if (RC_BAD( rc = ixKeyGetNodeId( pIxd, pucKey2, pucKeyEnd2,
												uiKeyComponent, &ui64NodeId2)))
					{
						goto Exit;
					}
					flmAssert( ui64NodeId2);
				}
				
				// If the node IDs are equal, we can skip fetching the data, because
				// it will be the same.
				
				if (ui64NodeId1 != ui64NodeId2)
				{
					FLMBYTE		ucDynaBuf1[ 64];
					FLMBYTE		ucDynaBuf2[ 64];
					F_DynaBuf	dynaBuf1( ucDynaBuf1, sizeof( ucDynaBuf1));
					F_DynaBuf	dynaBuf2( ucDynaBuf2, sizeof( ucDynaBuf2));
					
					// Better be binary data or text data.
					
					switch (icdGetDataType( pIcd))
					{
						case XFLM_TEXT_TYPE:
						{
							if (RC_BAD( rc = ixKeyGetUnicode( pDb, pIcd, 
													pIxd->uiCollectionNum,
													ui64NodeId1, uiKeyComponent,
													pOldNodeList1, pSearchKey, &dynaBuf1)))
							{
								goto Exit;
							}
							if (RC_BAD( rc = ixKeyGetUnicode( pDb, pIcd, 
													pIxd->uiCollectionNum,
													ui64NodeId2, uiKeyComponent,
													pOldNodeList2, pSearchKey, &dynaBuf2)))
							{
								goto Exit;
							}
							if (RC_BAD( rc = ixKeyCompareUnicode( pIcd,
														pIxd->uiLanguage,
														dynaBuf1.getUnicodePtr(),
														dynaBuf1.getDataLength(),
														dynaBuf2.getUnicodePtr(),
														dynaBuf2.getDataLength(), piCompare)))
							{
								goto Exit;
							}
							if (*piCompare < 0)
							{
								*piCompare = bSortAscending ? -1 : 1;
								goto Exit;
							}
							else if (*piCompare > 0)
							{
								*piCompare = bSortAscending ? 1 : -1;
								goto Exit;
							}
							break;
						}
				
						case XFLM_BINARY_TYPE:
						{
							if (RC_BAD( rc = ixKeyGetBinary( pDb, pIcd, 
													pIxd->uiCollectionNum,
													ui64NodeId1, uiKeyComponent,
													pOldNodeList1, pSearchKey, &dynaBuf1)))
							{
								goto Exit;
							}
							
							if (RC_BAD( rc = ixKeyGetBinary( pDb, pIcd, 
									pIxd->uiCollectionNum, ui64NodeId2, uiKeyComponent,
									pOldNodeList2, pSearchKey, &dynaBuf2)))
							{
								goto Exit;
							}
							
							if ((*piCompare = ixKeyCompareBinary(
														dynaBuf1.getBufferPtr(),
														dynaBuf1.getDataLength(),
														dynaBuf2.getBufferPtr(),
														dynaBuf2.getDataLength(),
														bSortAscending)) != 0)
							{
								goto Exit;
							}
							break;
						}
	
						default:
							rc = RC_SET_AND_ASSERT( NE_XFLM_DATA_ERROR);
							goto Exit;
					}
				}
			}
		}

Test_Exclusive:
			
		// See if either component is exclusive - everything else is
		// equal up to this point.
		
		if (isKeyComponentLTExclusive( pucKey1))
		{
			if (!isKeyComponentLTExclusive( pucKey2))
			{
				*piCompare = bSortAscending ? -1 : 1;
				goto Exit;
			}
		}
		else if (isKeyComponentGTExclusive( pucKey1))
		{
			if (!isKeyComponentGTExclusive( pucKey2))
			{
				*piCompare = bSortAscending ? 1 : -1;
				goto Exit;
			}
		}
		else if (isKeyComponentLTExclusive( pucKey2))
		{
			*piCompare = bSortAscending ? 1 : -1;
			goto Exit;
		}
		else if (isKeyComponentGTExclusive( pucKey2))
		{
			*piCompare = bSortAscending ? -1 : 1;
			goto Exit;
		}
		
		// Position to the end of this component

		pucKey1 += (2 + uiComponentLen1);
		pucKey2 += (2 + uiComponentLen2);

		pIcd = pIcd->pNextKeyComponent;
		uiKeyComponent++;

		// If there are no more ICDs, we are done with the key
		// components.

		if (!pIcd)
		{
			break;
		}
		
		// See if we are out of key components - this may be a search that
		// passed in only a partial key.
		
		if (pucKey1 >= pucKeyEnd1)
		{
			*piCompare = (pucKey2 >= pucKeyEnd2) ? 0 : -1;
			goto Exit;
		}
		else if (pucKey2 >= pucKeyEnd2)
		{
			*piCompare = 1;
			goto Exit;
		}
	}
	
	// Compare the node ID list, if being requested to.  Includes comparing of the
	// last byte, which is the total number of bytes in the node ID list.
	
	if (bCompareDocId || bCompareNodeIds)
	{
		
		// See if we have a node IDs - this may be a search that
		// passed in only a partial key and there are no NODE ids on it.
		
		if (pucKey1 >= pucKeyEnd1)
		{
			*piCompare = (pucKey2 >= pucKeyEnd2) ? 0 : -1;
			goto Exit;
		}
		else if (pucKey2 >= pucKeyEnd2)
		{
			*piCompare = 1;
			goto Exit;
		}
		
		// See if either one has an ID buffer of "high"
		
		if (*pucKey1 == 0xFF)
		{
			
			// Key1 has a "high" set of node IDs, see what key2 has.
			
			*piCompare = (*pucKey2 == 0xFF) ? 0 : 1;
			goto Exit;
		}
		else if (*pucKey2 == 0xFF)
		{
			// Key2 has a "high" set of node IDs, key1 does not.
			
			*piCompare = -1;
			goto Exit;
		}
		else if (bCompareNodeIds)
		{
			FLMUINT	uiNodeIDLen1 = (FLMUINT)(pucKeyEnd1 - pucKey1);
			FLMUINT	uiNodeIDLen2 = (FLMUINT)(pucKeyEnd2 - pucKey2);
			
			// We will always compare doc ID if we are also comparing
			// node ID.  Hence, although it is probably not entirely
			// necessary, we require the caller to also set bCompareDocId
			// to TRUE, just so that he doesn't think it is possible to
			// compare the node ids without comparing the document id.
			
			flmAssert( bCompareDocId);
					  
			*piCompare = ixKeyCompareBinary( pucKey1, uiNodeIDLen1,
										pucKey2, uiNodeIDLen2, TRUE);
		}
		else
		{
			FLMUINT64	ui64DocId1;
			FLMUINT64	ui64DocId2;
			
			// Get the document ID and compare it, and only it.
			// At this point, both keys should be positioned to
			// get the document ID.
			
			if (RC_BAD( rc = flmDecodeSEN64( &pucKey1, pucKeyEnd1, &ui64DocId1)))
			{
				goto Exit;
			}
			if (RC_BAD( rc = flmDecodeSEN64( &pucKey2, pucKeyEnd2, &ui64DocId2)))
			{
				goto Exit;
			}
			if (ui64DocId1 == ui64DocId2)
			{
				*piCompare = 0;
			}
			else if (ui64DocId1 < ui64DocId2)
			{
				*piCompare = -1;
			}
			else
			{
				*piCompare = 1;
			}
		}
	}
	else
	{
		*piCompare = 0;
	}

Exit:

	return( rc);
}

/****************************************************************************
Desc:	Compare function used to compare index number and key
****************************************************************************/
FINLINE RCODE krefCompareIxAndKey(
	F_Db *			pDb,
	IXD *				pIxd,
	KREF_ENTRY * 	pKrefA,
	KREF_ENTRY *	pKrefB,
	FLMINT *			piCompare)
{
	RCODE		rc = NE_XFLM_OK;
	
	// Compare index numbers

	if ((*piCompare = ((FLMINT) pKrefA->ui16IxNum) - 
		((FLMINT) pKrefB->ui16IxNum)) != 0)
	{
		goto Exit;
	}
	
	if (!pIxd || pIxd->uiIndexNum != (FLMUINT)pKrefA->ui16IxNum)
	{
		if (RC_BAD( rc = pDb->getDict()->getIndex( (FLMUINT)pKrefA->ui16IxNum,
														NULL, &pIxd, TRUE)))
		{
			goto Exit;
		}
	}

	if (RC_BAD( rc = ixKeyCompare( pDb, pIxd, NULL,
							pKrefA->bDelete ? pDb->getOldNodeList() : NULL,
							pKrefB->bDelete ? pDb->getOldNodeList() : NULL,
							TRUE, TRUE,
							&pKrefA [1], (FLMUINT)pKrefA->ui16KeyLen,
							&pKrefB [1], (FLMUINT)pKrefB->ui16KeyLen, piCompare)))
	{
		goto Exit;
	}
	
Exit:

	return( rc);
}

/****************************************************************************
Desc:	Compare function used to compare key data
****************************************************************************/
FINLINE FLMBOOL krefIsKeyDataEqual(
	KREF_ENTRY * 	pKrefA,
	KREF_ENTRY *	pKrefB)
{
	if( pKrefA->uiDataLen != pKrefB->uiDataLen)
	{
		return( FALSE);
	}
	
	if( pKrefA->uiDataLen)
	{
		if( f_memcmp( (FLMBYTE *)(&pKrefA [1]) +
												pKrefA->ui16KeyLen + 1,
									(FLMBYTE *)(&pKrefB [1]) +
												pKrefB->ui16KeyLen + 1,
									pKrefA->uiDataLen) != 0)
		{
			return( FALSE);
		}
	}
	
	return( TRUE);
}
		
/****************************************************************************
Desc:	Compare function used to compare two keys.
****************************************************************************/
FINLINE RCODE krefSortCompare(
	F_Db *			pDb,
	IXD *				pIxd,
	KREF_ENTRY * 	pKrefA,
	KREF_ENTRY *	pKrefB,
	FLMINT *			piCompare)
{
	RCODE		rc = NE_XFLM_OK;
	
	if (RC_BAD( rc = krefCompareIxAndKey( pDb, pIxd, pKrefA, pKrefB, piCompare)))
	{
		goto Exit;
	}

	if (*piCompare == 0)
	{
		*piCompare = (pKrefA->uiSequence < pKrefB->uiSequence) ? -1 : 1;
	}
	
Exit:

	return( rc);
}

/****************************************************************************
Desc:	Checks if the current database has any UNIQUE indexes that need 
		to checked. Also does duplicate processing for the record.
****************************************************************************/
RCODE F_Db::processDupKeys(
	IXD *		pIxd)
{
	RCODE	rc = NE_XFLM_OK;
	
	//  Sort and remove duplicates

	if (m_uiKrefCount > 1)
	{
		if (RC_BAD( rc = krefQuickSort( this, pIxd, m_pKrefTbl,
									0, m_uiKrefCount - 1)))
		{
			goto Exit;
		}
		if (RC_BAD( rc = krefKillDups( this, pIxd,
										m_pKrefTbl, &m_uiKrefCount)))
		{
			goto Exit;
		}
	}
	
Exit:

	return( rc);
}

/****************************************************************************
Desc:	Commit (write out) all keys that have built up in the KREF table.
****************************************************************************/
RCODE F_Db::keysCommit(
	FLMBOOL			bCommittingTrans,
	FLMBOOL			bSortKeys)
{
	RCODE				rc = NE_XFLM_OK;
	FLMUINT			uiRflToken = 0;
	
	// If the Kref has not been initialized, there is no
	// work to do.

	if (m_bKrefSetup)
	{
		LFILE *			pLFile = NULL;
		IXD *				pIxd;
		FLMUINT			uiTotal = m_uiKrefCount;
		KREF_ENTRY *	pKref;
		KREF_ENTRY **	pKrefTbl = m_pKrefTbl;
		FLMUINT			uiKrefNum;
		FLMUINT			uiLastIxNum;

		// We should not have reached this point if bAbortTrans is TRUE

		if( RC_BAD( m_AbortRc))
		{
			rc = RC_SET_AND_ASSERT( m_AbortRc);
			goto Exit;
		}

		// Sort the KREF table, if it contains more than one key.
		// This will sort all keys from the same index the same.

		if (uiTotal > 1 && bSortKeys)
		{
			processDupKeys( NULL);
			uiTotal = m_uiKrefCount;
		}

		// Disable RFL logging

		if( uiTotal)
		{
			m_pDatabase->m_pRfl->disableLogging( &uiRflToken);
		}

		// Loop through the KREF table outputting all keys

		uiLastIxNum = 0;
		for (uiKrefNum = 0; uiKrefNum < uiTotal; uiKrefNum++)
		{
			pKref = pKrefTbl [uiKrefNum];

			// See if the LFILE changed

			flmAssert( pKref->ui16IxNum);

			if (pKref->ui16IxNum != uiLastIxNum)
			{
				uiLastIxNum = pKref->ui16IxNum;
				if (RC_BAD( rc = m_pDict->getIndex( uiLastIxNum,
							&pLFile, &pIxd, TRUE)))
				{
					goto Exit;
				}
			}

			// Flush the key to the index
			if (m_pKeyColl)
			{
				m_pKeyColl->addKey( this, pIxd, pKref);
			}
			else
			{
				if (RC_BAD(rc = refUpdate( pLFile, pIxd, pKref, TRUE)))
				{
					if (rc != NE_XFLM_NOT_UNIQUE)
					{
						RC_UNEXPECTED_ASSERT( rc);
					}
					goto Exit;
				}
			}
		}
						
		if (bCommittingTrans)
		{
			krefCntrlFree();
		}
		else
		{
			// Empty the table out so we can add more keys in this trans.

			m_pKrefPool->poolReset( NULL, TRUE);
			m_uiKrefCount = 0;
			m_uiTotalKrefBytes = 0;
		}
	}

Exit:

	if( RC_BAD( rc))
	{
		setMustAbortTrans( rc);
	}

	if( uiRflToken)
	{
		m_pDatabase->m_pRfl->enableLogging( &uiRflToken);
	}
	
	return( rc);
}

/***************************************************************************
Desc:	Quick sort an array of KREF_ENTRY * values.
****************************************************************************/
FSTATIC RCODE krefQuickSort(
	F_Db *			pDb,
	IXD *				pIxd,
	KREF_ENTRY **	pEntryTbl,
	FLMUINT			uiLowerBounds,
	FLMUINT			uiUpperBounds)
{
	RCODE				rc = NE_XFLM_OK;
	FLMUINT			uiLBPos;
	FLMUINT			uiUBPos;
	FLMUINT			uiMIDPos;
	FLMUINT			uiLeftItems;
	FLMUINT			uiRightItems;
	KREF_ENTRY *	pCurEntry;
	KREF_ENTRY *	pTempKref;
	FLMINT			iCompare;

Iterate_Larger_Half:

	uiUBPos = uiUpperBounds;
	uiLBPos = uiLowerBounds;
	uiMIDPos = (uiUpperBounds + uiLowerBounds + 1) / 2;
	pCurEntry = pEntryTbl[ uiMIDPos ];
	for( ;;)
	{
		for (;;)
		{
			if (uiLBPos != uiMIDPos)
			{
				if (RC_BAD( rc = krefSortCompare( pDb, pIxd,
											pEntryTbl[ uiLBPos], pCurEntry, &iCompare)))
				{
					goto Exit;
				}
				if (iCompare >= 0)
				{
					break;
				}
			}
			if (uiLBPos >= uiUpperBounds)
			{
				break;
			}
			uiLBPos++;
		}

		for (;;)
		{
			if (uiUBPos != uiMIDPos)
			{
				if (RC_BAD( rc = krefSortCompare( pDb, pIxd, pCurEntry,
												pEntryTbl[ uiUBPos], &iCompare)))
				{
					goto Exit;
				}
				if (iCompare >= 0)
				{
					break;
				}
			}
			if (!uiUBPos)
			{
				break;
			}
			uiUBPos--;
		}
		
		if (uiLBPos < uiUBPos)			// Interchange and continue loop.
		{

			// Interchange [uiLBPos] with [uiUBPos].

			KY_SWAP( pEntryTbl, uiLBPos, uiUBPos );
			uiLBPos++;						// Scan from left to right.
			uiUBPos--;						// Scan from right to left.
		}
		else									// Past each other - done
		{
			break;
		}
	}

	// Check for swap( LB, MID ) - cases 3 and 4

	if (uiLBPos < uiMIDPos)
	{

		// Interchange [uiLBPos] with [uiMIDPos]

		KY_SWAP( pEntryTbl, uiMIDPos, uiLBPos );
		uiMIDPos = uiLBPos;
	}
	else if (uiMIDPos < uiUBPos)
	{

		// Interchange [uUBPos] with [uiMIDPos]

		KY_SWAP( pEntryTbl, uiMIDPos, uiUBPos );
		uiMIDPos = uiUBPos;
	}

	// Check the left piece.

	uiLeftItems = (uiLowerBounds + 1 < uiMIDPos )
							? uiMIDPos - uiLowerBounds		// 2 or more
							: 0;
	uiRightItems = (uiMIDPos + 1 < uiUpperBounds )
							? uiUpperBounds - uiMIDPos 		// 2 or more
							: 0;

	if (uiLeftItems < uiRightItems)
	{

		// Recurse on the LEFT side and goto the top on the RIGHT side.

		if (uiLeftItems)
		{
			if (RC_BAD( rc = krefQuickSort( pDb, pIxd, pEntryTbl,
										uiLowerBounds, uiMIDPos - 1)))
			{
				goto Exit;
			}
		}
		uiLowerBounds = uiMIDPos + 1;
		goto Iterate_Larger_Half;
	}
	else if (uiLeftItems)	// Compute a truth table to figure out this check.
	{

		// Recurse on the RIGHT side and goto the top for the LEFT side.

		if (uiRightItems)
		{
			if (RC_BAD( rc = krefQuickSort( pDb, pIxd, pEntryTbl,
										uiMIDPos + 1, uiUpperBounds)))
			{
				goto Exit;
			}
		}
		uiUpperBounds = uiMIDPos - 1;
		goto Iterate_Larger_Half;
	}
	
Exit:

	return( rc);
}

/****************************************************************************
Desc:		Kill all duplicate keys in the KREF table.
****************************************************************************/
FSTATIC RCODE krefKillDups(
	F_Db *			pDb,
	IXD *				pIxd,
	KREF_ENTRY **	pKrefTbl,
	FLMUINT *		puiKrefTotal)
{
	RCODE				rc = NE_XFLM_OK;
	FLMUINT			uiCurKref = 0;
	FLMUINT			uiLastKref = *puiKrefTotal;
	FLMUINT			uiFirstForKey;
	FLMUINT			uiLastForKey;
	FLMUINT			uiNewPosOffset = 0;
	FLMINT			iCompare;

	while( uiCurKref < uiLastKref)
	{
		uiFirstForKey = uiLastForKey = uiCurKref;
		uiCurKref = uiFirstForKey + 1;

		while( uiCurKref < uiLastKref)
		{
			if (RC_BAD( rc = krefCompareIxAndKey( pDb, pIxd, pKrefTbl[ uiFirstForKey],
												pKrefTbl[ uiCurKref], &iCompare)))
			{
				goto Exit;
			}
			
			if (iCompare)
			{
				break;
			}
			
			uiLastForKey = uiCurKref++;
		}
		
		if( uiFirstForKey == uiLastForKey)
		{
			pKrefTbl[ uiNewPosOffset++] = pKrefTbl[ uiFirstForKey];
			continue;
		}
		
		if( pKrefTbl[ uiFirstForKey]->bDelete)
		{
			if( pKrefTbl[ uiLastForKey]->bDelete)
			{
				pKrefTbl[ uiNewPosOffset++] = pKrefTbl[ uiFirstForKey];
			}
			else
			{
TestCancel:
				// See if the operations cancel each other.  If they don't, we
				// need to keep both operations
				
				if( !krefIsKeyDataEqual( pKrefTbl[ uiFirstForKey], pKrefTbl[ uiLastForKey]))
				{
					pKrefTbl[ uiNewPosOffset++] = pKrefTbl[ uiFirstForKey];
					pKrefTbl[ uiNewPosOffset++] = pKrefTbl[ uiLastForKey];
				}
			}
		}
		else
		{
			if( pKrefTbl[ uiLastForKey]->bDelete)
			{
				goto TestCancel;
			}
			else
			{
				pKrefTbl[ uiNewPosOffset++] = pKrefTbl[ uiLastForKey];
			}
		}
	}
	
	*puiKrefTotal = uiNewPosOffset;
	
Exit:

	return( rc);
}