mirror of
https://github.com/postgres/postgres.git
synced 2026-04-15 22:10:45 -04:00
6fcb337fa5
The original implementation of TABLESAMPLE modeled the tablesample method API on index access methods, which wasn't a good choice because, without specialized DDL commands, there's no way to build an extension that can implement a TSM. (Raw inserts into system catalogs are not an acceptable thing to do, because we can't undo them during DROP EXTENSION, nor will pg_upgrade behave sanely.) Instead adopt an API more like procedural language handlers or foreign data wrappers, wherein the only SQL-level support object needed is a single handler function identified by having a special return type. This lets us get rid of the supporting catalog altogether, so that no custom DDL support is needed for the feature. Adjust the API so that it can support non-constant tablesample arguments (the original coding assumed we could evaluate the argument expressions at ExecInitSampleScan time, which is undesirable even if it weren't outright unsafe), and discourage sampling methods from looking at invisible tuples. Make sure that the BERNOULLI and SYSTEM methods are genuinely repeatable within and across queries, as required by the SQL standard, and deal more honestly with methods that can't support that requirement. Make a full code-review pass over the tablesample additions, and fix assorted bugs, omissions, infelicities, and cosmetic issues (such as failure to put the added code stanzas in a consistent ordering). Improve EXPLAIN's output of tablesample plans, too. Back-patch to 9.5 so that we don't have to support the original API in production.
192 lines
7.3 KiB
C
192 lines
7.3 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* heapam.h
|
|
* POSTGRES heap access method definitions.
|
|
*
|
|
*
|
|
* Portions Copyright (c) 1996-2015, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
* src/include/access/heapam.h
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#ifndef HEAPAM_H
|
|
#define HEAPAM_H
|
|
|
|
#include "access/sdir.h"
|
|
#include "access/skey.h"
|
|
#include "nodes/lockoptions.h"
|
|
#include "nodes/primnodes.h"
|
|
#include "storage/bufpage.h"
|
|
#include "storage/lock.h"
|
|
#include "utils/relcache.h"
|
|
#include "utils/snapshot.h"
|
|
|
|
|
|
/* "options" flag bits for heap_insert */
|
|
#define HEAP_INSERT_SKIP_WAL 0x0001
|
|
#define HEAP_INSERT_SKIP_FSM 0x0002
|
|
#define HEAP_INSERT_FROZEN 0x0004
|
|
#define HEAP_INSERT_SPECULATIVE 0x0008
|
|
|
|
typedef struct BulkInsertStateData *BulkInsertState;
|
|
|
|
/*
|
|
* Possible lock modes for a tuple.
|
|
*/
|
|
typedef enum LockTupleMode
|
|
{
|
|
/* SELECT FOR KEY SHARE */
|
|
LockTupleKeyShare,
|
|
/* SELECT FOR SHARE */
|
|
LockTupleShare,
|
|
/* SELECT FOR NO KEY UPDATE, and UPDATEs that don't modify key columns */
|
|
LockTupleNoKeyExclusive,
|
|
/* SELECT FOR UPDATE, UPDATEs that modify key columns, and DELETE */
|
|
LockTupleExclusive
|
|
} LockTupleMode;
|
|
|
|
#define MaxLockTupleMode LockTupleExclusive
|
|
|
|
/*
|
|
* When heap_update, heap_delete, or heap_lock_tuple fail because the target
|
|
* tuple is already outdated, they fill in this struct to provide information
|
|
* to the caller about what happened.
|
|
* ctid is the target's ctid link: it is the same as the target's TID if the
|
|
* target was deleted, or the location of the replacement tuple if the target
|
|
* was updated.
|
|
* xmax is the outdating transaction's XID. If the caller wants to visit the
|
|
* replacement tuple, it must check that this matches before believing the
|
|
* replacement is really a match.
|
|
* cmax is the outdating command's CID, but only when the failure code is
|
|
* HeapTupleSelfUpdated (i.e., something in the current transaction outdated
|
|
* the tuple); otherwise cmax is zero. (We make this restriction because
|
|
* HeapTupleHeaderGetCmax doesn't work for tuples outdated in other
|
|
* transactions.)
|
|
*/
|
|
typedef struct HeapUpdateFailureData
|
|
{
|
|
ItemPointerData ctid;
|
|
TransactionId xmax;
|
|
CommandId cmax;
|
|
} HeapUpdateFailureData;
|
|
|
|
|
|
/* ----------------
|
|
* function prototypes for heap access method
|
|
*
|
|
* heap_create, heap_create_with_catalog, and heap_drop_with_catalog
|
|
* are declared in catalog/heap.h
|
|
* ----------------
|
|
*/
|
|
|
|
/* in heap/heapam.c */
|
|
extern Relation relation_open(Oid relationId, LOCKMODE lockmode);
|
|
extern Relation try_relation_open(Oid relationId, LOCKMODE lockmode);
|
|
extern Relation relation_openrv(const RangeVar *relation, LOCKMODE lockmode);
|
|
extern Relation relation_openrv_extended(const RangeVar *relation,
|
|
LOCKMODE lockmode, bool missing_ok);
|
|
extern void relation_close(Relation relation, LOCKMODE lockmode);
|
|
|
|
extern Relation heap_open(Oid relationId, LOCKMODE lockmode);
|
|
extern Relation heap_openrv(const RangeVar *relation, LOCKMODE lockmode);
|
|
extern Relation heap_openrv_extended(const RangeVar *relation,
|
|
LOCKMODE lockmode, bool missing_ok);
|
|
|
|
#define heap_close(r,l) relation_close(r,l)
|
|
|
|
/* struct definition appears in relscan.h */
|
|
typedef struct HeapScanDescData *HeapScanDesc;
|
|
|
|
/*
|
|
* HeapScanIsValid
|
|
* True iff the heap scan is valid.
|
|
*/
|
|
#define HeapScanIsValid(scan) PointerIsValid(scan)
|
|
|
|
extern HeapScanDesc heap_beginscan(Relation relation, Snapshot snapshot,
|
|
int nkeys, ScanKey key);
|
|
extern HeapScanDesc heap_beginscan_catalog(Relation relation, int nkeys,
|
|
ScanKey key);
|
|
extern HeapScanDesc heap_beginscan_strat(Relation relation, Snapshot snapshot,
|
|
int nkeys, ScanKey key,
|
|
bool allow_strat, bool allow_sync);
|
|
extern HeapScanDesc heap_beginscan_bm(Relation relation, Snapshot snapshot,
|
|
int nkeys, ScanKey key);
|
|
extern HeapScanDesc heap_beginscan_sampling(Relation relation,
|
|
Snapshot snapshot, int nkeys, ScanKey key,
|
|
bool allow_strat, bool allow_sync, bool allow_pagemode);
|
|
extern void heap_setscanlimits(HeapScanDesc scan, BlockNumber startBlk,
|
|
BlockNumber endBlk);
|
|
extern void heapgetpage(HeapScanDesc scan, BlockNumber page);
|
|
extern void heap_rescan(HeapScanDesc scan, ScanKey key);
|
|
extern void heap_rescan_set_params(HeapScanDesc scan, ScanKey key,
|
|
bool allow_strat, bool allow_sync, bool allow_pagemode);
|
|
extern void heap_endscan(HeapScanDesc scan);
|
|
extern HeapTuple heap_getnext(HeapScanDesc scan, ScanDirection direction);
|
|
|
|
extern bool heap_fetch(Relation relation, Snapshot snapshot,
|
|
HeapTuple tuple, Buffer *userbuf, bool keep_buf,
|
|
Relation stats_relation);
|
|
extern bool heap_hot_search_buffer(ItemPointer tid, Relation relation,
|
|
Buffer buffer, Snapshot snapshot, HeapTuple heapTuple,
|
|
bool *all_dead, bool first_call);
|
|
extern bool heap_hot_search(ItemPointer tid, Relation relation,
|
|
Snapshot snapshot, bool *all_dead);
|
|
|
|
extern void heap_get_latest_tid(Relation relation, Snapshot snapshot,
|
|
ItemPointer tid);
|
|
extern void setLastTid(const ItemPointer tid);
|
|
|
|
extern BulkInsertState GetBulkInsertState(void);
|
|
extern void FreeBulkInsertState(BulkInsertState);
|
|
|
|
extern Oid heap_insert(Relation relation, HeapTuple tup, CommandId cid,
|
|
int options, BulkInsertState bistate);
|
|
extern void heap_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
|
|
CommandId cid, int options, BulkInsertState bistate);
|
|
extern HTSU_Result heap_delete(Relation relation, ItemPointer tid,
|
|
CommandId cid, Snapshot crosscheck, bool wait,
|
|
HeapUpdateFailureData *hufd);
|
|
extern void heap_finish_speculative(Relation relation, HeapTuple tuple);
|
|
extern void heap_abort_speculative(Relation relation, HeapTuple tuple);
|
|
extern HTSU_Result heap_update(Relation relation, ItemPointer otid,
|
|
HeapTuple newtup,
|
|
CommandId cid, Snapshot crosscheck, bool wait,
|
|
HeapUpdateFailureData *hufd, LockTupleMode *lockmode);
|
|
extern HTSU_Result heap_lock_tuple(Relation relation, HeapTuple tuple,
|
|
CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy,
|
|
bool follow_update,
|
|
Buffer *buffer, HeapUpdateFailureData *hufd);
|
|
extern void heap_inplace_update(Relation relation, HeapTuple tuple);
|
|
extern bool heap_freeze_tuple(HeapTupleHeader tuple, TransactionId cutoff_xid,
|
|
TransactionId cutoff_multi);
|
|
extern bool heap_tuple_needs_freeze(HeapTupleHeader tuple, TransactionId cutoff_xid,
|
|
MultiXactId cutoff_multi, Buffer buf);
|
|
|
|
extern Oid simple_heap_insert(Relation relation, HeapTuple tup);
|
|
extern void simple_heap_delete(Relation relation, ItemPointer tid);
|
|
extern void simple_heap_update(Relation relation, ItemPointer otid,
|
|
HeapTuple tup);
|
|
|
|
extern void heap_sync(Relation relation);
|
|
|
|
/* in heap/pruneheap.c */
|
|
extern void heap_page_prune_opt(Relation relation, Buffer buffer);
|
|
extern int heap_page_prune(Relation relation, Buffer buffer,
|
|
TransactionId OldestXmin,
|
|
bool report_stats, TransactionId *latestRemovedXid);
|
|
extern void heap_page_prune_execute(Buffer buffer,
|
|
OffsetNumber *redirected, int nredirected,
|
|
OffsetNumber *nowdead, int ndead,
|
|
OffsetNumber *nowunused, int nunused);
|
|
extern void heap_get_root_tuples(Page page, OffsetNumber *root_offsets);
|
|
|
|
/* in heap/syncscan.c */
|
|
extern void ss_report_location(Relation rel, BlockNumber location);
|
|
extern BlockNumber ss_get_location(Relation rel, BlockNumber relnblocks);
|
|
extern void SyncScanShmemInit(void);
|
|
extern Size SyncScanShmemSize(void);
|
|
|
|
#endif /* HEAPAM_H */
|