windows-server-2003/net/jet500/jet/dae/inc/fucb.h

//==============	DAE: OS/2 Database Access Engine	===================
//==============	 fucb.h: File Use Control Block		===================


/*	describes exact placement of CSR and meaning of CSR's pgno:itag
/**/
typedef INT CSRSTAT;
#define csrstatOnCurNode				0		// pgno:itag == node CSR is ON
#define csrstatBeforeCurNode			1		// pgno:itag == node CSR is BEFORE
#define csrstatAfterCurNode				2		// pgno:itag == node CSR is AFTER,
#define csrstatDeferGotoBookmark		3		// valid bm
#define csrstatAfterLast				4		// no pgno:itag
#define csrstatBeforeFirst				5		// no pgno:itag
#define csrstatOnFDPNode				6		// pgno:itag == FDP root
#define csrstatDeferMoveFirst			7		// on first node
#define csrstatOnDataRoot				8		// on FCB data root node

/*	Currency Stack Register
/**/
struct _csr
	{
	ULONG  		ulDBTime;	 	// page time stamp
	struct _csr	*pcsrPath;		// parent currency
	PGNO   		pgno;	   		// pgno of node page
	SRID   		bm;				// bookmark of node
	SRID   		item;	   		// item, set to sridInvisibleCSR if invisible CSR
	CSRSTAT		csrstat;   		// status of csr relative to node
	INT			itag;	   		// node itag
	INT			isrid;		  	// index of item in item list
	INT			itagFather;	  	// itag of father
	INT			ibSon;		  	// index of son in father son table
	};

/*	allow invisible CSRs to be identified
/**/
#define	sridInvisibleCSR				((SRID)(-1))
#define	CSRSetInvisible( pcsr )			( (pcsr)->item = sridInvisibleCSR )
#define	CSRResetInvisible( pcsr )		( (pcsr)->item = sridNull )
#define	FCSRInvisible( pcsr )			( (pcsr)->item == sridInvisibleCSR )

#define	PcsrMEMAlloc()			(CSR*)PbMEMAlloc(iresCSR)

#ifdef DEBUG /*  Debug check for illegal use of freed csr  */
#define	MEMReleasePcsr(pcsr)	{ MEMRelease(iresCSR, (BYTE*)(pcsr)); pcsr = pcsrNil; }
#else
#define	MEMReleasePcsr(pcsr)	{ MEMRelease(iresCSR, (BYTE*)(pcsr)); }
#endif

/*	CSR constants
/**/
#define itagNull					(-1)
#define isridNull					(-1)
#define ibSonNull					(-1)

/*	flags for FUCB
/*
/*	fFUCBTaggedSet is set by column set, and reset by prepare replace
/*	and prepare insert.
/*
/*	fFUCBDeferClose is set by cursor DIRClose and reset by ErrDIROpen.
/*
/*	fFUCBDeferGotoBookmark is set by non-clustered index navigation and
/*	reset by record status, ErrIsamMove( 0 ), and column retrieval.
/*
/*	fFUCBGetBookmark is set by get bookmark and is reset by ErrFUCBOpen.
/**/
#define fFUCBIndex							(1<<0)	// FUCB is for index
#define fFUCBNonClustered					(1<<1)	// FUCB for nonclustered index
#define fFUCBSort							(1<<2)	// FUCB is for sort
#define fFUCBSystemTable					(1<<3)	// System table cursor
#define fFUCBWrite							(1<<4)	//	cursor can write
#define fFUCBDenyRead						(1<<5)	//	deny read flag
#define fFUCBDenyWrite						(1<<6)	//	deny write flag
#define fFUCBTaggedSet						(1<<7)	// tagged column

#define fFUCBDeferClose						(1<<9)	//	FUCB is awaiting close
#define fFUCBDeferGotoBookmark				(1<<10)	//	clustered cursor position
#define fFUCBGetBookmark					(1<<11)	//	cursor got bookmark
#define fFUCBLimstat	  					(1<<12)	//	range limit
#define fFUCBInclusive					 	(1<<13)	//	inclusive range
#define fFUCBUpper							(1<<14)	//	upper range limit
#define fFUCBFull							(1<<15)	//	all CSRs including invisible CSRs
#define fFUCBUpdateSeparateLV	  			(1<<16)	//	long value updated

/*	the following flags need to be prevent reuse of cursor
/*	after deferred closed.  This is done to correctly release
/*	domain flags when commit/rollback to transaction level 0.
/**/
#define fFUCBNotReuse						( fFUCBDenyRead | fFUCBDenyWrite )

