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