168d5805e4
The newly added ON CONFLICT clause allows to specify an alternative to
raising a unique or exclusion constraint violation error when inserting.
ON CONFLICT refers to constraints that can either be specified using a
inference clause (by specifying the columns of a unique constraint) or
by naming a unique or exclusion constraint. DO NOTHING avoids the
constraint violation, without touching the pre-existing row. DO UPDATE
SET ... [WHERE ...] updates the pre-existing tuple, and has access to
both the tuple proposed for insertion and the existing tuple; the
optional WHERE clause can be used to prevent an update from being
executed. The UPDATE SET and WHERE clauses have access to the tuple
proposed for insertion using the "magic" EXCLUDED alias, and to the
pre-existing tuple using the table name or its alias.
This feature is often referred to as upsert.
This is implemented using a new infrastructure called "speculative
insertion". It is an optimistic variant of regular insertion that first
does a pre-check for existing tuples and then attempts an insert. If a
violating tuple was inserted concurrently, the speculatively inserted
tuple is deleted and a new attempt is made. If the pre-check finds a
matching tuple the alternative DO NOTHING or DO UPDATE action is taken.
If the insertion succeeds without detecting a conflict, the tuple is
deemed inserted.
To handle the possible ambiguity between the excluded alias and a table
named excluded, and for convenience with long relation names, INSERT
INTO now can alias its target table.
Bumps catversion as stored rules change.
Author: Peter Geoghegan, with significant contributions from Heikki
Linnakangas and Andres Freund. Testing infrastructure by Jeff Janes.
Reviewed-By: Heikki Linnakangas, Andres Freund, Robert Haas, Simon Riggs,
Dean Rasheed, Stephen Frost and many others.
187 lines
7.0 KiB
C
187 lines
7.0 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 void heap_setscanlimits(HeapScanDesc scan, BlockNumber startBlk,
|
|
BlockNumber endBlk);
|
|
extern void heap_rescan(HeapScanDesc scan, ScanKey key);
|
|
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 */
|