head	1.9;
access;
symbols
	release_4_2:1.9
	aix_ok:1.9
	Version_2_1:1.7
	C_Demo_1:1.4;
locks; strict;
comment	@ * @;


1.9
date	91.05.01.02.51.29;	author cimarron;	state Exp;
branches;
next	1.8;

1.8
date	91.04.28.09.14.39;	author cimarron;	state Exp;
branches;
next	1.7;

1.7
date	90.09.25.16.46.22;	author kemnitz;	state Exp;
branches;
next	1.6;

1.6
date	89.10.16.22.09.52;	author goh;	state Exp;
branches;
next	1.5;

1.5
date	89.09.25.10.57.41;	author goh;	state Exp;
branches;
next	1.4;

1.4
date	89.09.05.17.25.11;	author mao;	state C_Demo_1;
branches;
next	1.3;

1.3
date	89.07.17.15.01.36;	author dillon;	state Exp;
branches;
next	1.2;

1.2
date	89.02.02.15.35.12;	author dillon;	state Stab;
branches;
next	1.1;

1.1
date	89.01.17.05.57.39;	author cimarron;	state Exp;
branches;
next	;


desc
@@


1.9
log
@round II of converting simple functions to macros + code cleaning in general
@
text
@/*
 * itemptr.c --
 *	POSTGRES disk item pointer code.
 */

#include "tmp/c.h"

#include "storage/block.h"
#include "storage/off.h"
#include "storage/page.h"
#include "storage/itemptr.h"
#include "storage/bufpage.h"

RcsId("$Header: RCS/itemptr.c,v 1.8 91/04/28 09:14:39 cimarron Exp Locker: cimarron $");

bool
ItemPointerEquals(pointer1, pointer2)
    ItemPointer pointer1;
    ItemPointer	pointer2;
{
    if (ItemPointerGetBlockNumber(pointer1) ==
        ItemPointerGetBlockNumber(pointer2) &&
        ItemPointerGetOffsetNumber(pointer1, SinglePagePartition) ==
        ItemPointerGetOffsetNumber(pointer2, SinglePagePartition))
	return(true);
    else
        return(false);
}

LogicalPageNumber
ItemPointerGetLogicalPageNumber(pointer, partition)
    ItemPointer		pointer;
    PagePartition	partition;
{
    int16	pagesPerBlock;	/* XXX use a named type */
    
    Assert(ItemPointerIsValid(pointer));
    
    pagesPerBlock = PagePartitionGetPagesPerBlock(partition);
    if (pagesPerBlock == 1) {
	return (1 + ItemPointerGetBlockNumber(pointer));
    }
    return (1 + ItemPointerGetPageNumber(pointer, partition) +
	    pagesPerBlock * ItemPointerGetBlockNumber(pointer));
}

void
ItemPointerSetLogicalPageNumber(pointer, partition, pageNumber)
    ItemPointer		pointer;
    PagePartition	partition;
    LogicalPageNumber	pageNumber;
{
    int16	pagesPerBlock;	/* XXX use a named type */
    
    Assert(PointerIsValid(pointer));
    Assert(LogicalPageNumberIsValid(pageNumber));
    
    pagesPerBlock = PagePartitionGetPagesPerBlock(partition);
    
    if (pagesPerBlock == 1) {
	ItemPointerSimpleSet(pointer,
			     (LogicalPageNumber)(-1 + pageNumber),
			     InvalidOffsetNumber);
    } else {
	ItemPointerSet(pointer, partition,
		       (LogicalPageNumber)(-1 + pageNumber) / pagesPerBlock,
		       (LogicalPageNumber)(-1 + pageNumber) % pagesPerBlock,
		       InvalidOffsetNumber);
    }
}
@


1.8
log
@Converted IsValid code into macros and added an improved NodeIsType scheme
@
text
@d12 1
d14 1
a14 1
#include "internal.h"
a15 109
RcsId("$Header: RCS/itemptr.c,v 1.7 90/09/25 16:46:22 kemnitz Exp Locker: cimarron $");

BlockNumber
ItemPointerGetBlockNumber(pointer)
	ItemPointer	pointer;
{
	Assert(ItemPointerIsValid(pointer));
	return
	    BlockIdGetBlockNumber(&pointer->blockData);
}