#define FFUCBNotReuse( pfucb )				( (pfucb)->wFlags & fFUCBNotReuse )

#define FFUCBIndex( pfucb )					( (pfucb)->wFlags & fFUCBIndex )
#define FUCBSetIndex( pfucb )				( (pfucb)->wFlags |= fFUCBIndex )
#define FUCBResetIndex( pfucb )				( (pfucb)->wFlags &= ~(fFUCBIndex) )

#define FFUCBNonClustered( pfucb )	  		( (pfucb)->wFlags & fFUCBNonClustered )
#define FUCBSetNonClustered( pfucb )  		( (pfucb)->wFlags |= fFUCBNonClustered )
#define FUCBResetNonClustered( pfucb )		( (pfucb)->wFlags &= ~(fFUCBNonClustered) )
													
#define FFUCBSort( pfucb )	 		 		( (pfucb)->wFlags & fFUCBSort )
#define FUCBSetSort( pfucb )  				( (pfucb)->wFlags |= fFUCBSort )
#define FUCBResetSort( pfucb )				( (pfucb)->wFlags &= ~(fFUCBSort) )

#define FFUCBSystemTable( pfucb )	 		( (pfucb)->wFlags & fFUCBSystemTable )
#define FUCBSetSystemTable( pfucb )  		( (pfucb)->wFlags |= fFUCBSystemTable )
#define FUCBResetSystemTable( pfucb )		( (pfucb)->wFlags &= ~(fFUCBSystemTable) )

#define FFUCBUpdatable( pfucb )				( (pfucb)->wFlags & fFUCBWrite )
#define FUCBSetUpdatable( pfucb )			( (pfucb)->wFlags |= fFUCBWrite )
#define FUCBResetUpdatable( pfucb )			( (pfucb)->wFlags &= ~(fFUCBWrite) )

#define FFUCBDenyWrite( pfucb )				( (pfucb)->wFlags & fFUCBDenyWrite )
#define FUCBSetDenyWrite( pfucb )			( (pfucb)->wFlags |= fFUCBDenyWrite )
#define FUCBResetDenyWrite( pfucb )			( (pfucb)->wFlags &= ~(fFUCBDenyWrite) )

#define FFUCBDenyRead( pfucb )				( (pfucb)->wFlags & fFUCBDenyRead )
#define FUCBSetDenyRead( pfucb )			( (pfucb)->wFlags |= fFUCBDenyRead )
#define FUCBResetDenyRead( pfucb )			( (pfucb)->wFlags &= ~(fFUCBDenyRead) )

#define FFUCBTaggedSet( pfucb )	 			( (pfucb)->wFlags & fFUCBTaggedSet )
#define FUCBSetTaggedSet( pfucb )  			( (pfucb)->wFlags |= fFUCBTaggedSet )
#define FUCBResetTaggedSet( pfucb )			( (pfucb)->wFlags &= ~(fFUCBTaggedSet) )

#define FFUCBUpdateSeparateLV( pfucb )		( (pfucb)->wFlags & fFUCBUpdateSeparateLV )
#define FUCBSetUpdateSeparateLV( pfucb )	( (pfucb)->wFlags |= fFUCBUpdateSeparateLV )
#define FUCBResetUpdateSeparateLV( pfucb ) 	( (pfucb)->wFlags &= ~(fFUCBUpdateSeparateLV) )

#define FFUCBDeferClosed( pfucb )			( (pfucb)->wFlags & fFUCBDeferClose )
#define FUCBSetDeferClose( pfucb )			( (pfucb)->wFlags |= fFUCBDeferClose )
#define FUCBResetDeferClose( pfucb ) 		( (pfucb)->wFlags &= ~(fFUCBDeferClose) )

#define	FFUCBDeferGotoBookmark( pfucb )					\
	( (pfucb)->wFlags & fFUCBDeferGotoBookmark )
#define	FUCBSetDeferGotoBookmark( pfucb )				\
	( (pfucb)->wFlags |= fFUCBDeferGotoBookmark )
#define	FUCBResetDeferGotoBookmark( pfucb )				\
	( (pfucb)->wFlags &= ~(fFUCBDeferGotoBookmark) )

#define	FFUCBGetBookmark( pfucb )						\
	( (pfucb)->wFlags & fFUCBGetBookmark )
#define	FUCBSetGetBookmark( pfucb )						\
	( (pfucb)->wFlags |= fFUCBGetBookmark )
#define	FUCBResetGetBookmark( pfucb )					\
	( (pfucb)->wFlags &= ~(fFUCBGetBookmark) )

