gitlab-pg_query 1.3.1 → 2.0.4

data/ext/pg_query/src_pl_plpgsql_src_pl_unreserved_kwlist_d.h

@@ -0,0 +1,255 @@
+/*--------------------------------------------------------------------
+ * Symbols referenced in this file:
+ * - UnreservedPLKeywords
+ * - UnreservedPLKeywords_kw_string
+ * - UnreservedPLKeywords_kw_offsets
+ * - UnreservedPLKeywords_hash_func
+ *--------------------------------------------------------------------
+ */
+
+/*-------------------------------------------------------------------------
+ *
+ * pl_unreserved_kwlist_d.h
+ *    List of keywords represented as a ScanKeywordList.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * NOTES
+ *  ******************************
+ *  *** DO NOT EDIT THIS FILE! ***
+ *  ******************************
+ *
+ *  It has been GENERATED by src/tools/gen_keywordlist.pl
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef PL_UNRESERVED_KWLIST_D_H
+#define PL_UNRESERVED_KWLIST_D_H
+
+#include "common/kwlookup.h"
+
+static const char UnreservedPLKeywords_kw_string[] =
+	"absolute\0"
+	"alias\0"
+	"and\0"
+	"array\0"
+	"assert\0"
+	"backward\0"
+	"call\0"
+	"chain\0"
+	"close\0"
+	"collate\0"
+	"column\0"
+	"column_name\0"
+	"commit\0"
+	"constant\0"
+	"constraint\0"
+	"constraint_name\0"
+	"continue\0"
+	"current\0"
+	"cursor\0"
+	"datatype\0"
+	"debug\0"
+	"default\0"
+	"detail\0"
+	"diagnostics\0"
+	"do\0"
+	"dump\0"
+	"elseif\0"
+	"elsif\0"
+	"errcode\0"
+	"error\0"
+	"exception\0"
+	"exit\0"
+	"fetch\0"
+	"first\0"
+	"forward\0"
+	"get\0"
+	"hint\0"
+	"import\0"
+	"info\0"
+	"insert\0"
+	"is\0"
+	"last\0"
+	"log\0"
+	"message\0"
+	"message_text\0"
+	"move\0"
+	"next\0"
+	"no\0"
+	"notice\0"
+	"open\0"
+	"option\0"
+	"perform\0"
+	"pg_context\0"
+	"pg_datatype_name\0"
+	"pg_exception_context\0"
+	"pg_exception_detail\0"
+	"pg_exception_hint\0"
+	"print_strict_params\0"
+	"prior\0"
+	"query\0"
+	"raise\0"
+	"relative\0"
+	"reset\0"
+	"return\0"
+	"returned_sqlstate\0"
+	"reverse\0"
+	"rollback\0"
+	"row_count\0"
+	"rowtype\0"
+	"schema\0"
+	"schema_name\0"
+	"scroll\0"
+	"set\0"
+	"slice\0"
+	"sqlstate\0"
+	"stacked\0"
+	"table\0"
+	"table_name\0"
+	"type\0"
+	"use_column\0"
+	"use_variable\0"
+	"variable_conflict\0"
+	"warning";
+
+static const uint16 UnreservedPLKeywords_kw_offsets[] = {
+	0,
+	9,
+	15,
+	19,
+	25,
+	32,
+	41,
+	46,
+	52,
+	58,
+	66,
+	73,
+	85,
+	92,
+	101,
+	112,
+	128,
+	137,
+	145,
+	152,
+	161,
+	167,
+	175,
+	182,
+	194,
+	197,
+	202,
+	209,
+	215,
+	223,
+	229,
+	239,
+	244,
+	250,
+	256,
+	264,
+	268,
+	273,
+	280,
+	285,
+	292,
+	295,
+	300,
+	304,
+	312,
+	325,
+	330,
+	335,
+	338,
+	345,
+	350,
+	357,
+	365,
+	376,
+	393,
+	414,
+	434,
+	452,
+	472,
+	478,
+	484,
+	490,
+	499,
+	505,
+	512,
+	530,
+	538,
+	547,
+	557,
+	565,
+	572,
+	584,
+	591,
+	595,
+	601,
+	610,
+	618,
+	624,
+	635,
+	640,
+	651,
+	664,
+	682,
+};
+
+#define UNRESERVEDPLKEYWORDS_NUM_KEYWORDS 83
+
+static int
+UnreservedPLKeywords_hash_func(const void *key, size_t keylen)
+{
+	static const int16 h[167] = {
+		    10,  32767,  32767,     57,  32767,     62,     21,  32767,
+		    54,     18,  32767,     58,     59,    -54,     47,      0,
+		   -22,    -64,  32767,    -22,     33,     44,     -5,  32767,
+		 32767,     43,     57,    102,  32767,    -65,      7,  32767,
+		    13,  32767,    -28,     14,  32767,  32767,     82,  32767,
+		     0,      0,  32767,      8,    -43,      0,     19,      8,
+		    75,    -58,  32767,  32767,      0,     22,     29,  32767,
+		   -50,      6,  32767,      0,     30,  32767,  32767,     29,
+		     0,    104,  32767,  32767,     26,      0,  32767,  32767,
+		    -9,      2,  32767,     50,     39,     38,     39,     80,
+		 32767,  32767,  32767,  32767,    -67,     89,  32767,    -40,
+		    64,  32767,  32767,     26,     10,     27,  32767,     19,
+		    51,    -13,     26,  32767,  32767,  32767,     84,     23,
+		     0,     66,     12,     -5,  32767,  32767,      0,     50,
+		   141,     72,     45,  32767,  32767,      0,    -22,      0,
+		 32767,  32767,    -34,      0,     19,     -5,  32767,  32767,
+		 32767,      0,     37,     13,  32767,  32767,  32767,  32767,
+		   -68,     -4,  32767,  32767,     78,  32767,  32767,      0,
+		    85,  32767,  32767,  32767,    -93,  32767,      0,      0,
+		 32767,     74,      5,  32767,  32767,     71,      0,  32767,
+		 32767,      0,  32767,  32767,  32767,     46,     70,
+	};
+
+	const unsigned char *k = (const unsigned char *) key;
+	uint32		a = 0;
+	uint32		b = 1;
+
+	while (keylen--)
+	{
+		unsigned char c = *k++ | 0x20;
+
+		a = a * 31 + c;
+		b = b * 127 + c;
+	}
+	return h[a % 167] + h[b % 167];
+}
+
+static const ScanKeywordList UnreservedPLKeywords = {
+	UnreservedPLKeywords_kw_string,
+	UnreservedPLKeywords_kw_offsets,
+	UnreservedPLKeywords_hash_func,
+	UNRESERVEDPLKEYWORDS_NUM_KEYWORDS,
+	20
+};
+
+#endif							/* PL_UNRESERVED_KWLIST_D_H */