PageNumber
ItemPointerGetPageNumber(pointer, partition)
	ItemPointer	pointer;
	PagePartition	partition;
{
	Assert(ItemPointerIsValid(pointer));
	return
	    PositionIdGetPageNumber(&pointer->positionData, partition);
}

OffsetNumber
ItemPointerGetOffsetNumber(pointer, partition)
	ItemPointer	pointer;
	PagePartition	partition;
{
	Assert(ItemPointerIsValid(pointer));
	return
	    PositionIdGetOffsetNumber(&pointer->positionData, partition);
}

OffsetIndex
ItemPointerGetOffsetIndex(pointer, partition)
	ItemPointer	pointer;
	PagePartition	partition;
{
	Assert(ItemPointerIsValid(pointer));
	return
	    ItemPointerGetOffsetNumber(pointer, partition) - 1;
}

void
ItemPointerSet(pointer, partition, blockNumber, pageNumber, offsetNumber)
	ItemPointer	pointer;
	PagePartition	partition;
	BlockNumber	blockNumber;
	PageNumber	pageNumber;
	OffsetNumber	offsetNumber;
{
	Assert(PointerIsValid(pointer));

	BlockIdSet(&pointer->blockData, blockNumber);
	PositionIdSet(&pointer->positionData, partition, pageNumber,
		offsetNumber);
}

void
ItemPointerCopy(fromPointer, toPointer)
	ItemPointer	fromPointer;
	ItemPointer	toPointer;
{
	Assert(PointerIsValid(toPointer));
	Assert(PointerIsValid(fromPointer));

	*toPointer = *fromPointer;
}

void
ItemPointerSetInvalid(pointer)
	ItemPointer	pointer;
{
	Assert(PointerIsValid(pointer));

	pointer->blockData.data[0] &= 0x7fff;	/* XXX byte ordering */
	pointer->positionData = 0;
}

PageNumber
ItemPointerSimpleGetPageNumber(pointer)
	ItemPointer	pointer;
{
	return (ItemPointerGetPageNumber(pointer, SinglePagePartition));
}


OffsetNumber
ItemPointerSimpleGetOffsetNumber(pointer)
	ItemPointer	pointer;
{
	return (ItemPointerGetOffsetNumber(pointer, SinglePagePartition));
}

OffsetIndex
ItemPointerSimpleGetOffsetIndex(pointer)
	ItemPointer	pointer;
{
	return (ItemPointerGetOffsetIndex(pointer, SinglePagePartition));
}

void
ItemPointerSimpleSet(pointer, blockNumber, offsetNumber)
	ItemPointer	pointer;
	BlockNumber	blockNumber;
	OffsetNumber	offsetNumber;
{
	ItemPointerSet(pointer, SinglePagePartition, blockNumber,
		FirstPageNumber, offsetNumber);
}

d18 2
a19 1
    ItemPointer pointer1, pointer2;
d25 1
a25 1
            return(true);
a29 2
/* #ifndef	POSTMASTER */

d32 2
a33 2
	ItemPointer	pointer;
	PagePartition	partition;
d35 10
a44 10
	int16	pagesPerBlock;	/* XXX use a named type */

	Assert(ItemPointerIsValid(pointer));

	pagesPerBlock = PagePartitionGetPagesPerBlock(partition);
	if (pagesPerBlock == 1) {
		return (1 + ItemPointerGetBlockNumber(pointer));
	}
	return (1 + ItemPointerGetPageNumber(pointer, partition) +
		pagesPerBlock * ItemPointerGetBlockNumber(pointer));
d49 3
a51 3
	ItemPointer		pointer;
	PagePartition		partition;
	LogicalPageNumber	pageNumber;
d53 17
a69 17
	int16	pagesPerBlock;	/* XXX use a named type */

	Assert(PointerIsValid(pointer));
	Assert(LogicalPageNumberIsValid(pageNumber));

	pagesPerBlock = PagePartitionGetPagesPerBlock(partition);

	if (pagesPerBlock == 1) {
		ItemPointerSimpleSet(pointer,
			(LogicalPageNumber)(-1 + pageNumber),
			InvalidOffsetNumber);
	} else {
		ItemPointerSet(pointer, partition,
			(LogicalPageNumber)(-1 + pageNumber) / pagesPerBlock,
			(LogicalPageNumber)(-1 + pageNumber) % pagesPerBlock,
			InvalidOffsetNumber);
	}
