1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* hio.c
|
1997-09-07 07:04:48 +02:00
|
|
|
* POSTGRES heap access method input/output code.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
|
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2000-11-16 06:51:07 +01:00
|
|
|
* $Id: hio.c,v 1.34 2000/11/16 05:50:58 momjian Exp $
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "postgres.h"
|
1996-10-20 10:32:11 +02:00
|
|
|
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "access/heapam.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "access/hio.h"
|
1996-10-21 07:59:49 +02:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
2000-07-03 04:54:21 +02:00
|
|
|
* RelationPutHeapTuple - place tuple at specified page
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2000-07-03 04:54:21 +02:00
|
|
|
* !!! ELOG(ERROR) IS DISALLOWED HERE !!!
|
1998-12-15 13:47:01 +01:00
|
|
|
*
|
2000-07-03 04:54:21 +02:00
|
|
|
* Note - we assume that caller hold BUFFER_LOCK_EXCLUSIVE on the buffer.
|
1998-12-15 13:47:01 +01:00
|
|
|
*
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
RelationPutHeapTuple(Relation relation,
|
1998-12-15 13:47:01 +01:00
|
|
|
Buffer buffer,
|
1997-09-07 07:04:48 +02:00
|
|
|
HeapTuple tuple)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1999-05-25 18:15:34 +02:00
|
|
|
Page pageHeader;
|
|
|
|
OffsetNumber offnum;
|
2000-03-17 03:36:41 +01:00
|
|
|
Size len;
|
1999-05-25 18:15:34 +02:00
|
|
|
ItemId itemId;
|
|
|
|
Item item;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/* ----------------
|
|
|
|
* increment access statistics
|
|
|
|
* ----------------
|
|
|
|
*/
|
|
|
|
IncrHeapAccessStat(local_RelationPutHeapTuple);
|
|
|
|
IncrHeapAccessStat(global_RelationPutHeapTuple);
|
|
|
|
|
|
|
|
pageHeader = (Page) BufferGetPage(buffer);
|
2000-04-12 19:17:23 +02:00
|
|
|
len = MAXALIGN(tuple->t_len); /* be conservative */
|
2000-03-17 03:36:41 +01:00
|
|
|
Assert(len <= PageGetFreeSpace(pageHeader));
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-11-27 20:52:36 +01:00
|
|
|
offnum = PageAddItem((Page) pageHeader, (Item) tuple->t_data,
|
1997-09-07 07:04:48 +02:00
|
|
|
tuple->t_len, InvalidOffsetNumber, LP_USED);
|
|
|
|
|
2000-07-03 04:54:21 +02:00
|
|
|
if (offnum == InvalidOffsetNumber)
|
|
|
|
elog(STOP, "RelationPutHeapTuple: failed to add tuple");
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
itemId = PageGetItemId((Page) pageHeader, offnum);
|
|
|
|
item = PageGetItem((Page) pageHeader, itemId);
|
|
|
|
|
1999-05-25 18:15:34 +02:00
|
|
|
ItemPointerSet(&((HeapTupleHeader) item)->t_ctid,
|
|
|
|
BufferGetBlockNumber(buffer), offnum);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/* return an accurate tuple */
|
1998-12-15 13:47:01 +01:00
|
|
|
ItemPointerSet(&tuple->t_self, BufferGetBlockNumber(buffer), offnum);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2000-07-03 04:54:21 +02:00
|
|
|
* RelationGetBufferForTuple
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2000-09-07 11:58:38 +02:00
|
|
|
* Returns (locked) buffer with free space >= given len.
|
|
|
|
*
|
|
|
|
* Note that we use LockPage to lock relation for extension. We can
|
|
|
|
* do this as long as in all other places we use page-level locking
|
|
|
|
* for indices only. Alternatively, we could define pseudo-table as
|
|
|
|
* we do for transactions with XactLockTable.
|
1997-09-07 07:04:48 +02:00
|
|
|
*
|
2000-07-03 04:54:21 +02:00
|
|
|
* ELOG(ERROR) is allowed here, so this routine *must* be called
|
|
|
|
* before any (unlogged) changes are made in buffer pool.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*/
|
2000-07-03 04:54:21 +02:00
|
|
|
Buffer
|
2000-09-07 11:58:38 +02:00
|
|
|
RelationGetBufferForTuple(Relation relation, Size len)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
Buffer buffer;
|
|
|
|
Page pageHeader;
|
|
|
|
BlockNumber lastblock;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-03 04:54:21 +02:00
|
|
|
len = MAXALIGN(len); /* be conservative */
|
1999-11-29 05:34:55 +01:00
|
|
|
|
|
|
|
/*
|
2000-07-03 04:54:21 +02:00
|
|
|
* If we're gonna fail for oversize tuple, do it right away
|
1999-11-29 05:34:55 +01:00
|
|
|
*/
|
|
|
|
if (len > MaxTupleSize)
|
2000-11-16 06:51:07 +01:00
|
|
|
elog(ERROR, "Tuple is too big: size %lu, max size %ld",
|
|
|
|
(unsigned long)len, MaxTupleSize);
|
1999-11-29 05:34:55 +01:00
|
|
|
|
1999-02-02 04:45:56 +01:00
|
|
|
if (!relation->rd_myxactonly)
|
1999-05-07 03:23:11 +02:00
|
|
|
LockPage(relation, 0, ExclusiveLock);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX This does an lseek - VERY expensive - but at the moment it is
|
|
|
|
* the only way to accurately determine how many blocks are in a
|
|
|
|
* relation. A good optimization would be to get this to actually
|
|
|
|
* work properly.
|
|
|
|
*/
|
|
|
|
lastblock = RelationGetNumberOfBlocks(relation);
|
|
|
|
|
1999-11-29 05:34:55 +01:00
|
|
|
/*
|
2000-04-12 19:17:23 +02:00
|
|
|
* Get the last existing page --- may need to create the first one if
|
|
|
|
* this is a virgin relation.
|
1999-11-29 05:34:55 +01:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
if (lastblock == 0)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2000-09-07 11:58:38 +02:00
|
|
|
buffer = ReadBuffer(relation, P_NEW);
|
|
|
|
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
|
1997-09-07 07:04:48 +02:00
|
|
|
pageHeader = (Page) BufferGetPage(buffer);
|
1998-12-15 13:47:01 +01:00
|
|
|
Assert(PageIsNew((PageHeader) pageHeader));
|
|
|
|
PageInit(pageHeader, BufferGetPageSize(buffer), 0);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
else
|
2000-09-07 11:58:38 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
buffer = ReadBuffer(relation, lastblock - 1);
|
2000-07-03 04:54:21 +02:00
|
|
|
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
|
2000-09-07 11:58:38 +02:00
|
|
|
pageHeader = (Page) BufferGetPage(buffer);
|
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/*
|
1999-11-29 05:34:55 +01:00
|
|
|
* Is there room on the last existing page?
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
if (len > PageGetFreeSpace(pageHeader))
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2000-09-07 11:58:38 +02:00
|
|
|
LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
|
1997-09-07 07:04:48 +02:00
|
|
|
buffer = ReleaseAndReadBuffer(buffer, relation, P_NEW);
|
1998-12-15 13:47:01 +01:00
|
|
|
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
|
1997-09-07 07:04:48 +02:00
|
|
|
pageHeader = (Page) BufferGetPage(buffer);
|
2000-09-07 11:58:38 +02:00
|
|
|
Assert(PageIsNew((PageHeader) pageHeader));
|
1997-09-07 07:04:48 +02:00
|
|
|
PageInit(pageHeader, BufferGetPageSize(buffer), 0);
|
|
|
|
|
1999-07-03 03:56:16 +02:00
|
|
|
if (len > PageGetFreeSpace(pageHeader))
|
1999-11-29 05:34:55 +01:00
|
|
|
{
|
2000-07-03 04:54:21 +02:00
|
|
|
/* We should not get here given the test at the top */
|
2000-11-16 06:51:07 +01:00
|
|
|
elog(STOP, "Tuple is too big: size %lu",
|
|
|
|
(unsigned long)len);
|
1999-11-29 05:34:55 +01:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1999-02-02 04:45:56 +01:00
|
|
|
if (!relation->rd_myxactonly)
|
1999-05-07 03:23:11 +02:00
|
|
|
UnlockPage(relation, 0, ExclusiveLock);
|
1998-12-15 13:47:01 +01:00
|
|
|
|
2000-07-03 04:54:21 +02:00
|
|
|
return(buffer);
|
1998-12-15 13:47:01 +01:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|