#define FFUCBLimstat( pfucb )				( (pfucb)->wFlags & fFUCBLimstat )
#define FUCBSetLimstat( pfucb )				( (pfucb)->wFlags |= fFUCBLimstat )
#define FUCBResetLimstat( pfucb ) 			( (pfucb)->wFlags &= ~(fFUCBLimstat) )

#define FFUCBInclusive( pfucb )	 			( (pfucb)->wFlags & fFUCBInclusive )
#define FUCBSetInclusive( pfucb )			( (pfucb)->wFlags |= fFUCBInclusive )
#define FUCBResetInclusive( pfucb ) 		( (pfucb)->wFlags &= ~(fFUCBInclusive) )

#define FFUCBUpper( pfucb )					( (pfucb)->wFlags & fFUCBUpper )
#define FUCBSetUpper( pfucb )				( (pfucb)->wFlags |= fFUCBUpper )
#define FUCBResetUpper( pfucb ) 			( (pfucb)->wFlags &= ~(fFUCBUpper) )

#define FFUCBFull( pfucb )					( (pfucb)->wFlags & fFUCBFull )
#define FUCBSetFull( pfucb )				( (pfucb)->wFlags |= fFUCBFull )
#define FUCBResetFull( pfucb ) 				( (pfucb)->wFlags &= ~(fFUCBFull) )

#define FFUCBVersioned( pfucb )				( (pfucb)->fVersioned )
#define FUCBSetVersioned( pfucb )			( (pfucb)->fVersioned = fTrue )
#define FUCBResetVersioned( pfucb )			( (pfucb)->fVersioned = fFalse )

/*	record modification copy buffer status
/**/
typedef	INT						CBSTAT;

#define	fCBSTATNull				0
#define	fCBSTATInsert			(1<<0)
#define	fCBSTATReplace			(1<<1)
#define	fCBSTATSet				(1<<2)
#define	fCBSTATLock				(1<<3)
#define	fCBSTATAppendItem		(1<<4)

#define StoreChecksum( pfucb )								\
	( (pfucb)->ulChecksum = 								\
		UlChecksum( (pfucb)->lineData.pb, (pfucb)->lineData.cb ) )
#define	PrepareInsert( pfucb )								\
	( (pfucb)->cbstat = fCBSTATInsert,						\
	  (pfucb)->levelPrep = (pfucb)->ppib->level )
#define	PrepareReplaceNoLock( pfucb )		  				\
	( (pfucb)->cbstat = fCBSTATReplace,						\
	  (pfucb)->levelPrep = (pfucb)->ppib->level )
#define	PrepareReplace( pfucb )		  						\
	( (pfucb)->cbstat = fCBSTATReplace | fCBSTATLock, 		\
	  (pfucb)->levelPrep = (pfucb)->ppib->level )
#define	PrepareSet( pfucb )									\
	( (pfucb)->cbstat = fCBSTATSet,							\
	  (pfucb)->levelPrep = (pfucb)->ppib->level )
#define	PrepareAppendItem( pfucb )							\
	( (pfucb)->cbstat = fCBSTATAppendItem )

typedef struct {
	INT		isrid;
	SRID	rgsrid[(cbPage - sizeof(INT))/sizeof(SRID)];
	} APPENDITEM;

#define	csridAppendItemMax	((cbPage - sizeof(INT))/sizeof(SRID))

#define	IsridAppendItemOfPfucb( pfucb )		(((APPENDITEM *)(pfucb)->lineWorkBuf.pb)->isrid)
#define	RgsridAppendItemOfPfucb( pfucb )	(((APPENDITEM *)(pfucb)->lineWorkBuf.pb)->rgsrid)

#define FChecksum( pfucb )											\
	( (pfucb)->ulChecksum == UlChecksum( (pfucb)->lineData.pb,		\
	(pfucb)->lineData.cb ) )

#define FFUCBReplacePrepared( pfucb )								\
	( (pfucb)->cbstat & fCBSTATReplace )
#define FFUCBReplaceNoLockPrepared( pfucb )							\
	( !( (pfucb)->cbstat & fCBSTATLock ) &&							\
	FFUCBReplacePrepared( pfucb ) )
#define FFUCBInsertPrepared( pfucb )								\
	( (pfucb)->cbstat & fCBSTATInsert )
#define FFUCBSetPrepared( pfucb )									\
	( (pfucb)->cbstat != fCBSTATNull &&								\
	(pfucb)->levelPrep == (pfucb)->ppib->level )
