pg_query 1.1.0 → 2.0.1

data/ext/pg_query/include/utils/expandedrecord.h

@@ -0,0 +1,231 @@
+/*-------------------------------------------------------------------------
+ *
+ * expandedrecord.h
+ *	  Declarations for composite expanded objects.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/utils/expandedrecord.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef EXPANDEDRECORD_H
+#define EXPANDEDRECORD_H
+
+#include "access/htup.h"
+#include "access/tupdesc.h"
+#include "fmgr.h"
+#include "utils/expandeddatum.h"
+
+
+/*
+ * An expanded record is contained within a private memory context (as
+ * all expanded objects must be) and has a control structure as below.
+ *
+ * The expanded record might contain a regular "flat" tuple if that was the
+ * original input and we've not modified it.  Otherwise, the contents are
+ * represented by Datum/isnull arrays plus type information.  We could also
+ * have both forms, if we've deconstructed the original tuple for access
+ * purposes but not yet changed it.  For pass-by-reference field types, the
+ * Datums would point into the flat tuple in this situation.  Once we start
+ * modifying tuple fields, new pass-by-ref fields are separately palloc'd
+ * within the memory context.
+ *
+ * It's possible to build an expanded record that references a "flat" tuple
+ * stored externally, if the caller can guarantee that that tuple will not
+ * change for the lifetime of the expanded record.  (This frammish is mainly
+ * meant to avoid unnecessary data copying in trigger functions.)
+ */
+#define ER_MAGIC 1384727874		/* ID for debugging crosschecks */
+
+typedef struct ExpandedRecordHeader
+{
+	/* Standard header for expanded objects */
+	ExpandedObjectHeader hdr;
+
+	/* Magic value identifying an expanded record (for debugging only) */
+	int			er_magic;
+
+	/* Assorted flag bits */
+	int			flags;
+#define ER_FLAG_FVALUE_VALID	0x0001	/* fvalue is up to date? */
+#define ER_FLAG_FVALUE_ALLOCED	0x0002	/* fvalue is local storage? */
+#define ER_FLAG_DVALUES_VALID	0x0004	/* dvalues/dnulls are up to date? */
+#define ER_FLAG_DVALUES_ALLOCED	0x0008	/* any field values local storage? */
+#define ER_FLAG_HAVE_EXTERNAL	0x0010	/* any field values are external? */
+#define ER_FLAG_TUPDESC_ALLOCED	0x0020	/* tupdesc is local storage? */
+#define ER_FLAG_IS_DOMAIN		0x0040	/* er_decltypeid is domain? */
+#define ER_FLAG_IS_DUMMY		0x0080	/* this header is dummy (see below) */
+/* flag bits that are not to be cleared when replacing tuple data: */
+#define ER_FLAGS_NON_DATA \
+	(ER_FLAG_TUPDESC_ALLOCED | ER_FLAG_IS_DOMAIN | ER_FLAG_IS_DUMMY)
+
+	/* Declared type of the record variable (could be a domain type) */
+	Oid			er_decltypeid;
+
+	/*
+	 * Actual composite type/typmod; never a domain (if ER_FLAG_IS_DOMAIN,
+	 * these identify the composite base type).  These will match
+	 * er_tupdesc->tdtypeid/tdtypmod, as well as the header fields of
+	 * composite datums made from or stored in this expanded record.
+	 */
+	Oid			er_typeid;		/* type OID of the composite type */
+	int32		er_typmod;		/* typmod of the composite type */
+
+	/*
+	 * Tuple descriptor, if we have one, else NULL.  This may point to a
+	 * reference-counted tupdesc originally belonging to the typcache, in
+	 * which case we use a memory context reset callback to release the
+	 * refcount.  It can also be locally allocated in this object's private
+	 * context (in which case ER_FLAG_TUPDESC_ALLOCED is set).
+	 */
+	TupleDesc	er_tupdesc;
+
+	/*
+	 * Unique-within-process identifier for the tupdesc (see typcache.h). This
+	 * field will never be equal to INVALID_TUPLEDESC_IDENTIFIER.
+	 */
+	uint64		er_tupdesc_id;
+
+	/*
+	 * If we have a Datum-array representation of the record, it's kept here;
+	 * else ER_FLAG_DVALUES_VALID is not set, and dvalues/dnulls may be NULL
+	 * if they've not yet been allocated.  If allocated, the dvalues and
+	 * dnulls arrays are palloc'd within the object private context, and are
+	 * of length matching er_tupdesc->natts.  For pass-by-ref field types,
+	 * dvalues entries might point either into the fstartptr..fendptr area, or
+	 * to separately palloc'd chunks.
+	 */
+	Datum	   *dvalues;		/* array of Datums */
+	bool	   *dnulls;			/* array of is-null flags for Datums */
+	int			nfields;		/* length of above arrays */
+
+	/*
+	 * flat_size is the current space requirement for the flat equivalent of
+	 * the expanded record, if known; otherwise it's 0.  We store this to make
+	 * consecutive calls of get_flat_size cheap.  If flat_size is not 0, the
+	 * component values data_len, hoff, and hasnull must be valid too.
+	 */
+	Size		flat_size;
+
+	Size		data_len;		/* data len within flat_size */
+	int			hoff;			/* header offset */
+	bool		hasnull;		/* null bitmap needed? */
+
+	/*
+	 * fvalue points to the flat representation if we have one, else it is
+	 * NULL.  If the flat representation is valid (up to date) then
+	 * ER_FLAG_FVALUE_VALID is set.  Even if we've outdated the flat
+	 * representation due to changes of user fields, it can still be used to
+	 * fetch system column values.  If we have a flat representation then
+	 * fstartptr/fendptr point to the start and end+1 of its data area; this
+	 * is so that we can tell which Datum pointers point into the flat
+	 * representation rather than being pointers to separately palloc'd data.
+	 */
+	HeapTuple	fvalue;			/* might or might not be private storage */
+	char	   *fstartptr;		/* start of its data area */
+	char	   *fendptr;		/* end+1 of its data area */
+
+	/* Some operations on the expanded record need a short-lived context */
+	MemoryContext er_short_term_cxt;	/* short-term memory context */
+
+	/* Working state for domain checking, used if ER_FLAG_IS_DOMAIN is set */
+	struct ExpandedRecordHeader *er_dummy_header;	/* dummy record header */
+	void	   *er_domaininfo;	/* cache space for domain_check() */
+
+	/* Callback info (it's active if er_mcb.arg is not NULL) */
+	MemoryContextCallback er_mcb;
+} ExpandedRecordHeader;
+
+/* fmgr macros for expanded record objects */
+#define PG_GETARG_EXPANDED_RECORD(n)  DatumGetExpandedRecord(PG_GETARG_DATUM(n))
+#define ExpandedRecordGetDatum(erh)   EOHPGetRWDatum(&(erh)->hdr)
+#define ExpandedRecordGetRODatum(erh) EOHPGetRODatum(&(erh)->hdr)
+#define PG_RETURN_EXPANDED_RECORD(x)  PG_RETURN_DATUM(ExpandedRecordGetDatum(x))
+
+/* assorted other macros */
+#define ExpandedRecordIsEmpty(erh) \
+	(((erh)->flags & (ER_FLAG_DVALUES_VALID | ER_FLAG_FVALUE_VALID)) == 0)
+#define ExpandedRecordIsDomain(erh) \
+	(((erh)->flags & ER_FLAG_IS_DOMAIN) != 0)
+
+/* this can substitute for TransferExpandedObject() when we already have erh */
+#define TransferExpandedRecord(erh, cxt) \
+	MemoryContextSetParent((erh)->hdr.eoh_context, cxt)
+
+/* information returned by expanded_record_lookup_field() */
+typedef struct ExpandedRecordFieldInfo
+{
+	int			fnumber;		/* field's attr number in record */
+	Oid			ftypeid;		/* field's type/typmod info */
+	int32		ftypmod;
+	Oid			fcollation;		/* field's collation if any */
+} ExpandedRecordFieldInfo;
+
+/*
+ * prototypes for functions defined in expandedrecord.c
+ */
+extern ExpandedRecordHeader *make_expanded_record_from_typeid(Oid type_id, int32 typmod,
+															  MemoryContext parentcontext);
+extern ExpandedRecordHeader *make_expanded_record_from_tupdesc(TupleDesc tupdesc,
+															   MemoryContext parentcontext);
+extern ExpandedRecordHeader *make_expanded_record_from_exprecord(ExpandedRecordHeader *olderh,
+																 MemoryContext parentcontext);
+extern void expanded_record_set_tuple(ExpandedRecordHeader *erh,
+									  HeapTuple tuple, bool copy, bool expand_external);
+extern Datum make_expanded_record_from_datum(Datum recorddatum,
+											 MemoryContext parentcontext);
+extern TupleDesc expanded_record_fetch_tupdesc(ExpandedRecordHeader *erh);
+extern HeapTuple expanded_record_get_tuple(ExpandedRecordHeader *erh);
+extern ExpandedRecordHeader *DatumGetExpandedRecord(Datum d);
+extern void deconstruct_expanded_record(ExpandedRecordHeader *erh);
+extern bool expanded_record_lookup_field(ExpandedRecordHeader *erh,
+										 const char *fieldname,
+										 ExpandedRecordFieldInfo *finfo);
+extern Datum expanded_record_fetch_field(ExpandedRecordHeader *erh, int fnumber,
+										 bool *isnull);
+extern void expanded_record_set_field_internal(ExpandedRecordHeader *erh,
+											   int fnumber,
+											   Datum newValue, bool isnull,
+											   bool expand_external,
+											   bool check_constraints);
+extern void expanded_record_set_fields(ExpandedRecordHeader *erh,
+									   const Datum *newValues, const bool *isnulls,
+									   bool expand_external);
+
+/* outside code should never call expanded_record_set_field_internal as such */
+#define expanded_record_set_field(erh, fnumber, newValue, isnull, expand_external) \
+	expanded_record_set_field_internal(erh, fnumber, newValue, isnull, expand_external, true)
+
+/*
+ * Inline-able fast cases.  The expanded_record_fetch_xxx functions above
+ * handle the general cases.
+ */
+
+/* Get the tupdesc for the expanded record's actual type */
+static inline TupleDesc
+expanded_record_get_tupdesc(ExpandedRecordHeader *erh)
+{
+	if (likely(erh->er_tupdesc != NULL))
+		return erh->er_tupdesc;
+	else
+		return expanded_record_fetch_tupdesc(erh);
+}
+
+/* Get value of record field */
+static inline Datum
+expanded_record_get_field(ExpandedRecordHeader *erh, int fnumber,
+						  bool *isnull)
+{
+	if ((erh->flags & ER_FLAG_DVALUES_VALID) &&
+		likely(fnumber > 0 && fnumber <= erh->nfields))
+	{
+		*isnull = erh->dnulls[fnumber - 1];
+		return erh->dvalues[fnumber - 1];
+	}
+	else
+		return expanded_record_fetch_field(erh, fnumber, isnull);
+}
+
+#endif							/* EXPANDEDRECORD_H */

