rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove pointless const qualifiers from function arguments in the SSI code. 

As Tom Lane pointed out, "const Relation foo" doesn't guarantee that you
can't modify the data the "foo" pointer points to. It just means that you
can't change the pointer to point to something else within the function,
which is not very useful.
This commit is contained in:
Heikki Linnakangas 2011-06-22 12:18:39 +03:00
parent 503c7305a1
commit 5da417f7c4
2 changed files with 59 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
src/backend/storage/lmgr/predicate.c
View File

@ -388,7 +388,7 @@ static void ReleasePredXact(SERIALIZABLEXACT *sxact);
static SERIALIZABLEXACT *FirstPredXact(void); static SERIALIZABLEXACT *FirstPredXact(void);
static SERIALIZABLEXACT *NextPredXact(SERIALIZABLEXACT *sxact); static SERIALIZABLEXACT *NextPredXact(SERIALIZABLEXACT *sxact);
static bool RWConflictExists(const SERIALIZABLEXACT *reader, const SERIALIZABLEXACT *writer); static bool RWConflictExists(SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer);
static void SetRWConflict(SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer); static void SetRWConflict(SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer);
static void SetPossibleUnsafeConflict(SERIALIZABLEXACT *roXact, SERIALIZABLEXACT *activeXact); static void SetPossibleUnsafeConflict(SERIALIZABLEXACT *roXact, SERIALIZABLEXACT *activeXact);
static void ReleaseRWConflict(RWConflict conflict); static void ReleaseRWConflict(RWConflict conflict);
@ -404,27 +404,27 @@ static uint32 predicatelock_hash(const void *key, Size keysize);
static void SummarizeOldestCommittedSxact(void); static void SummarizeOldestCommittedSxact(void);
static Snapshot GetSafeSnapshot(Snapshot snapshot); static Snapshot GetSafeSnapshot(Snapshot snapshot);
static Snapshot RegisterSerializableTransactionInt(Snapshot snapshot); static Snapshot RegisterSerializableTransactionInt(Snapshot snapshot);
static bool PredicateLockExists(const PREDICATELOCKTARGETTAG *targettag); static bool PredicateLockExists(PREDICATELOCKTARGETTAG *targettag);
static bool GetParentPredicateLockTag(const PREDICATELOCKTARGETTAG *tag, static bool GetParentPredicateLockTag(PREDICATELOCKTARGETTAG *tag,
PREDICATELOCKTARGETTAG *parent); PREDICATELOCKTARGETTAG *parent);
static bool CoarserLockCovers(const PREDICATELOCKTARGETTAG *newtargettag); static bool CoarserLockCovers(PREDICATELOCKTARGETTAG *newtargettag);
static void RemoveScratchTarget(bool lockheld); static void RemoveScratchTarget(bool lockheld);
static void RestoreScratchTarget(bool lockheld); static void RestoreScratchTarget(bool lockheld);
static void RemoveTargetIfNoLongerUsed(PREDICATELOCKTARGET *target, static void RemoveTargetIfNoLongerUsed(PREDICATELOCKTARGET *target,
uint32 targettaghash); uint32 targettaghash);
static void DeleteChildTargetLocks(const PREDICATELOCKTARGETTAG *newtargettag); static void DeleteChildTargetLocks(PREDICATELOCKTARGETTAG *newtargettag);
static int PredicateLockPromotionThreshold(const PREDICATELOCKTARGETTAG *tag); static int PredicateLockPromotionThreshold(PREDICATELOCKTARGETTAG *tag);
static bool CheckAndPromotePredicateLockRequest(const PREDICATELOCKTARGETTAG *reqtag); static bool CheckAndPromotePredicateLockRequest(PREDICATELOCKTARGETTAG *reqtag);
static void DecrementParentLocks(const PREDICATELOCKTARGETTAG *targettag); static void DecrementParentLocks(PREDICATELOCKTARGETTAG *targettag);
static void CreatePredicateLock(const PREDICATELOCKTARGETTAG *targettag, static void CreatePredicateLock(PREDICATELOCKTARGETTAG *targettag,
uint32 targettaghash, uint32 targettaghash,
SERIALIZABLEXACT *sxact); SERIALIZABLEXACT *sxact);
static void DeleteLockTarget(PREDICATELOCKTARGET *target, uint32 targettaghash); static void DeleteLockTarget(PREDICATELOCKTARGET *target, uint32 targettaghash);
static bool TransferPredicateLocksToNewTarget(const PREDICATELOCKTARGETTAG oldtargettag, static bool TransferPredicateLocksToNewTarget(PREDICATELOCKTARGETTAG oldtargettag,
const PREDICATELOCKTARGETTAG newtargettag, PREDICATELOCKTARGETTAG newtargettag,
bool removeOld); bool removeOld);
static void PredicateLockAcquire(const PREDICATELOCKTARGETTAG *targettag); static void PredicateLockAcquire(PREDICATELOCKTARGETTAG *targettag);
static void DropAllPredicateLocksFromTable(const Relation relation, static void DropAllPredicateLocksFromTable(Relation relation,
bool transfer); bool transfer);
static void SetNewSxactGlobalXmin(void); static void SetNewSxactGlobalXmin(void);
static void ClearOldPredicateLocks(void); static void ClearOldPredicateLocks(void);
@ -433,7 +433,7 @@ static void ReleaseOneSerializableXact(SERIALIZABLEXACT *sxact, bool partial,
static bool XidIsConcurrent(TransactionId xid); static bool XidIsConcurrent(TransactionId xid);
static void CheckTargetForConflictsIn(PREDICATELOCKTARGETTAG *targettag); static void CheckTargetForConflictsIn(PREDICATELOCKTARGETTAG *targettag);
static void FlagRWConflict(SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer); static void FlagRWConflict(SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer);
static void OnConflict_CheckForSerializationFailure(const SERIALIZABLEXACT *reader, static void OnConflict_CheckForSerializationFailure(SERIALIZABLEXACT *reader,
SERIALIZABLEXACT *writer); SERIALIZABLEXACT *writer);
@ -601,7 +601,7 @@ NextPredXact(SERIALIZABLEXACT *sxact)
* These functions manage primitive access to the RWConflict pool and lists. * These functions manage primitive access to the RWConflict pool and lists.
*/ */
static bool static bool
RWConflictExists(const SERIALIZABLEXACT *reader, const SERIALIZABLEXACT *writer) RWConflictExists(SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer)
{ {
RWConflict conflict; RWConflict conflict;
@ -1337,7 +1337,7 @@ PredicateLockShmemSize(void)
static uint32 static uint32
predicatelock_hash(const void *key, Size keysize) predicatelock_hash(const void *key, Size keysize)
{ {
const PREDICATELOCKTAG *predicatelocktag = (const PREDICATELOCKTAG *) key; PREDICATELOCKTAG *predicatelocktag = (PREDICATELOCKTAG *) key;
uint32 targethash; uint32 targethash;
Assert(keysize == sizeof(PREDICATELOCKTAG)); Assert(keysize == sizeof(PREDICATELOCKTAG));
@ -1699,7 +1699,7 @@ RegisterSerializableTransactionInt(Snapshot snapshot)
* Also store it for easy reference in MySerializableXact. * Also store it for easy reference in MySerializableXact.
*/ */
void void
RegisterPredicateLockingXid(const TransactionId xid) RegisterPredicateLockingXid(TransactionId xid)
{ {
SERIALIZABLEXIDTAG sxidtag; SERIALIZABLEXIDTAG sxidtag;
SERIALIZABLEXID *sxid; SERIALIZABLEXID *sxid;
@ -1748,7 +1748,7 @@ RegisterPredicateLockingXid(const TransactionId xid)
* One use is to support proper behavior during GiST index vacuum. * One use is to support proper behavior during GiST index vacuum.
*/ */
bool bool
PageIsPredicateLocked(const Relation relation, const BlockNumber blkno) PageIsPredicateLocked(Relation relation, BlockNumber blkno)
{ {
PREDICATELOCKTARGETTAG targettag; PREDICATELOCKTARGETTAG targettag;
uint32 targettaghash; uint32 targettaghash;
@ -1785,7 +1785,7 @@ PageIsPredicateLocked(const Relation relation, const BlockNumber blkno)
* acceptable! * acceptable!
*/ */
static bool static bool
PredicateLockExists(const PREDICATELOCKTARGETTAG *targettag) PredicateLockExists(PREDICATELOCKTARGETTAG *targettag)
{ {
LOCALPREDICATELOCK *lock; LOCALPREDICATELOCK *lock;
@ -1812,7 +1812,7 @@ PredicateLockExists(const PREDICATELOCKTARGETTAG *targettag)
* returns false if none exists. * returns false if none exists.
*/ */
static bool static bool
GetParentPredicateLockTag(const PREDICATELOCKTARGETTAG *tag, GetParentPredicateLockTag(PREDICATELOCKTARGETTAG *tag,
PREDICATELOCKTARGETTAG *parent) PREDICATELOCKTARGETTAG *parent)
{ {
switch (GET_PREDICATELOCKTARGETTAG_TYPE(*tag)) switch (GET_PREDICATELOCKTARGETTAG_TYPE(*tag))
@ -1851,7 +1851,7 @@ GetParentPredicateLockTag(const PREDICATELOCKTARGETTAG *tag,
* negative, but it will never return a false positive. * negative, but it will never return a false positive.
*/ */
static bool static bool
CoarserLockCovers(const PREDICATELOCKTARGETTAG *newtargettag) CoarserLockCovers(PREDICATELOCKTARGETTAG *newtargettag)
{ {
PREDICATELOCKTARGETTAG targettag, PREDICATELOCKTARGETTAG targettag,
parenttag; parenttag;
@ -1952,7 +1952,7 @@ RemoveTargetIfNoLongerUsed(PREDICATELOCKTARGET *target, uint32 targettaghash)
* locks. * locks.
*/ */
static void static void
DeleteChildTargetLocks(const PREDICATELOCKTARGETTAG *newtargettag) DeleteChildTargetLocks(PREDICATELOCKTARGETTAG *newtargettag)
{ {
SERIALIZABLEXACT *sxact; SERIALIZABLEXACT *sxact;
PREDICATELOCK *predlock; PREDICATELOCK *predlock;
@ -2029,7 +2029,7 @@ DeleteChildTargetLocks(const PREDICATELOCKTARGETTAG *newtargettag)
* entirely arbitrarily (and without benchmarking). * entirely arbitrarily (and without benchmarking).
*/ */
static int static int
PredicateLockPromotionThreshold(const PREDICATELOCKTARGETTAG *tag) PredicateLockPromotionThreshold(PREDICATELOCKTARGETTAG *tag)
{ {
switch (GET_PREDICATELOCKTARGETTAG_TYPE(*tag)) switch (GET_PREDICATELOCKTARGETTAG_TYPE(*tag))
{ {
@ -2063,7 +2063,7 @@ PredicateLockPromotionThreshold(const PREDICATELOCKTARGETTAG *tag)
* Returns true if a parent lock was acquired and false otherwise. * Returns true if a parent lock was acquired and false otherwise.
*/ */
static bool static bool
CheckAndPromotePredicateLockRequest(const PREDICATELOCKTARGETTAG *reqtag) CheckAndPromotePredicateLockRequest(PREDICATELOCKTARGETTAG *reqtag)
{ {
PREDICATELOCKTARGETTAG targettag, PREDICATELOCKTARGETTAG targettag,
nexttag, nexttag,
@ -2128,7 +2128,7 @@ CheckAndPromotePredicateLockRequest(const PREDICATELOCKTARGETTAG *reqtag)
* this information is no longer needed. * this information is no longer needed.
*/ */
static void static void
DecrementParentLocks(const PREDICATELOCKTARGETTAG *targettag) DecrementParentLocks(PREDICATELOCKTARGETTAG *targettag)
{ {
PREDICATELOCKTARGETTAG parenttag, PREDICATELOCKTARGETTAG parenttag,
nexttag; nexttag;
@ -2190,7 +2190,7 @@ DecrementParentLocks(const PREDICATELOCKTARGETTAG *targettag)
* PredicateLockAcquire for that. * PredicateLockAcquire for that.
*/ */
static void static void
CreatePredicateLock(const PREDICATELOCKTARGETTAG *targettag, CreatePredicateLock(PREDICATELOCKTARGETTAG *targettag,
uint32 targettaghash, uint32 targettaghash,
SERIALIZABLEXACT *sxact) SERIALIZABLEXACT *sxact)
{ {
@ -2251,7 +2251,7 @@ CreatePredicateLock(const PREDICATELOCKTARGETTAG *targettag,
* any finer-grained locks covered by the new one. * any finer-grained locks covered by the new one.
*/ */
static void static void
PredicateLockAcquire(const PREDICATELOCKTARGETTAG *targettag) PredicateLockAcquire(PREDICATELOCKTARGETTAG *targettag)
{ {
uint32 targettaghash; uint32 targettaghash;
bool found; bool found;
@ -2310,7 +2310,7 @@ PredicateLockAcquire(const PREDICATELOCKTARGETTAG *targettag)
* Clear any finer-grained predicate locks this session has on the relation. * Clear any finer-grained predicate locks this session has on the relation.
*/ */
void void
PredicateLockRelation(const Relation relation, const Snapshot snapshot) PredicateLockRelation(Relation relation, Snapshot snapshot)
{ {
PREDICATELOCKTARGETTAG tag; PREDICATELOCKTARGETTAG tag;
@ -2333,8 +2333,7 @@ PredicateLockRelation(const Relation relation, const Snapshot snapshot)
* Clear any finer-grained predicate locks this session has on the relation. * Clear any finer-grained predicate locks this session has on the relation.
*/ */
void void
PredicateLockPage(const Relation relation, const BlockNumber blkno, PredicateLockPage(Relation relation, BlockNumber blkno, Snapshot snapshot)
const Snapshot snapshot)
{ {
PREDICATELOCKTARGETTAG tag; PREDICATELOCKTARGETTAG tag;
@ -2356,8 +2355,7 @@ PredicateLockPage(const Relation relation, const BlockNumber blkno,
* Skip if this is a temporary table. * Skip if this is a temporary table.
*/ */
void void
PredicateLockTuple(const Relation relation, const HeapTuple tuple, PredicateLockTuple(Relation relation, HeapTuple tuple, Snapshot snapshot)
const Snapshot snapshot)
{ {
PREDICATELOCKTARGETTAG tag; PREDICATELOCKTARGETTAG tag;
ItemPointer tid; ItemPointer tid;
@ -2495,8 +2493,8 @@ DeleteLockTarget(PREDICATELOCKTARGET *target, uint32 targettaghash)
* Caller must hold SerializablePredicateLockListLock. * Caller must hold SerializablePredicateLockListLock.
*/ */
static bool static bool
TransferPredicateLocksToNewTarget(const PREDICATELOCKTARGETTAG oldtargettag, TransferPredicateLocksToNewTarget(PREDICATELOCKTARGETTAG oldtargettag,
const PREDICATELOCKTARGETTAG newtargettag, PREDICATELOCKTARGETTAG newtargettag,
bool removeOld) bool removeOld)
{ {
uint32 oldtargettaghash; uint32 oldtargettaghash;
@ -2712,7 +2710,7 @@ exit:
* transaction which executed DROP TABLE, the false condition will be useful. * transaction which executed DROP TABLE, the false condition will be useful.
*/ */
static void static void
DropAllPredicateLocksFromTable(const Relation relation, bool transfer) DropAllPredicateLocksFromTable(Relation relation, bool transfer)
{ {
HASH_SEQ_STATUS seqstat; HASH_SEQ_STATUS seqstat;
PREDICATELOCKTARGET *oldtarget; PREDICATELOCKTARGET *oldtarget;
@ -2908,7 +2906,7 @@ DropAllPredicateLocksFromTable(const Relation relation, bool transfer)
* relation to a single relation lock on the heap. * relation to a single relation lock on the heap.
*/ */
void void
TransferPredicateLocksToHeapRelation(const Relation relation) TransferPredicateLocksToHeapRelation(Relation relation)
{ {
DropAllPredicateLocksFromTable(relation, true); DropAllPredicateLocksFromTable(relation, true);
} }
@ -2929,8 +2927,8 @@ TransferPredicateLocksToHeapRelation(const Relation relation)
* which hold the locks getting in and noticing. * which hold the locks getting in and noticing.
*/ */
void void
PredicateLockPageSplit(const Relation relation, const BlockNumber oldblkno, PredicateLockPageSplit(Relation relation, BlockNumber oldblkno,
const BlockNumber newblkno) BlockNumber newblkno)
{ {
PREDICATELOCKTARGETTAG oldtargettag; PREDICATELOCKTARGETTAG oldtargettag;
PREDICATELOCKTARGETTAG newtargettag; PREDICATELOCKTARGETTAG newtargettag;
@ -3014,8 +3012,8 @@ PredicateLockPageSplit(const Relation relation, const BlockNumber oldblkno,
* occurs in the context of another transaction isolation level. * occurs in the context of another transaction isolation level.
*/ */
void void
PredicateLockPageCombine(const Relation relation, const BlockNumber oldblkno, PredicateLockPageCombine(Relation relation, BlockNumber oldblkno,
const BlockNumber newblkno) BlockNumber newblkno)
{ {
/* /*
* Page combines differ from page splits in that we ought to be able to * Page combines differ from page splits in that we ought to be able to
@ -3086,7 +3084,7 @@ SetNewSxactGlobalXmin(void)
* holding locks. * holding locks.
*/ */
void void
ReleasePredicateLocks(const bool isCommit) ReleasePredicateLocks(bool isCommit)
{ {
bool needToClear; bool needToClear;
RWConflict conflict, RWConflict conflict,
@ -3736,9 +3734,9 @@ XidIsConcurrent(TransactionId xid)
* currently no known reason to call this function from an index AM. * currently no known reason to call this function from an index AM.
*/ */
void void
CheckForSerializableConflictOut(const bool visible, const Relation relation, CheckForSerializableConflictOut(bool visible, Relation relation,
const HeapTuple tuple, const Buffer buffer, HeapTuple tuple, Buffer buffer,
const Snapshot snapshot) Snapshot snapshot)
{ {
TransactionId xid; TransactionId xid;
SERIALIZABLEXIDTAG sxidtag; SERIALIZABLEXIDTAG sxidtag;
@ -4117,8 +4115,8 @@ CheckTargetForConflictsIn(PREDICATELOCKTARGETTAG *targettag)
* tuple itself. * tuple itself.
*/ */
void void
CheckForSerializableConflictIn(const Relation relation, const HeapTuple tuple, CheckForSerializableConflictIn(Relation relation, HeapTuple tuple,
const Buffer buffer) Buffer buffer)
{ {
PREDICATELOCKTARGETTAG targettag; PREDICATELOCKTARGETTAG targettag;
@ -4202,7 +4200,7 @@ CheckForSerializableConflictIn(const Relation relation, const HeapTuple tuple,
* lead to some false positives, but it doesn't seem worth the trouble.) * lead to some false positives, but it doesn't seem worth the trouble.)
*/ */
void void
CheckTableForSerializableConflictIn(const Relation relation) CheckTableForSerializableConflictIn(Relation relation)
{ {
HASH_SEQ_STATUS seqstat; HASH_SEQ_STATUS seqstat;
PREDICATELOCKTARGET *target; PREDICATELOCKTARGET *target;
@ -4329,7 +4327,7 @@ FlagRWConflict(SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer)
*---------------------------------------------------------------------------- *----------------------------------------------------------------------------
*/ */
static void static void
OnConflict_CheckForSerializationFailure(const SERIALIZABLEXACT *reader, OnConflict_CheckForSerializationFailure(SERIALIZABLEXACT *reader,
SERIALIZABLEXACT *writer) SERIALIZABLEXACT *writer)
{ {
bool failure; bool failure;

26
src/include/storage/predicate.h
View File

@ -39,24 +39,24 @@ extern Size PredicateLockShmemSize(void);
extern void CheckPointPredicate(void); extern void CheckPointPredicate(void);
/* predicate lock reporting */ /* predicate lock reporting */
extern bool PageIsPredicateLocked(const Relation relation, const BlockNumber blkno); extern bool PageIsPredicateLocked(Relation relation, BlockNumber blkno);
/* predicate lock maintenance */ /* predicate lock maintenance */
extern Snapshot RegisterSerializableTransaction(Snapshot snapshot); extern Snapshot RegisterSerializableTransaction(Snapshot snapshot);
extern void RegisterPredicateLockingXid(const TransactionId xid); extern void RegisterPredicateLockingXid(TransactionId xid);
extern void PredicateLockRelation(const Relation relation, const Snapshot snapshot); extern void PredicateLockRelation(Relation relation, Snapshot snapshot);
extern void PredicateLockPage(const Relation relation, const BlockNumber blkno, const Snapshot snapshot); extern void PredicateLockPage(Relation relation, BlockNumber blkno, Snapshot snapshot);
extern void PredicateLockTuple(const Relation relation, const HeapTuple tuple, const Snapshot snapshot); extern void PredicateLockTuple(Relation relation, HeapTuple tuple, Snapshot snapshot);
extern void PredicateLockPageSplit(const Relation relation, const BlockNumber oldblkno, const BlockNumber newblkno); extern void PredicateLockPageSplit(Relation relation, BlockNumber oldblkno, BlockNumber newblkno);
extern void PredicateLockPageCombine(const Relation relation, const BlockNumber oldblkno, const BlockNumber newblkno); extern void PredicateLockPageCombine(Relation relation, BlockNumber oldblkno, BlockNumber newblkno);
extern void TransferPredicateLocksToHeapRelation(const Relation relation); extern void TransferPredicateLocksToHeapRelation(Relation relation);
extern void ReleasePredicateLocks(const bool isCommit); extern void ReleasePredicateLocks(bool isCommit);
/* conflict detection (may also trigger rollback) */ /* conflict detection (may also trigger rollback) */
extern void CheckForSerializableConflictOut(const bool valid, const Relation relation, const HeapTuple tuple, extern void CheckForSerializableConflictOut(bool valid, Relation relation, HeapTuple tuple,
const Buffer buffer, const Snapshot snapshot); Buffer buffer, Snapshot snapshot);
extern void CheckForSerializableConflictIn(const Relation relation, const HeapTuple tuple, const Buffer buffer); extern void CheckForSerializableConflictIn(Relation relation, HeapTuple tuple, Buffer buffer);
extern void CheckTableForSerializableConflictIn(const Relation relation); extern void CheckTableForSerializableConflictIn(Relation relation);
/* final rollback checking */ /* final rollback checking */
extern void PreCommit_CheckForSerializationFailure(void); extern void PreCommit_CheckForSerializationFailure(void);