#define FFUCBRetPrepared( pfucb )									\
	( (pfucb)->cbstat != fCBSTATNull )
#define FFUCBUpdatePrepared( pfucb )	((pfucb)->cbstat != fCBSTATNull )
#define	FUCBResetCbstat( pfucb )  		( (pfucb)->cbstat = fCBSTATNull )

typedef INT		KS;

#define ksNull						0
#define ksPrepared					(1<<0)
#define ksTooBig					(1<<1)

#define	KSReset( pfucb )			( (pfucb)->ks = ksNull )
#define	KSSetPrepare( pfucb )		( (pfucb)->ks |= ksPrepared )
#define KSSetTooBig( pfucb ) 		( (pfucb)->ks |= ksTooBig )
#define	FKSPrepared( pfucb ) 		( (pfucb)->ks & ksPrepared )
#define	FKSTooBig( pfucb )	  		( (pfucb)->ks & ksTooBig )

/*	set bit arrary marcos
/**/
#define	FUCBResetColumnSet( pfucb )				  					\
	( memset( (pfucb)->rgbitSet, 0x00, 32 ) )
#define	FUCBSetFixedColumnSet( pfucb, fid )							\
	( (pfucb)->rgbitSet[(fid - fidFixedLeast)/8] |= 1 <<			\
		(fid-fidFixedLeast) % 8 )
#define	FUCBSetVarColumnSet( pfucb, fid )							\
	( (pfucb)->rgbitSet[16 + (fid - fidVarLeast)/8] |= 1 <<			\
		(fid-fidVarLeast) % 8 )
#define	FFUCBColumnSet( pfucb, ibitCol )							\
	( (pfucb)->rgbitSet[(ibitCol)/8] & ( 1 << ( (ibitCol) % 8 ) ) )

#define FUCBStore( pfucb )												\
	{																	\
	(pfucb)->csrstatStore = PcsrCurrent( pfucb )->csrstat;				\
	(pfucb)->bmStore = PcsrCurrent( pfucb )->bm;			 			\
	(pfucb)->itemStore = PcsrCurrent( pfucb )->item; 		 			\
	}

#define FUCBResetStore( pfucb )										\
	{																\
	(pfucb)->bmStore = 0;										 	\
	}

#define FUCBRestore( pfucb )										\
	{																\
	if ( (pfucb)->bmStore != isridNull && (pfucb)->bmStore != sridNull )	\
		{															\
		PcsrCurrent( pfucb )->csrstat = (pfucb)->csrstatStore;		\
		Assert( (pfucb)->csrstatStore == csrstatOnDataRoot ||		\
				(pfucb)->csrstatStore == csrstatDeferMoveFirst ||	\
				(pfucb)->csrstatStore == csrstatBeforeFirst ||		\
				(pfucb)->csrstatStore == csrstatAfterLast ||		\
				(pfucb)->bmStore != sridNull );						\
		PcsrCurrent( pfucb )->bm = (pfucb)->bmStore;				\
		PcsrCurrent( pfucb )->item = (pfucb)->itemStore;	  		\
		PcsrCurrent( pfucb )->ulDBTime = ulDBTimeNull; 			 	\
		}															\
	}