data/ext/pg_query/src_port_erand48.c

@@ -0,0 +1,127 @@
+/*--------------------------------------------------------------------
+ * Symbols referenced in this file:
+ * - pg_lrand48
+ * - _dorand48
+ * - _rand48_seed
+ *--------------------------------------------------------------------
+ */
+
+/*-------------------------------------------------------------------------
+ *
+ * erand48.c
+ *
+ * This file supplies pg_erand48() and related functions, which except
+ * for the names are just like the POSIX-standard erand48() family.
+ * (We don't supply the full set though, only the ones we have found use
+ * for in Postgres.  In particular, we do *not* implement lcong48(), so
+ * that there is no need for the multiplier and addend to be variable.)
+ *
+ * We used to test for an operating system version rather than
+ * unconditionally using our own, but (1) some versions of Cygwin have a
+ * buggy erand48() that always returns zero and (2) as of 2011, glibc's
+ * erand48() is strangely coded to be almost-but-not-quite thread-safe,
+ * which doesn't matter for the backend but is important for pgbench.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ *
+ * Portions Copyright (c) 1993 Martin Birgmeier
+ * All rights reserved.
+ *
+ * You may redistribute unmodified or modified versions of this source
+ * code provided that the above copyright notice and this and the
+ * following conditions are retained.
+ *
+ * This software is provided ``as is'', and comes with no warranties
+ * of any kind. I shall in no event be liable for anything that happens
+ * to anyone/anything when using this software.
+ *
+ * IDENTIFICATION
+ *	  src/port/erand48.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "c.h"
+
+#include <math.h>
+
+/* These values are specified by POSIX */
+#define RAND48_MULT		UINT64CONST(0x0005deece66d)
+#define RAND48_ADD		UINT64CONST(0x000b)
+
+/* POSIX specifies 0x330e's use in srand48, but the other bits are arbitrary */
+#define RAND48_SEED_0	(0x330e)
+#define RAND48_SEED_1	(0xabcd)
+#define RAND48_SEED_2	(0x1234)
+
+static __thread unsigned short _rand48_seed[3] = {
+	RAND48_SEED_0,
+	RAND48_SEED_1,
+	RAND48_SEED_2
+};
+
+
+
+/*
+ * Advance the 48-bit value stored in xseed[] to the next "random" number.
+ *
+ * Also returns the value of that number --- without masking it to 48 bits.
+ * If caller uses the result, it must mask off the bits it wants.
+ */
+static uint64
+_dorand48(unsigned short xseed[3])
+{
+	/*
+	 * We do the arithmetic in uint64; any type wider than 48 bits would work.
+	 */
+	uint64		in;
+	uint64		out;
+
+	in = (uint64) xseed[2] << 32 | (uint64) xseed[1] << 16 | (uint64) xseed[0];
+
+	out = in * RAND48_MULT + RAND48_ADD;
+
+	xseed[0] = out & 0xFFFF;
+	xseed[1] = (out >> 16) & 0xFFFF;
+	xseed[2] = (out >> 32) & 0xFFFF;
+
+	return out;
+}
+
+
+/*
+ * Generate a random floating-point value using caller-supplied state.
+ * Values are uniformly distributed over the interval [0.0, 1.0).
+ */
+
+
+/*
+ * Generate a random non-negative integral value using internal state.
+ * Values are uniformly distributed over the interval [0, 2^31).
+ */
+long
+pg_lrand48(void)
+{
+	uint64		x = _dorand48(_rand48_seed);
+
+	return (x >> 17) & UINT64CONST(0x7FFFFFFF);
+}
+
+/*
+ * Generate a random signed integral value using caller-supplied state.
+ * Values are uniformly distributed over the interval [-2^31, 2^31).
+ */
+
+
+/*
+ * Initialize the internal state using the given seed.
+ *
+ * Per POSIX, this uses only 32 bits from "seed" even if "long" is wider.
+ * Hence, the set of possible seed values is smaller than it could be.
+ * Better practice is to use caller-supplied state and initialize it with
+ * random bits obtained from a high-quality source of random bits.
+ *
+ * Note: POSIX specifies a function seed48() that allows all 48 bits
+ * of the internal state to be set, but we don't currently support that.
+ */
+