a70 1
/* #endif	/* !defined(POSTMASTER) */
@


1.7
log
@Updating from revision 1.6 to revision 1.7
@
text
@d15 1
a15 1
RcsId("$Header: RCS/itemptr.c,v 1.7 90/08/14 16:05:04 cimarron Exp $");
a16 24
bool
ItemPointerIsUserDefined(pointer)
	ItemPointer	pointer;
{
	if (!PointerIsValid(pointer)) {
		return (false);
	} else {
		return ((bool)(pointer->blockData.data[0] & 0x8000)); /* XXX */
	}
}

bool
ItemPointerIsValid(pointer)
	ItemPointer	pointer;
{
	Assert(!ItemPointerIsUserDefined(pointer));

	if (!PointerIsValid(pointer)) {
		return (false);
	} else {
		return ((bool)(pointer->positionData != 0));
	}
}

d21 3
a23 3
	Assert(!ItemPointerIsUserDefined(pointer));

	return (BlockIdGetBlockNumber(&pointer->blockData));
d31 3
a33 3
	Assert(!ItemPointerIsUserDefined(pointer));

	return (PositionIdGetPageNumber(&pointer->positionData, partition));
d41 3
a43 3
	Assert(!ItemPointerIsUserDefined(pointer));

	return (PositionIdGetOffsetNumber(&pointer->positionData, partition));
d51 3
a53 3
	Assert(!ItemPointerIsUserDefined(pointer));

	return (ItemPointerGetOffsetNumber(pointer, partition) - 1);
d146 1
a146 1
	Assert(!ItemPointerIsUserDefined(pointer));
@


1.6
log
@reverting back because can't resolve name references
in any suitable way.

@
text
@d6 1
a6 1
#include "c.h"
d8 4
a11 2
#include "block.h"
#include "off.h"
a12 3
#include "page.h"

#include "itemptr.h"
d15 1
a15 1
RcsId("$Header: RCS/itemptr.c,v 1.5 89/09/25 10:57:41 goh Exp $");
@


1.5
log
@added back #ifdef's for POSTMASTER
@
text
@d16 1
a16 1
RcsId("$Header: RCS/itemptr.c,v 1.2 89/02/02 15:35:12 dillon Stab $");
d162 1
a162 1
#ifndef	POSTMASTER
d205 1
a205 1
#endif	/* !defined(POSTMASTER) */
@


1.4
log
@Working version of C-only demo
@
text
@d16 1
a16 1
RcsId("$Header: /usr6/postgres/mao/postgres/src/storage/page/RCS/itemptr.c,v 1.3 89/07/17 15:01:36 dillon Exp $");
d162 1
a162 1
/* #ifndef	POSTMASTER ADDED BACK 14 July 1989 */
d205 1
a205 3

/* #endif	/* !defined(POSTMASTER) ADDED BACK 14 July 1989 */

@


1.3
log
@#ifdef's for postmaster removed for now
@
text
@d16 1
a16 1
RcsId("$Header: itemptr.c,v 1.2 89/02/02 15:35:12 dillon Locked $");
@


1.2
log
@Txfer From old tree
@
text
@d16 1
a16 1
RcsId("$Header: itemptr.c,v 1.8 88/08/19 01:53:12 dillon Locked $");
d162 1
a162 1
#ifndef	POSTMASTER
d205 3
a207 1
#endif	/* !defined(POSTMASTER) */
@


1.1
log
@Initial revision
@
text
@a0 1

a1 26
 * 
 * POSTGRES Data Base Management System
 * 
 * Copyright (c) 1988 Regents of the University of California
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for educational, research, and non-profit purposes and
 * without fee is hereby granted, provided that the above copyright
 * notice appear in all copies and that both that copyright notice and
 * this permission notice appear in supporting documentation, and that
 * the name of the University of California not be used in advertising
 * or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Permission to incorporate this
 * software into commercial products can be obtained from the Campus
 * Software Office, 295 Evans Hall, University of California, Berkeley,
 * Ca., 94720 provided only that the the requestor give the University
 * of California a free licence to any derived software for educational
 * and research purposes.  The University of California makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 * 
 */



/*
d16 1
a16 1
RcsId("$Header: itemptr.c,v 1.1 88/11/11 16:37:42 postgres Exp $");
@