data/ext/pg_query/include/utils/float.h

@@ -0,0 +1,356 @@
+/*-------------------------------------------------------------------------
+ *
+ * float.h
+ *	  Definitions for the built-in floating-point types
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/include/utils/float.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FLOAT_H
+#define FLOAT_H
+
+#include <math.h>
+
+#ifndef M_PI
+/* From my RH5.2 gcc math.h file - thomas 2000-04-03 */
+#define M_PI 3.14159265358979323846
+#endif
+
+/* Radians per degree, a.k.a. PI / 180 */
+#define RADIANS_PER_DEGREE 0.0174532925199432957692
+
+/* Visual C++ etc lacks NAN, and won't accept 0.0/0.0. */
+#if defined(WIN32) && !defined(NAN)
+static const uint32 nan[2] = {0xffffffff, 0x7fffffff};
+
+#define NAN (*(const float8 *) nan)
+#endif
+
+extern PGDLLIMPORT int extra_float_digits;
+
+/*
+ * Utility functions in float.c
+ */
+extern void float_overflow_error(void) pg_attribute_noreturn();
+extern void float_underflow_error(void) pg_attribute_noreturn();
+extern void float_zero_divide_error(void) pg_attribute_noreturn();
+extern int	is_infinite(float8 val);
+extern float8 float8in_internal(char *num, char **endptr_p,
+								const char *type_name, const char *orig_string);
+extern float8 float8in_internal_opt_error(char *num, char **endptr_p,
+										  const char *type_name, const char *orig_string,
+										  bool *have_error);
+extern char *float8out_internal(float8 num);
+extern int	float4_cmp_internal(float4 a, float4 b);
+extern int	float8_cmp_internal(float8 a, float8 b);
+
+/*
+ * Routines to provide reasonably platform-independent handling of
+ * infinity and NaN
+ *
+ * We assume that isinf() and isnan() are available and work per spec.
+ * (On some platforms, we have to supply our own; see src/port.)  However,
+ * generating an Infinity or NaN in the first place is less well standardized;
+ * pre-C99 systems tend not to have C99's INFINITY and NaN macros.  We
+ * centralize our workarounds for this here.
+ */
+
+/*
+ * The funny placements of the two #pragmas is necessary because of a
+ * long lived bug in the Microsoft compilers.
+ * See http://support.microsoft.com/kb/120968/en-us for details
+ */
+#ifdef _MSC_VER
+#pragma warning(disable:4756)
+#endif
+static inline float4
+get_float4_infinity(void)
+{
+#ifdef INFINITY
+	/* C99 standard way */
+	return (float4) INFINITY;
+#else
+#ifdef _MSC_VER
+#pragma warning(default:4756)
+#endif
+
+	/*
+	 * On some platforms, HUGE_VAL is an infinity, elsewhere it's just the
+	 * largest normal float8.  We assume forcing an overflow will get us a
+	 * true infinity.
+	 */
+	return (float4) (HUGE_VAL * HUGE_VAL);
+#endif
+}
+
+static inline float8
+get_float8_infinity(void)
+{
+#ifdef INFINITY
+	/* C99 standard way */
+	return (float8) INFINITY;
+#else
+
+	/*
+	 * On some platforms, HUGE_VAL is an infinity, elsewhere it's just the
+	 * largest normal float8.  We assume forcing an overflow will get us a
+	 * true infinity.
+	 */
+	return (float8) (HUGE_VAL * HUGE_VAL);
+#endif
+}
+
+static inline float4
+get_float4_nan(void)
+{
+#ifdef NAN
+	/* C99 standard way */
+	return (float4) NAN;
+#else
+	/* Assume we can get a NAN via zero divide */
+	return (float4) (0.0 / 0.0);
+#endif
+}
+
+static inline float8
+get_float8_nan(void)
+{
+	/* (float8) NAN doesn't work on some NetBSD/MIPS releases */
+#if defined(NAN) && !(defined(__NetBSD__) && defined(__mips__))
+	/* C99 standard way */
+	return (float8) NAN;
+#else
+	/* Assume we can get a NaN via zero divide */
+	return (float8) (0.0 / 0.0);
+#endif
+}
+
+/*
+ * Floating-point arithmetic with overflow/underflow reported as errors
+ *
+ * There isn't any way to check for underflow of addition/subtraction
+ * because numbers near the underflow value have already been rounded to
+ * the point where we can't detect that the two values were originally
+ * different, e.g. on x86, '1e-45'::float4 == '2e-45'::float4 ==
+ * 1.4013e-45.
+ */
+
+static inline float4
+float4_pl(const float4 val1, const float4 val2)
+{
+	float4		result;
+
+	result = val1 + val2;
+	if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
+		float_overflow_error();
+
+	return result;
+}
+
+static inline float8
+float8_pl(const float8 val1, const float8 val2)
+{
+	float8		result;
+
+	result = val1 + val2;
+	if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
+		float_overflow_error();
+
+	return result;
+}
+
+static inline float4
+float4_mi(const float4 val1, const float4 val2)
+{
+	float4		result;
+
+	result = val1 - val2;
+	if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
+		float_overflow_error();
+
+	return result;
+}
+
+static inline float8
+float8_mi(const float8 val1, const float8 val2)
+{
+	float8		result;
+
+	result = val1 - val2;
+	if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
+		float_overflow_error();
+
+	return result;
+}
+
+static inline float4
+float4_mul(const float4 val1, const float4 val2)
+{
+	float4		result;
+
+	result = val1 * val2;
+	if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
+		float_overflow_error();
+	if (unlikely(result == 0.0f) && val1 != 0.0f && val2 != 0.0f)
+		float_underflow_error();
+
+	return result;
+}
+
+static inline float8
+float8_mul(const float8 val1, const float8 val2)
+{
+	float8		result;
+
+	result = val1 * val2;
+	if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
+		float_overflow_error();
+	if (unlikely(result == 0.0) && val1 != 0.0 && val2 != 0.0)
+		float_underflow_error();
+
+	return result;
+}
+
+static inline float4
+float4_div(const float4 val1, const float4 val2)
+{
+	float4		result;
+
+	if (unlikely(val2 == 0.0f))
+		float_zero_divide_error();
+	result = val1 / val2;
+	if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
+		float_overflow_error();
+	if (unlikely(result == 0.0f) && val1 != 0.0f)
+		float_underflow_error();
+
+	return result;
+}
+
+static inline float8
+float8_div(const float8 val1, const float8 val2)
+{
+	float8		result;
+
+	if (unlikely(val2 == 0.0))
+		float_zero_divide_error();
+	result = val1 / val2;
+	if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
+		float_overflow_error();
+	if (unlikely(result == 0.0) && val1 != 0.0)
+		float_underflow_error();
+
+	return result;
+}
+
+/*
+ * Routines for NaN-aware comparisons
+ *
+ * We consider all NaNs to be equal and larger than any non-NaN. This is
+ * somewhat arbitrary; the important thing is to have a consistent sort
+ * order.
+ */
+
+static inline bool
+float4_eq(const float4 val1, const float4 val2)
+{
+	return isnan(val1) ? isnan(val2) : !isnan(val2) && val1 == val2;
+}
+
+static inline bool
+float8_eq(const float8 val1, const float8 val2)
+{
+	return isnan(val1) ? isnan(val2) : !isnan(val2) && val1 == val2;
+}
+
+static inline bool
+float4_ne(const float4 val1, const float4 val2)
+{
+	return isnan(val1) ? !isnan(val2) : isnan(val2) || val1 != val2;
+}
+
+static inline bool
+float8_ne(const float8 val1, const float8 val2)
+{
+	return isnan(val1) ? !isnan(val2) : isnan(val2) || val1 != val2;
+}
+
+static inline bool
+float4_lt(const float4 val1, const float4 val2)
+{
+	return !isnan(val1) && (isnan(val2) || val1 < val2);
+}
+
+static inline bool
+float8_lt(const float8 val1, const float8 val2)
+{
+	return !isnan(val1) && (isnan(val2) || val1 < val2);
+}
+
+static inline bool
+float4_le(const float4 val1, const float4 val2)
+{
+	return isnan(val2) || (!isnan(val1) && val1 <= val2);
+}
+
+static inline bool
+float8_le(const float8 val1, const float8 val2)
+{
+	return isnan(val2) || (!isnan(val1) && val1 <= val2);
+}
+
+static inline bool
+float4_gt(const float4 val1, const float4 val2)
+{
+	return !isnan(val2) && (isnan(val1) || val1 > val2);
+}
+
+static inline bool
+float8_gt(const float8 val1, const float8 val2)
+{
+	return !isnan(val2) && (isnan(val1) || val1 > val2);
+}
+
+static inline bool
+float4_ge(const float4 val1, const float4 val2)
+{
+	return isnan(val1) || (!isnan(val2) && val1 >= val2);
+}
+
+static inline bool
+float8_ge(const float8 val1, const float8 val2)
+{
+	return isnan(val1) || (!isnan(val2) && val1 >= val2);
+}
+
+static inline float4
+float4_min(const float4 val1, const float4 val2)
+{
+	return float4_lt(val1, val2) ? val1 : val2;
+}
+
+static inline float8
+float8_min(const float8 val1, const float8 val2)
+{
+	return float8_lt(val1, val2) ? val1 : val2;
+}
+
+static inline float4
+float4_max(const float4 val1, const float4 val2)
+{
+	return float4_gt(val1, val2) ? val1 : val2;
+}
+
+static inline float8
+float8_max(const float8 val1, const float8 val2)
+{
+	return float8_gt(val1, val2) ? val1 : val2;
+}
+
+#endif							/* FLOAT_H */