data/ext/pg_query/src_port_pg_bitutils.c

@@ -0,0 +1,246 @@
+/*--------------------------------------------------------------------
+ * Symbols referenced in this file:
+ * - pg_popcount64
+ * - pg_popcount64_choose
+ * - pg_popcount32
+ * - pg_popcount32_choose
+ * - pg_popcount_available
+ * - pg_popcount32_asm
+ * - pg_popcount64_asm
+ * - pg_popcount32_slow
+ * - pg_popcount64_slow
+ *--------------------------------------------------------------------
+ */
+
+/*-------------------------------------------------------------------------
+ *
+ * pg_bitutils.c
+ *	  Miscellaneous functions for bit-wise operations.
+ *
+ * Copyright (c) 2019-2020, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/port/pg_bitutils.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "c.h"
+
+#ifdef HAVE__GET_CPUID
+#include <cpuid.h>
+#endif
+#ifdef HAVE__CPUID
+#include <intrin.h>
+#endif
+
+#include "port/pg_bitutils.h"
+
+
+/*
+ * Array giving the position of the left-most set bit for each possible
+ * byte value.  We count the right-most position as the 0th bit, and the
+ * left-most the 7th bit.  The 0th entry of the array should not be used.
+ *
+ * Note: this is not used by the functions in pg_bitutils.h when
+ * HAVE__BUILTIN_CLZ is defined, but we provide it anyway, so that
+ * extensions possibly compiled with a different compiler can use it.
+ */
+
+
+/*
+ * Array giving the position of the right-most set bit for each possible
+ * byte value.  We count the right-most position as the 0th bit, and the
+ * left-most the 7th bit.  The 0th entry of the array should not be used.
+ *
+ * Note: this is not used by the functions in pg_bitutils.h when
+ * HAVE__BUILTIN_CTZ is defined, but we provide it anyway, so that
+ * extensions possibly compiled with a different compiler can use it.
+ */
+
+
+/*
+ * Array giving the number of 1-bits in each possible byte value.
+ *
+ * Note: we export this for use by functions in which explicit use
+ * of the popcount functions seems unlikely to be a win.
+ */
+
+
+/*
+ * On x86_64, we can use the hardware popcount instruction, but only if
+ * we can verify that the CPU supports it via the cpuid instruction.
+ *
+ * Otherwise, we fall back to __builtin_popcount if the compiler has that,
+ * or a hand-rolled implementation if not.
+ */
+#ifdef HAVE_X86_64_POPCNTQ
+#if defined(HAVE__GET_CPUID) || defined(HAVE__CPUID)
+#define USE_POPCNT_ASM 1
+#endif
+#endif
+
+static int	pg_popcount32_slow(uint32 word);
+static int	pg_popcount64_slow(uint64 word);
+
+#ifdef USE_POPCNT_ASM
+static bool pg_popcount_available(void);
+static int	pg_popcount32_choose(uint32 word);
+static int	pg_popcount64_choose(uint64 word);
+static int	pg_popcount32_asm(uint32 word);
+static int	pg_popcount64_asm(uint64 word);
+
+int			(*pg_popcount32) (uint32 word) = pg_popcount32_choose;
+int			(*pg_popcount64) (uint64 word) = pg_popcount64_choose;
+#else
+int			(*pg_popcount32) (uint32 word) = pg_popcount32_slow;
+int			(*pg_popcount64) (uint64 word) = pg_popcount64_slow;
+#endif							/* USE_POPCNT_ASM */
+
+#ifdef USE_POPCNT_ASM
+
+/*
+ * Return true if CPUID indicates that the POPCNT instruction is available.
+ */
+static bool
+pg_popcount_available(void)
+{
+	unsigned int exx[4] = {0, 0, 0, 0};
+
+#if defined(HAVE__GET_CPUID)
+	__get_cpuid(1, &exx[0], &exx[1], &exx[2], &exx[3]);
+#elif defined(HAVE__CPUID)
+	__cpuid(exx, 1);
+#else
+#error cpuid instruction not available
+#endif
+
+	return (exx[2] & (1 << 23)) != 0;	/* POPCNT */
+}
+
+/*
+ * These functions get called on the first call to pg_popcount32 etc.
+ * They detect whether we can use the asm implementations, and replace
+ * the function pointers so that subsequent calls are routed directly to
+ * the chosen implementation.
+ */
+static int
+pg_popcount32_choose(uint32 word)
+{
+	if (pg_popcount_available())
+	{
+		pg_popcount32 = pg_popcount32_asm;
+		pg_popcount64 = pg_popcount64_asm;
+	}
+	else
+	{
+		pg_popcount32 = pg_popcount32_slow;
+		pg_popcount64 = pg_popcount64_slow;
+	}
+
+	return pg_popcount32(word);
+}
+
+static int
+pg_popcount64_choose(uint64 word)
+{
+	if (pg_popcount_available())
+	{
+		pg_popcount32 = pg_popcount32_asm;
+		pg_popcount64 = pg_popcount64_asm;
+	}
+	else
+	{
+		pg_popcount32 = pg_popcount32_slow;
+		pg_popcount64 = pg_popcount64_slow;
+	}
+
+	return pg_popcount64(word);
+}
+
+/*
+ * pg_popcount32_asm
+ *		Return the number of 1 bits set in word
+ */
+static int
+pg_popcount32_asm(uint32 word)
+{
+	uint32		res;
+
+__asm__ __volatile__(" popcntl %1,%0\n":"=q"(res):"rm"(word):"cc");
+	return (int) res;
+}
+
+/*
+ * pg_popcount64_asm
+ *		Return the number of 1 bits set in word
+ */
+static int
+pg_popcount64_asm(uint64 word)
+{
+	uint64		res;
+
+__asm__ __volatile__(" popcntq %1,%0\n":"=q"(res):"rm"(word):"cc");
+	return (int) res;
+}
+
+#endif							/* USE_POPCNT_ASM */
+
+
+/*
+ * pg_popcount32_slow
+ *		Return the number of 1 bits set in word
+ */
+static int
+pg_popcount32_slow(uint32 word)
+{
+#ifdef HAVE__BUILTIN_POPCOUNT
+	return __builtin_popcount(word);
+#else							/* !HAVE__BUILTIN_POPCOUNT */
+	int			result = 0;
+
+	while (word != 0)
+	{
+		result += pg_number_of_ones[word & 255];
+		word >>= 8;
+	}
+
+	return result;
+#endif							/* HAVE__BUILTIN_POPCOUNT */
+}
+
+/*
+ * pg_popcount64_slow
+ *		Return the number of 1 bits set in word
+ */
+static int
+pg_popcount64_slow(uint64 word)
+{
+#ifdef HAVE__BUILTIN_POPCOUNT
+#if defined(HAVE_LONG_INT_64)
+	return __builtin_popcountl(word);
+#elif defined(HAVE_LONG_LONG_INT_64)
+	return __builtin_popcountll(word);
+#else
+#error must have a working 64-bit integer datatype
+#endif
+#else							/* !HAVE__BUILTIN_POPCOUNT */
+	int			result = 0;
+
+	while (word != 0)
+	{
+		result += pg_number_of_ones[word & 255];
+		word >>= 8;
+	}
+
+	return result;
+#endif							/* HAVE__BUILTIN_POPCOUNT */
+}
+
+
+/*
+ * pg_popcount
+ *		Returns the number of 1-bits in buf
+ */
+#if SIZEOF_VOID_P >= 8
+#else
+#endif