1996-10-31 08:10:14 +01:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* postgres.h
|
2001-02-10 03:31:31 +01:00
|
|
|
* Primary include file for PostgreSQL server .c files
|
|
|
|
*
|
|
|
|
* This should be the first file included by PostgreSQL backend modules.
|
|
|
|
* Client-side code should include postgres_fe.h instead.
|
|
|
|
*
|
1996-10-31 08:10:14 +01:00
|
|
|
*
|
2024-01-04 02:49:05 +01:00
|
|
|
* Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1995, Regents of the University of California
|
1996-10-31 08:10:14 +01:00
|
|
|
*
|
2010-09-20 22:08:53 +02:00
|
|
|
* src/include/postgres.h
|
1996-10-31 08:10:14 +01:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
/*
|
2001-02-10 03:31:31 +01:00
|
|
|
*----------------------------------------------------------------
|
|
|
|
* TABLE OF CONTENTS
|
1996-10-31 08:10:14 +01:00
|
|
|
*
|
2001-02-10 03:31:31 +01:00
|
|
|
* When adding stuff to this file, please try to put stuff
|
|
|
|
* into the relevant section, or add new sections as appropriate.
|
1996-10-31 08:10:14 +01:00
|
|
|
*
|
2001-02-10 03:31:31 +01:00
|
|
|
* section description
|
|
|
|
* ------- ------------------------------------------------
|
2023-01-10 05:48:59 +01:00
|
|
|
* 1) Datum type + support functions
|
|
|
|
* 2) miscellaneous
|
1996-10-31 08:10:14 +01:00
|
|
|
*
|
2001-02-10 03:31:31 +01:00
|
|
|
* NOTES
|
|
|
|
*
|
2002-08-25 19:20:01 +02:00
|
|
|
* In general, this file should contain declarations that are widely needed
|
|
|
|
* in the backend environment, but are of no interest outside the backend.
|
2001-02-10 03:31:31 +01:00
|
|
|
*
|
2002-08-25 19:20:01 +02:00
|
|
|
* Simple type definitions live in c.h, where they are shared with
|
|
|
|
* postgres_fe.h. We do that since those type definitions are needed by
|
|
|
|
* frontend modules that want to deal with binary data transmission to or
|
|
|
|
* from the backend. Type definitions in this file should be for
|
2023-01-10 05:48:59 +01:00
|
|
|
* representations that never escape the backend, such as Datum.
|
2001-02-10 03:31:31 +01:00
|
|
|
*
|
|
|
|
*----------------------------------------------------------------
|
1996-10-31 08:10:14 +01:00
|
|
|
*/
|
|
|
|
#ifndef POSTGRES_H
|
|
|
|
#define POSTGRES_H
|
|
|
|
|
|
|
|
#include "c.h"
|
1999-07-15 17:21:54 +02:00
|
|
|
#include "utils/elog.h"
|
1999-07-16 19:07:40 +02:00
|
|
|
#include "utils/palloc.h"
|
1996-10-31 08:10:14 +01:00
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
2023-01-10 05:48:59 +01:00
|
|
|
* Section 1: Datum type + support functions
|
2001-02-10 03:31:31 +01:00
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2018-01-23 17:19:12 +01:00
|
|
|
* A Datum contains either a value of a pass-by-value type or a pointer to a
|
|
|
|
* value of a pass-by-reference type. Therefore, we require:
|
2001-02-10 03:31:31 +01:00
|
|
|
*
|
2018-01-23 17:19:12 +01:00
|
|
|
* sizeof(Datum) == sizeof(void *) == 4 or 8
|
2001-02-10 03:31:31 +01:00
|
|
|
*
|
2022-09-27 20:47:07 +02:00
|
|
|
* The functions below and the analogous functions for other types should be used to
|
2018-01-23 17:19:12 +01:00
|
|
|
* convert between a Datum and the appropriate C type.
|
2001-02-10 03:31:31 +01:00
|
|
|
*/
|
|
|
|
|
2009-12-31 20:41:37 +01:00
|
|
|
typedef uintptr_t Datum;
|
2003-08-04 02:43:34 +02:00
|
|
|
|
Change function call information to be variable length.
Before this change FunctionCallInfoData, the struct arguments etc for
V1 function calls are stored in, always had space for
FUNC_MAX_ARGS/100 arguments, storing datums and their nullness in two
arrays. For nearly every function call 100 arguments is far more than
needed, therefore wasting memory. Arg and argnull being two separate
arrays also guarantees that to access a single argument, two
cachelines have to be touched.
Change the layout so there's a single variable-length array with pairs
of value / isnull. That drastically reduces memory consumption for
most function calls (on x86-64 a two argument function now uses
64bytes, previously 936 bytes), and makes it very likely that argument
value and its nullness are on the same cacheline.
Arguments are stored in a new NullableDatum struct, which, due to
padding, needs more memory per argument than before. But as usually
far fewer arguments are stored, and individual arguments are cheaper
to access, that's still a clear win. It's likely that there's other
places where conversion to NullableDatum arrays would make sense,
e.g. TupleTableSlots, but that's for another commit.
Because the function call information is now variable-length
allocations have to take the number of arguments into account. For
heap allocations that can be done with SizeForFunctionCallInfoData(),
for on-stack allocations there's a new LOCAL_FCINFO(name, nargs) macro
that helps to allocate an appropriately sized and aligned variable.
Some places with stack allocation function call information don't know
the number of arguments at compile time, and currently variably sized
stack allocations aren't allowed in postgres. Therefore allow for
FUNC_MAX_ARGS space in these cases. They're not that common, so for
now that seems acceptable.
Because of the need to allocate FunctionCallInfo of the appropriate
size, older extensions may need to update their code. To avoid subtle
breakages, the FunctionCallInfoData struct has been renamed to
FunctionCallInfoBaseData. Most code only references FunctionCallInfo,
so that shouldn't cause much collateral damage.
This change is also a prerequisite for more efficient expression JIT
compilation (by allocating the function call information on the stack,
allowing LLVM to optimize it away); previously the size of the call
information caused problems inside LLVM's optimizer.
Author: Andres Freund
Reviewed-By: Tom Lane
Discussion: https://postgr.es/m/20180605172952.x34m5uz6ju6enaem@alap3.anarazel.de
2019-01-26 23:17:52 +01:00
|
|
|
/*
|
|
|
|
* A NullableDatum is used in places where both a Datum and its nullness needs
|
|
|
|
* to be stored. This can be more efficient than storing datums and nullness
|
|
|
|
* in separate arrays, due to better spatial locality, even if more space may
|
|
|
|
* be wasted due to padding.
|
|
|
|
*/
|
|
|
|
typedef struct NullableDatum
|
|
|
|
{
|
|
|
|
#define FIELDNO_NULLABLE_DATUM_DATUM 0
|
|
|
|
Datum value;
|
|
|
|
#define FIELDNO_NULLABLE_DATUM_ISNULL 1
|
|
|
|
bool isnull;
|
|
|
|
/* due to alignment padding this could be used for flags for free */
|
|
|
|
} NullableDatum;
|
|
|
|
|
2009-12-31 20:41:37 +01:00
|
|
|
#define SIZEOF_DATUM SIZEOF_VOID_P
|
2007-03-23 21:24:41 +01:00
|
|
|
|
2001-02-10 03:31:31 +01:00
|
|
|
/*
|
|
|
|
* DatumGetBool
|
|
|
|
* Returns boolean value of a datum.
|
|
|
|
*
|
2018-01-23 17:19:12 +01:00
|
|
|
* Note: any nonzero value will be considered true.
|
1999-12-21 01:06:44 +01:00
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline bool
|
|
|
|
DatumGetBool(Datum X)
|
|
|
|
{
|
|
|
|
return (X != 0);
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* BoolGetDatum
|
|
|
|
* Returns datum representation for a boolean.
|
|
|
|
*
|
2018-01-23 17:19:12 +01:00
|
|
|
* Note: any nonzero value will be considered true.
|
2001-02-10 03:31:31 +01:00
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
BoolGetDatum(bool X)
|
|
|
|
{
|
|
|
|
return (Datum) (X ? 1 : 0);
|
|
|
|
}
|
1999-12-21 01:06:44 +01:00
|
|
|
|
2001-02-10 03:31:31 +01:00
|
|
|
/*
|
|
|
|
* DatumGetChar
|
|
|
|
* Returns character value of a datum.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline char
|
|
|
|
DatumGetChar(Datum X)
|
|
|
|
{
|
|
|
|
return (char) X;
|
|
|
|
}
|
2000-06-13 09:35:40 +02:00
|
|
|
|
2001-02-10 03:31:31 +01:00
|
|
|
/*
|
|
|
|
* CharGetDatum
|
|
|
|
* Returns datum representation for a character.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
CharGetDatum(char X)
|
|
|
|
{
|
|
|
|
return (Datum) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Int8GetDatum
|
|
|
|
* Returns datum representation for an 8-bit integer.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
Int8GetDatum(int8 X)
|
|
|
|
{
|
|
|
|
return (Datum) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* DatumGetUInt8
|
|
|
|
* Returns 8-bit unsigned integer value of a datum.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline uint8
|
|
|
|
DatumGetUInt8(Datum X)
|
|
|
|
{
|
|
|
|
return (uint8) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* UInt8GetDatum
|
|
|
|
* Returns datum representation for an 8-bit unsigned integer.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
UInt8GetDatum(uint8 X)
|
|
|
|
{
|
|
|
|
return (Datum) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* DatumGetInt16
|
|
|
|
* Returns 16-bit integer value of a datum.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline int16
|
|
|
|
DatumGetInt16(Datum X)
|
|
|
|
{
|
|
|
|
return (int16) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Int16GetDatum
|
|
|
|
* Returns datum representation for a 16-bit integer.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
Int16GetDatum(int16 X)
|
|
|
|
{
|
|
|
|
return (Datum) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* DatumGetUInt16
|
|
|
|
* Returns 16-bit unsigned integer value of a datum.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline uint16
|
|
|
|
DatumGetUInt16(Datum X)
|
|
|
|
{
|
|
|
|
return (uint16) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* UInt16GetDatum
|
|
|
|
* Returns datum representation for a 16-bit unsigned integer.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
UInt16GetDatum(uint16 X)
|
|
|
|
{
|
|
|
|
return (Datum) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* DatumGetInt32
|
|
|
|
* Returns 32-bit integer value of a datum.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline int32
|
|
|
|
DatumGetInt32(Datum X)
|
|
|
|
{
|
|
|
|
return (int32) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Int32GetDatum
|
|
|
|
* Returns datum representation for a 32-bit integer.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
Int32GetDatum(int32 X)
|
|
|
|
{
|
|
|
|
return (Datum) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* DatumGetUInt32
|
|
|
|
* Returns 32-bit unsigned integer value of a datum.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline uint32
|
|
|
|
DatumGetUInt32(Datum X)
|
|
|
|
{
|
|
|
|
return (uint32) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* UInt32GetDatum
|
|
|
|
* Returns datum representation for a 32-bit unsigned integer.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
UInt32GetDatum(uint32 X)
|
|
|
|
{
|
|
|
|
return (Datum) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* DatumGetObjectId
|
|
|
|
* Returns object identifier value of a datum.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Oid
|
|
|
|
DatumGetObjectId(Datum X)
|
|
|
|
{
|
|
|
|
return (Oid) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ObjectIdGetDatum
|
|
|
|
* Returns datum representation for an object identifier.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
ObjectIdGetDatum(Oid X)
|
|
|
|
{
|
|
|
|
return (Datum) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
2001-08-24 01:06:38 +02:00
|
|
|
/*
|
|
|
|
* DatumGetTransactionId
|
|
|
|
* Returns transaction identifier value of a datum.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline TransactionId
|
|
|
|
DatumGetTransactionId(Datum X)
|
|
|
|
{
|
|
|
|
return (TransactionId) X;
|
|
|
|
}
|
2001-08-24 01:06:38 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* TransactionIdGetDatum
|
|
|
|
* Returns datum representation for a transaction identifier.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
TransactionIdGetDatum(TransactionId X)
|
|
|
|
{
|
|
|
|
return (Datum) X;
|
|
|
|
}
|
2001-08-24 01:06:38 +02:00
|
|
|
|
Improve concurrency of foreign key locking
This patch introduces two additional lock modes for tuples: "SELECT FOR
KEY SHARE" and "SELECT FOR NO KEY UPDATE". These don't block each
other, in contrast with already existing "SELECT FOR SHARE" and "SELECT
FOR UPDATE". UPDATE commands that do not modify the values stored in
the columns that are part of the key of the tuple now grab a SELECT FOR
NO KEY UPDATE lock on the tuple, allowing them to proceed concurrently
with tuple locks of the FOR KEY SHARE variety.
Foreign key triggers now use FOR KEY SHARE instead of FOR SHARE; this
means the concurrency improvement applies to them, which is the whole
point of this patch.
The added tuple lock semantics require some rejiggering of the multixact
module, so that the locking level that each transaction is holding can
be stored alongside its Xid. Also, multixacts now need to persist
across server restarts and crashes, because they can now represent not
only tuple locks, but also tuple updates. This means we need more
careful tracking of lifetime of pg_multixact SLRU files; since they now
persist longer, we require more infrastructure to figure out when they
can be removed. pg_upgrade also needs to be careful to copy
pg_multixact files over from the old server to the new, or at least part
of multixact.c state, depending on the versions of the old and new
servers.
Tuple time qualification rules (HeapTupleSatisfies routines) need to be
careful not to consider tuples with the "is multi" infomask bit set as
being only locked; they might need to look up MultiXact values (i.e.
possibly do pg_multixact I/O) to find out the Xid that updated a tuple,
whereas they previously were assured to only use information readily
available from the tuple header. This is considered acceptable, because
the extra I/O would involve cases that would previously cause some
commands to block waiting for concurrent transactions to finish.
Another important change is the fact that locking tuples that have
previously been updated causes the future versions to be marked as
locked, too; this is essential for correctness of foreign key checks.
This causes additional WAL-logging, also (there was previously a single
WAL record for a locked tuple; now there are as many as updated copies
of the tuple there exist.)
With all this in place, contention related to tuples being checked by
foreign key rules should be much reduced.
As a bonus, the old behavior that a subtransaction grabbing a stronger
tuple lock than the parent (sub)transaction held on a given tuple and
later aborting caused the weaker lock to be lost, has been fixed.
Many new spec files were added for isolation tester framework, to ensure
overall behavior is sane. There's probably room for several more tests.
There were several reviewers of this patch; in particular, Noah Misch
and Andres Freund spent considerable time in it. Original idea for the
patch came from Simon Riggs, after a problem report by Joel Jacobson.
Most code is from me, with contributions from Marti Raudsepp, Alexander
Shulgin, Noah Misch and Andres Freund.
This patch was discussed in several pgsql-hackers threads; the most
important start at the following message-ids:
AANLkTimo9XVcEzfiBR-ut3KVNDkjm2Vxh+t8kAmWjPuv@mail.gmail.com
1290721684-sup-3951@alvh.no-ip.org
1294953201-sup-2099@alvh.no-ip.org
1320343602-sup-2290@alvh.no-ip.org
1339690386-sup-8927@alvh.no-ip.org
4FE5FF020200002500048A3D@gw.wicourts.gov
4FEAB90A0200002500048B7D@gw.wicourts.gov
2013-01-23 16:04:59 +01:00
|
|
|
/*
|
|
|
|
* MultiXactIdGetDatum
|
|
|
|
* Returns datum representation for a multixact identifier.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
MultiXactIdGetDatum(MultiXactId X)
|
|
|
|
{
|
|
|
|
return (Datum) X;
|
|
|
|
}
|
Improve concurrency of foreign key locking
This patch introduces two additional lock modes for tuples: "SELECT FOR
KEY SHARE" and "SELECT FOR NO KEY UPDATE". These don't block each
other, in contrast with already existing "SELECT FOR SHARE" and "SELECT
FOR UPDATE". UPDATE commands that do not modify the values stored in
the columns that are part of the key of the tuple now grab a SELECT FOR
NO KEY UPDATE lock on the tuple, allowing them to proceed concurrently
with tuple locks of the FOR KEY SHARE variety.
Foreign key triggers now use FOR KEY SHARE instead of FOR SHARE; this
means the concurrency improvement applies to them, which is the whole
point of this patch.
The added tuple lock semantics require some rejiggering of the multixact
module, so that the locking level that each transaction is holding can
be stored alongside its Xid. Also, multixacts now need to persist
across server restarts and crashes, because they can now represent not
only tuple locks, but also tuple updates. This means we need more
careful tracking of lifetime of pg_multixact SLRU files; since they now
persist longer, we require more infrastructure to figure out when they
can be removed. pg_upgrade also needs to be careful to copy
pg_multixact files over from the old server to the new, or at least part
of multixact.c state, depending on the versions of the old and new
servers.
Tuple time qualification rules (HeapTupleSatisfies routines) need to be
careful not to consider tuples with the "is multi" infomask bit set as
being only locked; they might need to look up MultiXact values (i.e.
possibly do pg_multixact I/O) to find out the Xid that updated a tuple,
whereas they previously were assured to only use information readily
available from the tuple header. This is considered acceptable, because
the extra I/O would involve cases that would previously cause some
commands to block waiting for concurrent transactions to finish.
Another important change is the fact that locking tuples that have
previously been updated causes the future versions to be marked as
locked, too; this is essential for correctness of foreign key checks.
This causes additional WAL-logging, also (there was previously a single
WAL record for a locked tuple; now there are as many as updated copies
of the tuple there exist.)
With all this in place, contention related to tuples being checked by
foreign key rules should be much reduced.
As a bonus, the old behavior that a subtransaction grabbing a stronger
tuple lock than the parent (sub)transaction held on a given tuple and
later aborting caused the weaker lock to be lost, has been fixed.
Many new spec files were added for isolation tester framework, to ensure
overall behavior is sane. There's probably room for several more tests.
There were several reviewers of this patch; in particular, Noah Misch
and Andres Freund spent considerable time in it. Original idea for the
patch came from Simon Riggs, after a problem report by Joel Jacobson.
Most code is from me, with contributions from Marti Raudsepp, Alexander
Shulgin, Noah Misch and Andres Freund.
This patch was discussed in several pgsql-hackers threads; the most
important start at the following message-ids:
AANLkTimo9XVcEzfiBR-ut3KVNDkjm2Vxh+t8kAmWjPuv@mail.gmail.com
1290721684-sup-3951@alvh.no-ip.org
1294953201-sup-2099@alvh.no-ip.org
1320343602-sup-2290@alvh.no-ip.org
1339690386-sup-8927@alvh.no-ip.org
4FE5FF020200002500048A3D@gw.wicourts.gov
4FEAB90A0200002500048B7D@gw.wicourts.gov
2013-01-23 16:04:59 +01:00
|
|
|
|
2001-08-24 01:06:38 +02:00
|
|
|
/*
|
|
|
|
* DatumGetCommandId
|
|
|
|
* Returns command identifier value of a datum.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline CommandId
|
|
|
|
DatumGetCommandId(Datum X)
|
|
|
|
{
|
|
|
|
return (CommandId) X;
|
|
|
|
}
|
2001-08-24 01:06:38 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* CommandIdGetDatum
|
|
|
|
* Returns datum representation for a command identifier.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
CommandIdGetDatum(CommandId X)
|
|
|
|
{
|
|
|
|
return (Datum) X;
|
|
|
|
}
|
2001-08-24 01:06:38 +02:00
|
|
|
|
2001-02-10 03:31:31 +01:00
|
|
|
/*
|
|
|
|
* DatumGetPointer
|
|
|
|
* Returns pointer value of a datum.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Pointer
|
|
|
|
DatumGetPointer(Datum X)
|
|
|
|
{
|
|
|
|
return (Pointer) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* PointerGetDatum
|
|
|
|
* Returns datum representation for a pointer.
|
1999-03-25 04:49:34 +01:00
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
PointerGetDatum(const void *X)
|
|
|
|
{
|
|
|
|
return (Datum) X;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* DatumGetCString
|
|
|
|
* Returns C string (null-terminated string) value of a datum.
|
|
|
|
*
|
|
|
|
* Note: C string is not a full-fledged Postgres type at present,
|
|
|
|
* but type input functions use this conversion for their inputs.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline char *
|
|
|
|
DatumGetCString(Datum X)
|
|
|
|
{
|
|
|
|
return (char *) DatumGetPointer(X);
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* CStringGetDatum
|
|
|
|
* Returns datum representation for a C string (null-terminated string).
|
|
|
|
*
|
|
|
|
* Note: C string is not a full-fledged Postgres type at present,
|
|
|
|
* but type output functions use this conversion for their outputs.
|
|
|
|
* Note: CString is pass-by-reference; caller must ensure the pointed-to
|
|
|
|
* value has adequate lifetime.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
CStringGetDatum(const char *X)
|
|
|
|
{
|
|
|
|
return PointerGetDatum(X);
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* DatumGetName
|
|
|
|
* Returns name value of a datum.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Name
|
|
|
|
DatumGetName(Datum X)
|
|
|
|
{
|
|
|
|
return (Name) DatumGetPointer(X);
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* NameGetDatum
|
|
|
|
* Returns datum representation for a name.
|
|
|
|
*
|
|
|
|
* Note: Name is pass-by-reference; caller must ensure the pointed-to
|
|
|
|
* value has adequate lifetime.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
NameGetDatum(const NameData *X)
|
|
|
|
{
|
|
|
|
return CStringGetDatum(NameStr(*X));
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* DatumGetInt64
|
|
|
|
* Returns 64-bit integer value of a datum.
|
|
|
|
*
|
2022-09-27 20:47:07 +02:00
|
|
|
* Note: this function hides whether int64 is pass by value or by reference.
|
2001-02-10 03:31:31 +01:00
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline int64
|
|
|
|
DatumGetInt64(Datum X)
|
|
|
|
{
|
2008-04-21 02:26:47 +02:00
|
|
|
#ifdef USE_FLOAT8_BYVAL
|
2022-09-27 20:47:07 +02:00
|
|
|
return (int64) X;
|
2008-04-21 02:26:47 +02:00
|
|
|
#else
|
2022-09-27 20:47:07 +02:00
|
|
|
return *((int64 *) DatumGetPointer(X));
|
2008-04-21 02:26:47 +02:00
|
|
|
#endif
|
2022-09-27 20:47:07 +02:00
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Int64GetDatum
|
|
|
|
* Returns datum representation for a 64-bit integer.
|
|
|
|
*
|
2008-04-21 02:26:47 +02:00
|
|
|
* Note: if int64 is pass by reference, this function returns a reference
|
|
|
|
* to palloc'd space.
|
2001-02-10 03:31:31 +01:00
|
|
|
*/
|
2008-04-21 02:26:47 +02:00
|
|
|
#ifdef USE_FLOAT8_BYVAL
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
Int64GetDatum(int64 X)
|
|
|
|
{
|
|
|
|
return (Datum) X;
|
|
|
|
}
|
2008-04-21 02:26:47 +02:00
|
|
|
#else
|
2001-02-10 03:31:31 +01:00
|
|
|
extern Datum Int64GetDatum(int64 X);
|
2008-04-21 02:26:47 +02:00
|
|
|
#endif
|
2001-02-10 03:31:31 +01:00
|
|
|
|
2022-09-27 20:47:07 +02:00
|
|
|
|
Widen query numbers-of-tuples-processed counters to uint64.
This patch widens SPI_processed, EState's es_processed field, PortalData's
portalPos field, FuncCallContext's call_cntr and max_calls fields,
ExecutorRun's count argument, PortalRunFetch's result, and the max number
of rows in a SPITupleTable to uint64, and deals with (I hope) all the
ensuing fallout. Some of these values were declared uint32 before, and
others "long".
I also removed PortalData's posOverflow field, since that logic seems
pretty useless given that portalPos is now always 64 bits.
The user-visible results are that command tags for SELECT etc will
correctly report tuple counts larger than 4G, as will plpgsql's GET
GET DIAGNOSTICS ... ROW_COUNT command. Queries processing more tuples
than that are still not exactly the norm, but they're becoming more
common.
Most values associated with FETCH/MOVE distances, such as PortalRun's count
argument and the count argument of most SPI functions that have one, remain
declared as "long". It's not clear whether it would be worth promoting
those to int64; but it would definitely be a large dollop of additional
API churn on top of this, and it would only help 32-bit platforms which
seem relatively less likely to see any benefit.
Andreas Scherbaum, reviewed by Christian Ullrich, additional hacking by me
2016-03-12 22:05:10 +01:00
|
|
|
/*
|
|
|
|
* DatumGetUInt64
|
|
|
|
* Returns 64-bit unsigned integer value of a datum.
|
|
|
|
*
|
2022-09-27 20:47:07 +02:00
|
|
|
* Note: this function hides whether int64 is pass by value or by reference.
|
Widen query numbers-of-tuples-processed counters to uint64.
This patch widens SPI_processed, EState's es_processed field, PortalData's
portalPos field, FuncCallContext's call_cntr and max_calls fields,
ExecutorRun's count argument, PortalRunFetch's result, and the max number
of rows in a SPITupleTable to uint64, and deals with (I hope) all the
ensuing fallout. Some of these values were declared uint32 before, and
others "long".
I also removed PortalData's posOverflow field, since that logic seems
pretty useless given that portalPos is now always 64 bits.
The user-visible results are that command tags for SELECT etc will
correctly report tuple counts larger than 4G, as will plpgsql's GET
GET DIAGNOSTICS ... ROW_COUNT command. Queries processing more tuples
than that are still not exactly the norm, but they're becoming more
common.
Most values associated with FETCH/MOVE distances, such as PortalRun's count
argument and the count argument of most SPI functions that have one, remain
declared as "long". It's not clear whether it would be worth promoting
those to int64; but it would definitely be a large dollop of additional
API churn on top of this, and it would only help 32-bit platforms which
seem relatively less likely to see any benefit.
Andreas Scherbaum, reviewed by Christian Ullrich, additional hacking by me
2016-03-12 22:05:10 +01:00
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline uint64
|
|
|
|
DatumGetUInt64(Datum X)
|
|
|
|
{
|
Widen query numbers-of-tuples-processed counters to uint64.
This patch widens SPI_processed, EState's es_processed field, PortalData's
portalPos field, FuncCallContext's call_cntr and max_calls fields,
ExecutorRun's count argument, PortalRunFetch's result, and the max number
of rows in a SPITupleTable to uint64, and deals with (I hope) all the
ensuing fallout. Some of these values were declared uint32 before, and
others "long".
I also removed PortalData's posOverflow field, since that logic seems
pretty useless given that portalPos is now always 64 bits.
The user-visible results are that command tags for SELECT etc will
correctly report tuple counts larger than 4G, as will plpgsql's GET
GET DIAGNOSTICS ... ROW_COUNT command. Queries processing more tuples
than that are still not exactly the norm, but they're becoming more
common.
Most values associated with FETCH/MOVE distances, such as PortalRun's count
argument and the count argument of most SPI functions that have one, remain
declared as "long". It's not clear whether it would be worth promoting
those to int64; but it would definitely be a large dollop of additional
API churn on top of this, and it would only help 32-bit platforms which
seem relatively less likely to see any benefit.
Andreas Scherbaum, reviewed by Christian Ullrich, additional hacking by me
2016-03-12 22:05:10 +01:00
|
|
|
#ifdef USE_FLOAT8_BYVAL
|
2022-09-27 20:47:07 +02:00
|
|
|
return (uint64) X;
|
Widen query numbers-of-tuples-processed counters to uint64.
This patch widens SPI_processed, EState's es_processed field, PortalData's
portalPos field, FuncCallContext's call_cntr and max_calls fields,
ExecutorRun's count argument, PortalRunFetch's result, and the max number
of rows in a SPITupleTable to uint64, and deals with (I hope) all the
ensuing fallout. Some of these values were declared uint32 before, and
others "long".
I also removed PortalData's posOverflow field, since that logic seems
pretty useless given that portalPos is now always 64 bits.
The user-visible results are that command tags for SELECT etc will
correctly report tuple counts larger than 4G, as will plpgsql's GET
GET DIAGNOSTICS ... ROW_COUNT command. Queries processing more tuples
than that are still not exactly the norm, but they're becoming more
common.
Most values associated with FETCH/MOVE distances, such as PortalRun's count
argument and the count argument of most SPI functions that have one, remain
declared as "long". It's not clear whether it would be worth promoting
those to int64; but it would definitely be a large dollop of additional
API churn on top of this, and it would only help 32-bit platforms which
seem relatively less likely to see any benefit.
Andreas Scherbaum, reviewed by Christian Ullrich, additional hacking by me
2016-03-12 22:05:10 +01:00
|
|
|
#else
|
2022-09-27 20:47:07 +02:00
|
|
|
return *((uint64 *) DatumGetPointer(X));
|
Widen query numbers-of-tuples-processed counters to uint64.
This patch widens SPI_processed, EState's es_processed field, PortalData's
portalPos field, FuncCallContext's call_cntr and max_calls fields,
ExecutorRun's count argument, PortalRunFetch's result, and the max number
of rows in a SPITupleTable to uint64, and deals with (I hope) all the
ensuing fallout. Some of these values were declared uint32 before, and
others "long".
I also removed PortalData's posOverflow field, since that logic seems
pretty useless given that portalPos is now always 64 bits.
The user-visible results are that command tags for SELECT etc will
correctly report tuple counts larger than 4G, as will plpgsql's GET
GET DIAGNOSTICS ... ROW_COUNT command. Queries processing more tuples
than that are still not exactly the norm, but they're becoming more
common.
Most values associated with FETCH/MOVE distances, such as PortalRun's count
argument and the count argument of most SPI functions that have one, remain
declared as "long". It's not clear whether it would be worth promoting
those to int64; but it would definitely be a large dollop of additional
API churn on top of this, and it would only help 32-bit platforms which
seem relatively less likely to see any benefit.
Andreas Scherbaum, reviewed by Christian Ullrich, additional hacking by me
2016-03-12 22:05:10 +01:00
|
|
|
#endif
|
2022-09-27 20:47:07 +02:00
|
|
|
}
|
Widen query numbers-of-tuples-processed counters to uint64.
This patch widens SPI_processed, EState's es_processed field, PortalData's
portalPos field, FuncCallContext's call_cntr and max_calls fields,
ExecutorRun's count argument, PortalRunFetch's result, and the max number
of rows in a SPITupleTable to uint64, and deals with (I hope) all the
ensuing fallout. Some of these values were declared uint32 before, and
others "long".
I also removed PortalData's posOverflow field, since that logic seems
pretty useless given that portalPos is now always 64 bits.
The user-visible results are that command tags for SELECT etc will
correctly report tuple counts larger than 4G, as will plpgsql's GET
GET DIAGNOSTICS ... ROW_COUNT command. Queries processing more tuples
than that are still not exactly the norm, but they're becoming more
common.
Most values associated with FETCH/MOVE distances, such as PortalRun's count
argument and the count argument of most SPI functions that have one, remain
declared as "long". It's not clear whether it would be worth promoting
those to int64; but it would definitely be a large dollop of additional
API churn on top of this, and it would only help 32-bit platforms which
seem relatively less likely to see any benefit.
Andreas Scherbaum, reviewed by Christian Ullrich, additional hacking by me
2016-03-12 22:05:10 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* UInt64GetDatum
|
|
|
|
* Returns datum representation for a 64-bit unsigned integer.
|
|
|
|
*
|
|
|
|
* Note: if int64 is pass by reference, this function returns a reference
|
|
|
|
* to palloc'd space.
|
|
|
|
*/
|
2022-09-27 20:47:07 +02:00
|
|
|
static inline Datum
|
|
|
|
UInt64GetDatum(uint64 X)
|
|
|
|
{
|
Widen query numbers-of-tuples-processed counters to uint64.
This patch widens SPI_processed, EState's es_processed field, PortalData's
portalPos field, FuncCallContext's call_cntr and max_calls fields,
ExecutorRun's count argument, PortalRunFetch's result, and the max number
of rows in a SPITupleTable to uint64, and deals with (I hope) all the
ensuing fallout. Some of these values were declared uint32 before, and
others "long".
I also removed PortalData's posOverflow field, since that logic seems
pretty useless given that portalPos is now always 64 bits.
The user-visible results are that command tags for SELECT etc will
correctly report tuple counts larger than 4G, as will plpgsql's GET
GET DIAGNOSTICS ... ROW_COUNT command. Queries processing more tuples
than that are still not exactly the norm, but they're becoming more
common.
Most values associated with FETCH/MOVE distances, such as PortalRun's count
argument and the count argument of most SPI functions that have one, remain
declared as "long". It's not clear whether it would be worth promoting
those to int64; but it would definitely be a large dollop of additional
API churn on top of this, and it would only help 32-bit platforms which
seem relatively less likely to see any benefit.
Andreas Scherbaum, reviewed by Christian Ullrich, additional hacking by me
2016-03-12 22:05:10 +01:00
|
|
|
#ifdef USE_FLOAT8_BYVAL
|
2022-09-27 20:47:07 +02:00
|
|
|
return (Datum) X;
|
Widen query numbers-of-tuples-processed counters to uint64.
This patch widens SPI_processed, EState's es_processed field, PortalData's
portalPos field, FuncCallContext's call_cntr and max_calls fields,
ExecutorRun's count argument, PortalRunFetch's result, and the max number
of rows in a SPITupleTable to uint64, and deals with (I hope) all the
ensuing fallout. Some of these values were declared uint32 before, and
others "long".
I also removed PortalData's posOverflow field, since that logic seems
pretty useless given that portalPos is now always 64 bits.
The user-visible results are that command tags for SELECT etc will
correctly report tuple counts larger than 4G, as will plpgsql's GET
GET DIAGNOSTICS ... ROW_COUNT command. Queries processing more tuples
than that are still not exactly the norm, but they're becoming more
common.
Most values associated with FETCH/MOVE distances, such as PortalRun's count
argument and the count argument of most SPI functions that have one, remain
declared as "long". It's not clear whether it would be worth promoting
those to int64; but it would definitely be a large dollop of additional
API churn on top of this, and it would only help 32-bit platforms which
seem relatively less likely to see any benefit.
Andreas Scherbaum, reviewed by Christian Ullrich, additional hacking by me
2016-03-12 22:05:10 +01:00
|
|
|
#else
|
2022-09-27 20:47:07 +02:00
|
|
|
return Int64GetDatum((int64) X);
|
Widen query numbers-of-tuples-processed counters to uint64.
This patch widens SPI_processed, EState's es_processed field, PortalData's
portalPos field, FuncCallContext's call_cntr and max_calls fields,
ExecutorRun's count argument, PortalRunFetch's result, and the max number
of rows in a SPITupleTable to uint64, and deals with (I hope) all the
ensuing fallout. Some of these values were declared uint32 before, and
others "long".
I also removed PortalData's posOverflow field, since that logic seems
pretty useless given that portalPos is now always 64 bits.
The user-visible results are that command tags for SELECT etc will
correctly report tuple counts larger than 4G, as will plpgsql's GET
GET DIAGNOSTICS ... ROW_COUNT command. Queries processing more tuples
than that are still not exactly the norm, but they're becoming more
common.
Most values associated with FETCH/MOVE distances, such as PortalRun's count
argument and the count argument of most SPI functions that have one, remain
declared as "long". It's not clear whether it would be worth promoting
those to int64; but it would definitely be a large dollop of additional
API churn on top of this, and it would only help 32-bit platforms which
seem relatively less likely to see any benefit.
Andreas Scherbaum, reviewed by Christian Ullrich, additional hacking by me
2016-03-12 22:05:10 +01:00
|
|
|
#endif
|
2022-09-27 20:47:07 +02:00
|
|
|
}
|
Widen query numbers-of-tuples-processed counters to uint64.
This patch widens SPI_processed, EState's es_processed field, PortalData's
portalPos field, FuncCallContext's call_cntr and max_calls fields,
ExecutorRun's count argument, PortalRunFetch's result, and the max number
of rows in a SPITupleTable to uint64, and deals with (I hope) all the
ensuing fallout. Some of these values were declared uint32 before, and
others "long".
I also removed PortalData's posOverflow field, since that logic seems
pretty useless given that portalPos is now always 64 bits.
The user-visible results are that command tags for SELECT etc will
correctly report tuple counts larger than 4G, as will plpgsql's GET
GET DIAGNOSTICS ... ROW_COUNT command. Queries processing more tuples
than that are still not exactly the norm, but they're becoming more
common.
Most values associated with FETCH/MOVE distances, such as PortalRun's count
argument and the count argument of most SPI functions that have one, remain
declared as "long". It's not clear whether it would be worth promoting
those to int64; but it would definitely be a large dollop of additional
API churn on top of this, and it would only help 32-bit platforms which
seem relatively less likely to see any benefit.
Andreas Scherbaum, reviewed by Christian Ullrich, additional hacking by me
2016-03-12 22:05:10 +01:00
|
|
|
|
2016-08-31 15:00:28 +02:00
|
|
|
/*
|
|
|
|
* Float <-> Datum conversions
|
|
|
|
*
|
|
|
|
* These have to be implemented as inline functions rather than macros, when
|
|
|
|
* passing by value, because many machines pass int and float function
|
|
|
|
* parameters/results differently; so we need to play weird games with unions.
|
|
|
|
*/
|
|
|
|
|
2001-02-10 03:31:31 +01:00
|
|
|
/*
|
|
|
|
* DatumGetFloat4
|
|
|
|
* Returns 4-byte floating point value of a datum.
|
|
|
|
*/
|
2016-08-31 15:00:28 +02:00
|
|
|
static inline float4
|
|
|
|
DatumGetFloat4(Datum X)
|
|
|
|
{
|
|
|
|
union
|
|
|
|
{
|
|
|
|
int32 value;
|
|
|
|
float4 retval;
|
|
|
|
} myunion;
|
|
|
|
|
2017-05-31 17:27:21 +02:00
|
|
|
myunion.value = DatumGetInt32(X);
|
2016-08-31 15:00:28 +02:00
|
|
|
return myunion.retval;
|
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Float4GetDatum
|
|
|
|
* Returns datum representation for a 4-byte floating point number.
|
|
|
|
*/
|
2016-08-31 15:00:28 +02:00
|
|
|
static inline Datum
|
|
|
|
Float4GetDatum(float4 X)
|
|
|
|
{
|
|
|
|
union
|
|
|
|
{
|
|
|
|
float4 value;
|
|
|
|
int32 retval;
|
|
|
|
} myunion;
|
2001-02-10 03:31:31 +01:00
|
|
|
|
2016-08-31 15:00:28 +02:00
|
|
|
myunion.value = X;
|
2017-05-31 17:27:21 +02:00
|
|
|
return Int32GetDatum(myunion.retval);
|
2016-08-31 15:00:28 +02:00
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* DatumGetFloat8
|
|
|
|
* Returns 8-byte floating point value of a datum.
|
|
|
|
*
|
2022-09-27 20:47:07 +02:00
|
|
|
* Note: this function hides whether float8 is pass by value or by reference.
|
2001-02-10 03:31:31 +01:00
|
|
|
*/
|
2016-08-31 15:00:28 +02:00
|
|
|
static inline float8
|
|
|
|
DatumGetFloat8(Datum X)
|
|
|
|
{
|
2022-09-27 20:47:07 +02:00
|
|
|
#ifdef USE_FLOAT8_BYVAL
|
2016-08-31 15:00:28 +02:00
|
|
|
union
|
|
|
|
{
|
|
|
|
int64 value;
|
|
|
|
float8 retval;
|
|
|
|
} myunion;
|
|
|
|
|
2017-05-31 17:27:21 +02:00
|
|
|
myunion.value = DatumGetInt64(X);
|
2016-08-31 15:00:28 +02:00
|
|
|
return myunion.retval;
|
2008-04-21 02:26:47 +02:00
|
|
|
#else
|
2022-09-27 20:47:07 +02:00
|
|
|
return *((float8 *) DatumGetPointer(X));
|
2008-04-21 02:26:47 +02:00
|
|
|
#endif
|
2022-09-27 20:47:07 +02:00
|
|
|
}
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Float8GetDatum
|
|
|
|
* Returns datum representation for an 8-byte floating point number.
|
|
|
|
*
|
2008-04-21 02:26:47 +02:00
|
|
|
* Note: if float8 is pass by reference, this function returns a reference
|
|
|
|
* to palloc'd space.
|
2001-02-10 03:31:31 +01:00
|
|
|
*/
|
2016-08-31 15:00:28 +02:00
|
|
|
#ifdef USE_FLOAT8_BYVAL
|
|
|
|
static inline Datum
|
|
|
|
Float8GetDatum(float8 X)
|
|
|
|
{
|
|
|
|
union
|
|
|
|
{
|
|
|
|
float8 value;
|
|
|
|
int64 retval;
|
|
|
|
} myunion;
|
|
|
|
|
|
|
|
myunion.value = X;
|
2017-05-31 17:27:21 +02:00
|
|
|
return Int64GetDatum(myunion.retval);
|
2016-08-31 15:00:28 +02:00
|
|
|
}
|
|
|
|
#else
|
2001-02-10 03:31:31 +01:00
|
|
|
extern Datum Float8GetDatum(float8 X);
|
2016-08-31 15:00:28 +02:00
|
|
|
#endif
|
2001-02-10 03:31:31 +01:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Int64GetDatumFast
|
|
|
|
* Float8GetDatumFast
|
|
|
|
*
|
2022-09-12 19:57:07 +02:00
|
|
|
* These macros are intended to allow writing code that does not depend on
|
2019-11-21 18:00:07 +01:00
|
|
|
* whether int64 and float8 are pass-by-reference types, while not
|
2001-02-10 03:31:31 +01:00
|
|
|
* sacrificing performance when they are. The argument must be a variable
|
|
|
|
* that will exist and have the same value for as long as the Datum is needed.
|
|
|
|
* In the pass-by-ref case, the address of the variable is taken to use as
|
2022-09-27 20:47:07 +02:00
|
|
|
* the Datum. In the pass-by-val case, these are the same as the non-Fast
|
|
|
|
* functions, except for asserting that the variable is of the correct type.
|
2001-02-10 03:31:31 +01:00
|
|
|
*/
|
|
|
|
|
2008-04-21 02:26:47 +02:00
|
|
|
#ifdef USE_FLOAT8_BYVAL
|
2022-09-27 20:47:07 +02:00
|
|
|
#define Int64GetDatumFast(X) \
|
|
|
|
(AssertVariableIsOfTypeMacro(X, int64), Int64GetDatum(X))
|
|
|
|
#define Float8GetDatumFast(X) \
|
|
|
|
(AssertVariableIsOfTypeMacro(X, double), Float8GetDatum(X))
|
2008-04-21 02:26:47 +02:00
|
|
|
#else
|
2022-09-27 20:47:07 +02:00
|
|
|
#define Int64GetDatumFast(X) \
|
|
|
|
(AssertVariableIsOfTypeMacro(X, int64), PointerGetDatum(&(X)))
|
|
|
|
#define Float8GetDatumFast(X) \
|
|
|
|
(AssertVariableIsOfTypeMacro(X, double), PointerGetDatum(&(X)))
|
2008-04-21 02:26:47 +02:00
|
|
|
#endif
|
|
|
|
|
2022-08-25 15:07:03 +02:00
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
2023-01-10 05:48:59 +01:00
|
|
|
* Section 2: miscellaneous
|
2022-08-25 15:07:03 +02:00
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NON_EXEC_STATIC: It's sometimes useful to define a variable or function
|
|
|
|
* that is normally static but extern when using EXEC_BACKEND (see
|
|
|
|
* pg_config_manual.h). There would then typically be some code in
|
|
|
|
* postmaster.c that uses those extern symbols to transfer state between
|
|
|
|
* processes or do whatever other things it needs to do in EXEC_BACKEND mode.
|
|
|
|
*/
|
|
|
|
#ifdef EXEC_BACKEND
|
|
|
|
#define NON_EXEC_STATIC
|
|
|
|
#else
|
|
|
|
#define NON_EXEC_STATIC static
|
|
|
|
#endif
|
|
|
|
|
1996-10-31 08:10:14 +01:00
|
|
|
#endif /* POSTGRES_H */
|