toast_pointer.va_extsize = data_todo;
}
- toast_pointer.va_valueid = GetNewOidWithIndex(toastrel, toastidx);
+ toast_pointer.va_valueid = GetNewOidWithIndex(toastrel,
+ RelationGetRelid(toastidx),
+ (AttrNumber) 1);
toast_pointer.va_toastrelid = rel->rd_rel->reltoastrelid;
/*
Relation toastrel;
Relation toastidx;
ScanKeyData toastkey;
- IndexScanDesc toastscan;
+ SysScanDesc toastscan;
HeapTuple toasttup;
if (!VARATT_IS_EXTERNAL(attr))
toastidx = index_open(toastrel->rd_rel->reltoastidxid, RowExclusiveLock);
/*
- * Setup a scan key to fetch from the index by va_valueid (we don't
- * particularly care whether we see them in sequence or not)
+ * Setup a scan key to find chunks with matching va_valueid
*/
ScanKeyInit(&toastkey,
(AttrNumber) 1,
ObjectIdGetDatum(toast_pointer.va_valueid));
/*
- * Find the chunks by index
+ * Find all the chunks. (We don't actually care whether we see them in
+ * sequence or not, but since we've already locked the index we might
+ * as well use systable_beginscan_ordered.)
*/
- toastscan = index_beginscan(toastrel, toastidx,
- SnapshotToast, 1, &toastkey);
- while ((toasttup = index_getnext(toastscan, ForwardScanDirection)) != NULL)
+ toastscan = systable_beginscan_ordered(toastrel, toastidx,
+ SnapshotToast, 1, &toastkey);
+ while ((toasttup = systable_getnext_ordered(toastscan, ForwardScanDirection)) != NULL)
{
/*
* Have a chunk, delete it
/*
* End scan and close relations
*/
- index_endscan(toastscan);
+ systable_endscan_ordered(toastscan);
index_close(toastidx, RowExclusiveLock);
heap_close(toastrel, RowExclusiveLock);
}
Relation toastrel;
Relation toastidx;
ScanKeyData toastkey;
- IndexScanDesc toastscan;
+ SysScanDesc toastscan;
HeapTuple ttup;
TupleDesc toasttupDesc;
struct varlena *result;
*/
nextidx = 0;
- toastscan = index_beginscan(toastrel, toastidx,
- SnapshotToast, 1, &toastkey);
- while ((ttup = index_getnext(toastscan, ForwardScanDirection)) != NULL)
+ toastscan = systable_beginscan_ordered(toastrel, toastidx,
+ SnapshotToast, 1, &toastkey);
+ while ((ttup = systable_getnext_ordered(toastscan, ForwardScanDirection)) != NULL)
{
/*
* Have a chunk, extract the sequence number and the data
/*
* End scan and close relations
*/
- index_endscan(toastscan);
+ systable_endscan_ordered(toastscan);
index_close(toastidx, AccessShareLock);
heap_close(toastrel, AccessShareLock);
Relation toastidx;
ScanKeyData toastkey[3];
int nscankeys;
- IndexScanDesc toastscan;
+ SysScanDesc toastscan;
HeapTuple ttup;
TupleDesc toasttupDesc;
struct varlena *result;
* The index is on (valueid, chunkidx) so they will come in order
*/
nextidx = startchunk;
- toastscan = index_beginscan(toastrel, toastidx,
- SnapshotToast, nscankeys, toastkey);
- while ((ttup = index_getnext(toastscan, ForwardScanDirection)) != NULL)
+ toastscan = systable_beginscan_ordered(toastrel, toastidx,
+ SnapshotToast, nscankeys, toastkey);
+ while ((ttup = systable_getnext_ordered(toastscan, ForwardScanDirection)) != NULL)
{
/*
* Have a chunk, extract the sequence number and the data
/*
* End scan and close relations
*/
- index_endscan(toastscan);
+ systable_endscan_ordered(toastscan);
index_close(toastidx, AccessShareLock);
heap_close(toastrel, AccessShareLock);
pfree(sysscan);
}
+
+
+/*
+ * systable_beginscan_ordered --- set up for ordered catalog scan
+ *
+ * These routines have essentially the same API as systable_beginscan etc,
+ * except that they guarantee to return multiple matching tuples in
+ * index order. Also, for largely historical reasons, the index to use
+ * is opened and locked by the caller, not here.
+ *
+ * Currently we do not support non-index-based scans here. (In principle
+ * we could do a heapscan and sort, but the uses are in places that
+ * probably don't need to still work with corrupted catalog indexes.)
+ * For the moment, therefore, these functions are merely the thinnest of
+ * wrappers around index_beginscan/index_getnext. The main reason for their
+ * existence is to centralize possible future support of lossy operators
+ * in catalog scans.
+ */
+SysScanDesc
+systable_beginscan_ordered(Relation heapRelation,
+ Relation indexRelation,
+ Snapshot snapshot,
+ int nkeys, ScanKey key)
+{
+ SysScanDesc sysscan;
+ int i;
+
+ /* REINDEX can probably be a hard error here ... */
+ if (ReindexIsProcessingIndex(RelationGetRelid(indexRelation)))
+ elog(ERROR, "cannot do ordered scan on index \"%s\", because it is the current REINDEX target",
+ RelationGetRelationName(indexRelation));
+ /* ... but we only throw a warning about violating IgnoreSystemIndexes */
+ if (IgnoreSystemIndexes)
+ elog(WARNING, "using index \"%s\" despite IgnoreSystemIndexes",
+ RelationGetRelationName(indexRelation));
+
+ sysscan = (SysScanDesc) palloc(sizeof(SysScanDescData));
+
+ sysscan->heap_rel = heapRelation;
+ sysscan->irel = indexRelation;
+
+ /*
+ * Change attribute numbers to be index column numbers.
+ *
+ * This code could be generalized to search for the index key numbers
+ * to substitute, but for now there's no need.
+ */
+ for (i = 0; i < nkeys; i++)
+ {
+ Assert(key[i].sk_attno == indexRelation->rd_index->indkey.values[i]);
+ key[i].sk_attno = i + 1;
+ }
+
+ sysscan->iscan = index_beginscan(heapRelation, indexRelation,
+ snapshot, nkeys, key);
+ sysscan->scan = NULL;
+
+ return sysscan;
+}
+
+/*
+ * systable_getnext_ordered --- get next tuple in an ordered catalog scan
+ */
+HeapTuple
+systable_getnext_ordered(SysScanDesc sysscan, ScanDirection direction)
+{
+ HeapTuple htup;
+
+ Assert(sysscan->irel);
+ htup = index_getnext(sysscan->iscan, direction);
+
+ return htup;
+}
+
+/*
+ * systable_endscan_ordered --- close scan, release resources
+ */
+void
+systable_endscan_ordered(SysScanDesc sysscan)
+{
+ Assert(sysscan->irel);
+ index_endscan(sysscan->iscan);
+ pfree(sysscan);
+}
/*
* index_beginscan - start a scan of an index with amgettuple
*
- * Note: heapRelation may be NULL if there is no intention of calling
- * index_getnext on this scan; index_getnext_indexitem will not use the
- * heapRelation link (nor the snapshot). However, the caller had better
- * be holding some kind of lock on the heap relation in any case, to ensure
- * no one deletes it (or the index) out from under us. Caller must also
- * be holding a lock on the index.
+ * Caller must be holding suitable locks on the heap and the index.
*/
IndexScanDesc
index_beginscan(Relation heapRelation,
return NULL; /* failure exit */
}
-/* ----------------
- * index_getnext_indexitem - get the next index tuple from a scan
- *
- * Finds the next index tuple satisfying the scan keys. Note that the
- * corresponding heap tuple is not accessed, and thus no time qual (snapshot)
- * check is done, other than the index AM's internal check for killed tuples
- * (which most callers of this routine will probably want to suppress by
- * setting scan->ignore_killed_tuples = false).
- *
- * On success (TRUE return), the heap TID of the found index entry is in
- * scan->xs_ctup.t_self. scan->xs_cbuf is untouched.
- * ----------------
- */
-bool
-index_getnext_indexitem(IndexScanDesc scan,
- ScanDirection direction)
-{
- FmgrInfo *procedure;
- bool found;
-
- SCAN_CHECKS;
- GET_SCAN_PROCEDURE(amgettuple);
-
- /* just make sure this is false... */
- scan->kill_prior_tuple = false;
-
- /*
- * have the am's gettuple proc do all the work.
- */
- found = DatumGetBool(FunctionCall2(procedure,
- PointerGetDatum(scan),
- Int32GetDatum(direction)));
-
- if (found)
- pgstat_count_index_tuples(scan->indexRelation, 1);
-
- return found;
-}
-
/* ----------------
* index_getbitmap - get all tuples at once from an index scan
*
Oid
GetNewOid(Relation relation)
{
- Oid newOid;
Oid oidIndex;
- Relation indexrel;
/* If relation doesn't have OIDs at all, caller is confused */
Assert(relation->rd_rel->relhasoids);
}
/* Otherwise, use the index to find a nonconflicting OID */
- indexrel = index_open(oidIndex, AccessShareLock);
- newOid = GetNewOidWithIndex(relation, indexrel);
- index_close(indexrel, AccessShareLock);
-
- return newOid;
+ return GetNewOidWithIndex(relation, oidIndex, ObjectIdAttributeNumber);
}
/*
* an index that will not be recognized by RelationGetOidIndex: TOAST tables
* and pg_largeobject have indexes that are usable, but have multiple columns
* and are on ordinary columns rather than a true OID column. This code
- * will work anyway, so long as the OID is the index's first column.
+ * will work anyway, so long as the OID is the index's first column. The
+ * caller must pass in the actual heap attnum of the OID column, however.
*
* Caller must have a suitable lock on the relation.
*/
Oid
-GetNewOidWithIndex(Relation relation, Relation indexrel)
+GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn)
{
Oid newOid;
SnapshotData SnapshotDirty;
- IndexScanDesc scan;
+ SysScanDesc scan;
ScanKeyData key;
bool collides;
newOid = GetNewObjectId();
ScanKeyInit(&key,
- (AttrNumber) 1,
+ oidcolumn,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(newOid));
/* see notes above about using SnapshotDirty */
- scan = index_beginscan(relation, indexrel,
- &SnapshotDirty, 1, &key);
+ scan = systable_beginscan(relation, indexId, true,
+ &SnapshotDirty, 1, &key);
- collides = HeapTupleIsValid(index_getnext(scan, ForwardScanDirection));
+ collides = HeapTupleIsValid(systable_getnext(scan));
- index_endscan(scan);
+ systable_endscan(scan);
} while (collides);
return newOid;
{
open_lo_relation();
- lobjId = GetNewOidWithIndex(lo_heap_r, lo_index_r);
+ lobjId = GetNewOidWithIndex(lo_heap_r, LargeObjectLOidPNIndexId,
+ Anum_pg_largeobject_loid);
}
/*
bool found = false;
uint32 lastbyte = 0;
ScanKeyData skey[1];
- IndexScanDesc sd;
+ SysScanDesc sd;
HeapTuple tuple;
Assert(PointerIsValid(obj_desc));
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(obj_desc->id));
- sd = index_beginscan(lo_heap_r, lo_index_r,
- obj_desc->snapshot, 1, skey);
+ sd = systable_beginscan_ordered(lo_heap_r, lo_index_r,
+ obj_desc->snapshot, 1, skey);
/*
* Because the pg_largeobject index is on both loid and pageno, but we
* large object in reverse pageno order. So, it's sufficient to examine
* the first valid tuple (== last valid page).
*/
- while ((tuple = index_getnext(sd, BackwardScanDirection)) != NULL)
+ while ((tuple = systable_getnext_ordered(sd, BackwardScanDirection)) != NULL)
{
Form_pg_largeobject data;
bytea *datafield;
break;
}
- index_endscan(sd);
+ systable_endscan_ordered(sd);
if (!found)
ereport(ERROR,
int32 pageno = (int32) (obj_desc->offset / LOBLKSIZE);
uint32 pageoff;
ScanKeyData skey[2];
- IndexScanDesc sd;
+ SysScanDesc sd;
HeapTuple tuple;
Assert(PointerIsValid(obj_desc));
BTGreaterEqualStrategyNumber, F_INT4GE,
Int32GetDatum(pageno));
- sd = index_beginscan(lo_heap_r, lo_index_r,
- obj_desc->snapshot, 2, skey);
+ sd = systable_beginscan_ordered(lo_heap_r, lo_index_r,
+ obj_desc->snapshot, 2, skey);
- while ((tuple = index_getnext(sd, ForwardScanDirection)) != NULL)
+ while ((tuple = systable_getnext_ordered(sd, ForwardScanDirection)) != NULL)
{
Form_pg_largeobject data;
bytea *datafield;
data = (Form_pg_largeobject) GETSTRUCT(tuple);
/*
- * We assume the indexscan will deliver pages in order. However,
+ * We expect the indexscan will deliver pages in order. However,
* there may be missing pages if the LO contains unwritten "holes". We
* want missing sections to read out as zeroes.
*/
break;
}
- index_endscan(sd);
+ systable_endscan_ordered(sd);
return nread;
}
int len;
int32 pageno = (int32) (obj_desc->offset / LOBLKSIZE);
ScanKeyData skey[2];
- IndexScanDesc sd;
+ SysScanDesc sd;
HeapTuple oldtuple;
Form_pg_largeobject olddata;
bool neednextpage;
BTGreaterEqualStrategyNumber, F_INT4GE,
Int32GetDatum(pageno));
- sd = index_beginscan(lo_heap_r, lo_index_r,
- obj_desc->snapshot, 2, skey);
+ sd = systable_beginscan_ordered(lo_heap_r, lo_index_r,
+ obj_desc->snapshot, 2, skey);
oldtuple = NULL;
olddata = NULL;
while (nwritten < nbytes)
{
/*
- * If possible, get next pre-existing page of the LO. We assume the
+ * If possible, get next pre-existing page of the LO. We expect the
* indexscan will deliver these in order --- but there may be holes.
*/
if (neednextpage)
{
- if ((oldtuple = index_getnext(sd, ForwardScanDirection)) != NULL)
+ if ((oldtuple = systable_getnext_ordered(sd, ForwardScanDirection)) != NULL)
{
if (HeapTupleHasNulls(oldtuple)) /* paranoia */
elog(ERROR, "null field found in pg_largeobject");
pageno++;
}
- index_endscan(sd);
+ systable_endscan_ordered(sd);
CatalogCloseIndexes(indstate);
int32 pageno = (int32) (len / LOBLKSIZE);
int off;
ScanKeyData skey[2];
- IndexScanDesc sd;
+ SysScanDesc sd;
HeapTuple oldtuple;
Form_pg_largeobject olddata;
struct
BTGreaterEqualStrategyNumber, F_INT4GE,
Int32GetDatum(pageno));
- sd = index_beginscan(lo_heap_r, lo_index_r,
- obj_desc->snapshot, 2, skey);
+ sd = systable_beginscan_ordered(lo_heap_r, lo_index_r,
+ obj_desc->snapshot, 2, skey);
/*
* If possible, get the page the truncation point is in. The truncation
* point may be beyond the end of the LO or in a hole.
*/
olddata = NULL;
- if ((oldtuple = index_getnext(sd, ForwardScanDirection)) != NULL)
+ if ((oldtuple = systable_getnext_ordered(sd, ForwardScanDirection)) != NULL)
{
if (HeapTupleHasNulls(oldtuple)) /* paranoia */
elog(ERROR, "null field found in pg_largeobject");
/*
* Delete any pages after the truncation point
*/
- while ((oldtuple = index_getnext(sd, ForwardScanDirection)) != NULL)
+ while ((oldtuple = systable_getnext_ordered(sd, ForwardScanDirection)) != NULL)
{
simple_heap_delete(lo_heap_r, &oldtuple->t_self);
}
- index_endscan(sd);
+ systable_endscan_ordered(sd);
CatalogCloseIndexes(indstate);
Relation maprel;
Relation mapidx;
ScanKeyData mapskey;
- IndexScanDesc mapscan;
+ SysScanDesc mapscan;
HeapTuple maptup;
ListDictionary maplists[MAXTOKENTYPE + 1];
Oid mapdicts[MAXDICTSPERTT];
maprel = heap_open(TSConfigMapRelationId, AccessShareLock);
mapidx = index_open(TSConfigMapIndexId, AccessShareLock);
- mapscan = index_beginscan(maprel, mapidx, SnapshotNow, 1, &mapskey);
+ mapscan = systable_beginscan_ordered(maprel, mapidx,
+ SnapshotNow, 1, &mapskey);
- while ((maptup = index_getnext(mapscan, ForwardScanDirection)) != NULL)
+ while ((maptup = systable_getnext_ordered(mapscan, ForwardScanDirection)) != NULL)
{
Form_pg_ts_config_map cfgmap = (Form_pg_ts_config_map) GETSTRUCT(maptup);
int toktype = cfgmap->maptokentype;
}
}
- index_endscan(mapscan);
+ systable_endscan_ordered(mapscan);
index_close(mapidx, AccessShareLock);
heap_close(maprel, AccessShareLock);
extern void index_markpos(IndexScanDesc scan);
extern void index_restrpos(IndexScanDesc scan);
extern HeapTuple index_getnext(IndexScanDesc scan, ScanDirection direction);
-extern bool index_getnext_indexitem(IndexScanDesc scan,
- ScanDirection direction);
extern int64 index_getbitmap(IndexScanDesc scan, TIDBitmap *bitmap);
extern IndexBulkDeleteResult *index_bulk_delete(IndexVacuumInfo *info,
int nkeys, ScanKey key);
extern HeapTuple systable_getnext(SysScanDesc sysscan);
extern void systable_endscan(SysScanDesc sysscan);
+extern SysScanDesc systable_beginscan_ordered(Relation heapRelation,
+ Relation indexRelation,
+ Snapshot snapshot,
+ int nkeys, ScanKey key);
+extern HeapTuple systable_getnext_ordered(SysScanDesc sysscan,
+ ScanDirection direction);
+extern void systable_endscan_ordered(SysScanDesc sysscan);
#endif /* GENAM_H */
/* index access method's private state */
void *opaque; /* access-method-specific info */
- /*
- * xs_ctup/xs_cbuf are valid after a successful index_getnext. After
- * index_getnext_indexitem, xs_ctup.t_self contains the heap tuple TID
- * from the index entry, but its other fields are not valid.
- */
+ /* xs_ctup/xs_cbuf are valid after a successful index_getnext */
HeapTupleData xs_ctup; /* current heap tuple, if any */
Buffer xs_cbuf; /* current heap buffer in scan, if any */
/* NB: if xs_cbuf is not InvalidBuffer, we hold a pin on that buffer */
+
+ /* state data for traversing HOT chains in index_getnext */
TransactionId xs_prev_xmax; /* previous HOT chain member's XMAX, if any */
OffsetNumber xs_next_hot; /* next member of HOT chain, if any */
bool xs_hot_dead; /* T if all members of HOT chain are dead */
extern bool IsSharedRelation(Oid relationId);
extern Oid GetNewOid(Relation relation);
-extern Oid GetNewOidWithIndex(Relation relation, Relation indexrel);
+extern Oid GetNewOidWithIndex(Relation relation, Oid indexId,
+ AttrNumber oidcolumn);
extern Oid GetNewRelFileNode(Oid reltablespace, bool relisshared,
Relation pg_class);
projects / users / simon / postgres.git / commitdiff