/* file use control block
/**/
struct _fucb
	{
	// ===== chaining fields =====
	struct _pib		*ppib;				// user that opened this FUCB
	struct _fucb 	*pfucbNext;			// Next FUCB of this user
	union
		{
		struct _fcb *pfcb;				// if wFlags & fFUCBIndex
		struct _scb *pscb;				// if wFlags & fFUCBSort
		} u;
	struct _fucb *pfucbNextInstance;	// Next Instance of this file

	// ===== currency =====
	struct _csr	*pcsr;

	// ===== stored currency =====
	SRID			bmStore;  			 	//	stored bookmark
	SRID			itemStore;		 	 	//	stored item
	SRID			bmRefresh;				//	stored bookmark for next/prev retry
	SRID 			sridFather;			 	// SRID of visible father
	
	BYTE			**ppbCurrent;		 	// (SORT) current record
	ULONG			ulChecksum;			 	// checksum of record -- used only for optimistic locking
	KEY  			keyNode;	 		 	// Key of current node
	LINE			lineData;			 	// Current data pointed in pcsr
	CSRSTAT	  		csrstatStore;  		 	//	stored CSR status
	LEVEL			levelOpen;

	// ===== interface to Storage System =====
	SSIB			ssib;					// SSIB associated with this FUCB
	struct _bf		*pbfEmpty;		 		// write latched empty page
	UINT			cpn;					//	next read-ahead pn

	// ===== maintained by rec man =====
	struct _fucb 	*pfucbCurIndex; 	// current secondary index
	struct _bf		*pbfWorkBuf;	 	// working buffer for Insert/Replace
	LINE			lineWorkBuf;	 	// working buffer for Insert/Replace
	ULONG			cbRecord;			//	size of original record
	ULONG			dbkUpdate;		 	// dbk of record to Replace
	BYTE			rgbitSet[32];
	CBSTAT			cbstat;			 	// copy buffer status
	LEVEL			levelPrep;		 	// level copy buffer prepared

		// ====== versioning work area =======
	struct _rce	*prceLast;				// last RCE allocated (used only for Replace)

	// ====== space manager work area =======
	PGNO			pgnoLast;			// last page of extent
	CPG 			cpgExtent;			// initial extent size
	CPG 			cpgAvail;			// number of remaining pages
	INT				fExtent;			// work area flag

	// ===== misc fields =====
	INT				wFlags;				// temporary flags

	// ===== maintained by dir man =====
	BYTE			*pbKey;			   	// search key buffer
	DBID			dbid;				// database id
	KS 				ks;					// search key buffer status
	UINT  			cbKey;				// key size
	BOOL			fVtid : 1;		 	// persistant flag cursor has vtid
	BOOL			fVersioned : 1;  	// persistant falg cursor made version
	BOOL			fCmprsLg:1;
	INT	  			clineDiff;
#define ilineDiffMax 3
	LINE			rglineDiff[ilineDiffMax];
	};


#define PfucbMEMAlloc()				(FUCB*)PbMEMAlloc(iresFUCB)

#ifdef DEBUG /*  Debug check for illegal use of freed fucb  */
#define MEMReleasePfucb(pfucb)		{ MEMRelease(iresFUCB, (BYTE*)(pfucb)); pfucb = pfucbNil; }
#else
#define MEMReleasePfucb(pfucb)		{ MEMRelease(iresFUCB, (BYTE*)(pfucb)); }
#endif

#ifdef	DEBUG
#define	CheckTable( ppibT, pfucb )		   					\
	{														\
	Assert( pfucb->ppib == ppibT );		   					\
	Assert( fRecovering || FFUCBIndex( pfucb ) );	 		\
	Assert( !( FFUCBSort( pfucb ) ) );						\
	Assert( pfucb->u.pfcb != NULL );						\
	}
#define	CheckSort( ppibT, pfucb )		   					\
	{									   					\
	Assert( pfucb->ppib == ppibT );		   					\
	Assert( FFUCBSort( pfucb ) );							\
	Assert( !( FFUCBIndex( pfucb ) ) );						\
	Assert( pfucb->u.pscb != NULL );						\
	}
#define	CheckFUCB( ppibT, pfucb )		   					\
	{														\
	Assert( pfucb->ppib == ppibT );		   					\
	Assert( pfucb->u.pfcb != NULL );						\
	}

#define CheckNonClustered( pfucb )							\
	{											   			\
	Assert( (pfucb)->pfucbCurIndex == pfucbNil ||			\
		FFUCBNonClustered( (pfucb)->pfucbCurIndex ) );		\
	}

#else	/* !DEBUG */
#define	CheckSort( ppib, pfucb )
#define	CheckTable( ppib, pfucb )
#define	CheckFUCB( ppib, pfucb )
#define	CheckNonClustered( pfucb )
#endif	/* !DEBUG */

#define PcsrCurrent( pfucb )		( (pfucb)->pcsr )
#define BmOfPfucb( pfucb )			( (pfucb)->pcsr->bm )
#define FUCBCheckUpdatable( pfucb )		\
	( FFUCBUpdatable( pfucb ) ? JET_errSuccess : JET_errPermissionDenied )
	
ERR ErrFUCBAllocCSR( CSR **ppcsr );
ERR ErrFUCBNewCSR( FUCB *pfucb );
VOID FUCBFreeCSR( FUCB *pfucb );
VOID FUCBFreePath( CSR **ppcsr, CSR *pcsrMark );
ERR ErrFUCBOpen( PIB *ppib, DBID dbid, FUCB **ppfucb );
VOID FUCBClose( FUCB *pfucb );
VOID FUCBRemoveInvisible(CSR **ppcsr);

VOID FUCBSetIndexRange( FUCB *pfucb, JET_GRBIT grbit );
VOID FUCBResetIndexRange( FUCB *pfucb );
ERR ErrFUCBCheckIndexRange( FUCB *pfucb );