pg_query 1.1.0 → 2.0.1

data/ext/pg_query/src_port_strerror.c

@@ -0,0 +1,324 @@
+/*--------------------------------------------------------------------
+ * Symbols referenced in this file:
+ * - pg_strerror_r
+ * - gnuish_strerror_r
+ * - get_errno_symbol
+ *--------------------------------------------------------------------
+ */
+
+/*-------------------------------------------------------------------------
+ *
+ * strerror.c
+ *	  Replacements for standard strerror() and strerror_r() functions
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/port/strerror.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "c.h"
+
+/*
+ * Within this file, "strerror" means the platform's function not pg_strerror,
+ * and likewise for "strerror_r"
+ */
+#undef strerror
+#undef strerror_r
+
+static char *gnuish_strerror_r(int errnum, char *buf, size_t buflen);
+static char *get_errno_symbol(int errnum);
+#ifdef WIN32
+static char *win32_socket_strerror(int errnum, char *buf, size_t buflen);
+#endif
+
+
+/*
+ * A slightly cleaned-up version of strerror()
+ */
+
+
+/*
+ * A slightly cleaned-up version of strerror_r()
+ */
+char *
+pg_strerror_r(int errnum, char *buf, size_t buflen)
+{
+	char	   *str;
+
+	/* If it's a Windows Winsock error, that needs special handling */
+#ifdef WIN32
+	/* Winsock error code range, per WinError.h */
+	if (errnum >= 10000 && errnum <= 11999)
+		return win32_socket_strerror(errnum, buf, buflen);
+#endif
+
+	/* Try the platform's strerror_r(), or maybe just strerror() */
+	str = gnuish_strerror_r(errnum, buf, buflen);
+
+	/*
+	 * Some strerror()s return an empty string for out-of-range errno.  This
+	 * is ANSI C spec compliant, but not exactly useful.  Also, we may get
+	 * back strings of question marks if libc cannot transcode the message to
+	 * the codeset specified by LC_CTYPE.  If we get nothing useful, first try
+	 * get_errno_symbol(), and if that fails, print the numeric errno.
+	 */
+	if (str == NULL || *str == '\0' || *str == '?')
+		str = get_errno_symbol(errnum);
+
+	if (str == NULL)
+	{
+		snprintf(buf, buflen, _("operating system error %d"), errnum);
+		str = buf;
+	}
+
+	return str;
+}
+
+/*
+ * Simple wrapper to emulate GNU strerror_r if what the platform provides is
+ * POSIX.  Also, if platform lacks strerror_r altogether, fall back to plain
+ * strerror; it might not be very thread-safe, but tough luck.
+ */
+static char *
+gnuish_strerror_r(int errnum, char *buf, size_t buflen)
+{
+#ifdef HAVE_STRERROR_R
+#ifdef STRERROR_R_INT
+	/* POSIX API */
+	if (strerror_r(errnum, buf, buflen) == 0)
+		return buf;
+	return NULL;				/* let caller deal with failure */
+#else
+	/* GNU API */
+	return strerror_r(errnum, buf, buflen);
+#endif
+#else							/* !HAVE_STRERROR_R */
+	char	   *sbuf = strerror(errnum);
+
+	if (sbuf == NULL)			/* can this still happen anywhere? */
+		return NULL;
+	/* To minimize thread-unsafety hazard, copy into caller's buffer */
+	strlcpy(buf, sbuf, buflen);
+	return buf;
+#endif
+}
+
+/*
+ * Returns a symbol (e.g. "ENOENT") for an errno code.
+ * Returns NULL if the code is unrecognized.
+ */
+static char *
+get_errno_symbol(int errnum)
+{
+	switch (errnum)
+	{
+		case E2BIG:
+			return "E2BIG";
+		case EACCES:
+			return "EACCES";
+#ifdef EADDRINUSE
+		case EADDRINUSE:
+			return "EADDRINUSE";
+#endif
+#ifdef EADDRNOTAVAIL
+		case EADDRNOTAVAIL:
+			return "EADDRNOTAVAIL";
+#endif
+		case EAFNOSUPPORT:
+			return "EAFNOSUPPORT";
+#ifdef EAGAIN
+		case EAGAIN:
+			return "EAGAIN";
+#endif
+#ifdef EALREADY
+		case EALREADY:
+			return "EALREADY";
+#endif
+		case EBADF:
+			return "EBADF";
+#ifdef EBADMSG
+		case EBADMSG:
+			return "EBADMSG";
+#endif
+		case EBUSY:
+			return "EBUSY";
+		case ECHILD:
+			return "ECHILD";
+#ifdef ECONNABORTED
+		case ECONNABORTED:
+			return "ECONNABORTED";
+#endif
+		case ECONNREFUSED:
+			return "ECONNREFUSED";
+#ifdef ECONNRESET
+		case ECONNRESET:
+			return "ECONNRESET";
+#endif
+		case EDEADLK:
+			return "EDEADLK";
+		case EDOM:
+			return "EDOM";
+		case EEXIST:
+			return "EEXIST";
+		case EFAULT:
+			return "EFAULT";
+		case EFBIG:
+			return "EFBIG";
+#ifdef EHOSTUNREACH
+		case EHOSTUNREACH:
+			return "EHOSTUNREACH";
+#endif
+		case EIDRM:
+			return "EIDRM";
+		case EINPROGRESS:
+			return "EINPROGRESS";
+		case EINTR:
+			return "EINTR";
+		case EINVAL:
+			return "EINVAL";
+		case EIO:
+			return "EIO";
+#ifdef EISCONN
+		case EISCONN:
+			return "EISCONN";
+#endif
+		case EISDIR:
+			return "EISDIR";
+#ifdef ELOOP
+		case ELOOP:
+			return "ELOOP";
+#endif
+		case EMFILE:
+			return "EMFILE";
+		case EMLINK:
+			return "EMLINK";
+		case EMSGSIZE:
+			return "EMSGSIZE";
+		case ENAMETOOLONG:
+			return "ENAMETOOLONG";
+		case ENFILE:
+			return "ENFILE";
+		case ENOBUFS:
+			return "ENOBUFS";
+		case ENODEV:
+			return "ENODEV";
+		case ENOENT:
+			return "ENOENT";
+		case ENOEXEC:
+			return "ENOEXEC";
+		case ENOMEM:
+			return "ENOMEM";
+		case ENOSPC:
+			return "ENOSPC";
+		case ENOSYS:
+			return "ENOSYS";
+#ifdef ENOTCONN
+		case ENOTCONN:
+			return "ENOTCONN";
+#endif
+		case ENOTDIR:
+			return "ENOTDIR";
+#if defined(ENOTEMPTY) && (ENOTEMPTY != EEXIST) /* same code on AIX */
+		case ENOTEMPTY:
+			return "ENOTEMPTY";
+#endif
+#ifdef ENOTSOCK
+		case ENOTSOCK:
+			return "ENOTSOCK";
+#endif
+#ifdef ENOTSUP
+		case ENOTSUP:
+			return "ENOTSUP";
+#endif
+		case ENOTTY:
+			return "ENOTTY";
+		case ENXIO:
+			return "ENXIO";
+#if defined(EOPNOTSUPP) && (!defined(ENOTSUP) || (EOPNOTSUPP != ENOTSUP))
+		case EOPNOTSUPP:
+			return "EOPNOTSUPP";
+#endif
+#ifdef EOVERFLOW
+		case EOVERFLOW:
+			return "EOVERFLOW";
+#endif
+		case EPERM:
+			return "EPERM";
+		case EPIPE:
+			return "EPIPE";
+		case EPROTONOSUPPORT:
+			return "EPROTONOSUPPORT";
+		case ERANGE:
+			return "ERANGE";
+#ifdef EROFS
+		case EROFS:
+			return "EROFS";
+#endif
+		case ESRCH:
+			return "ESRCH";
+#ifdef ETIMEDOUT
+		case ETIMEDOUT:
+			return "ETIMEDOUT";
+#endif
+#ifdef ETXTBSY
+		case ETXTBSY:
+			return "ETXTBSY";
+#endif
+#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
+		case EWOULDBLOCK:
+			return "EWOULDBLOCK";
+#endif
+		case EXDEV:
+			return "EXDEV";
+	}
+
+	return NULL;
+}
+
+
+#ifdef WIN32
+
+/*
+ * Windows' strerror() doesn't know the Winsock codes, so handle them this way
+ */
+static char *
+win32_socket_strerror(int errnum, char *buf, size_t buflen)
+{
+	static HANDLE handleDLL = INVALID_HANDLE_VALUE;
+
+	if (handleDLL == INVALID_HANDLE_VALUE)
+	{
+		handleDLL = LoadLibraryEx("netmsg.dll", NULL,
+								  DONT_RESOLVE_DLL_REFERENCES | LOAD_LIBRARY_AS_DATAFILE);
+		if (handleDLL == NULL)
+		{
+			snprintf(buf, buflen,
+					 "winsock error %d (could not load netmsg.dll to translate: error code %lu)",
+					 errnum, GetLastError());
+			return buf;
+		}
+	}
+
+	ZeroMemory(buf, buflen);
+	if (FormatMessage(FORMAT_MESSAGE_IGNORE_INSERTS |
+					  FORMAT_MESSAGE_FROM_SYSTEM |
+					  FORMAT_MESSAGE_FROM_HMODULE,
+					  handleDLL,
+					  errnum,
+					  MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),
+					  buf,
+					  buflen - 1,
+					  NULL) == 0)
+	{
+		/* Failed to get id */
+		snprintf(buf, buflen, "unrecognized winsock error %d", errnum);
+	}
+
+	return buf;
+}
+
+#endif							/* WIN32 */

data/ext/pg_query/src_port_strnlen.c

@@ -0,0 +1,39 @@
+/*--------------------------------------------------------------------
+ * Symbols referenced in this file:
+ * - strnlen
+ *--------------------------------------------------------------------
+ */
+
+/*-------------------------------------------------------------------------
+ *
+ * strnlen.c
+ *		Fallback implementation of strnlen().
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/port/strnlen.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "c.h"
+
+/*
+ * Implementation of posix' strnlen for systems where it's not available.
+ *
+ * Returns the number of characters before a null-byte in the string pointed
+ * to by str, unless there's no null-byte before maxlen. In the latter case
+ * maxlen is returned.
+ */
+size_t
+strnlen(const char *str, size_t maxlen)
+{
+	const char *p = str;
+
+	while (maxlen-- > 0 && *p)
+		p++;
+	return p - str;
+}

data/ext/pg_query/xxhash.c

@@ -0,0 +1,43 @@
+/*
+ * xxHash - Extremely Fast Hash algorithm
+ * Copyright (C) 2012-2020 Yann Collet
+ *
+ * BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php)
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following disclaimer
+ *      in the documentation and/or other materials provided with the
+ *      distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * You can contact the author at:
+ *   - xxHash homepage: https://www.xxhash.com
+ *   - xxHash source repository: https://github.com/Cyan4973/xxHash
+ */
+
+
+/*
+ * xxhash.c instantiates functions defined in xxhash.h
+ */
+
+#define XXH_STATIC_LINKING_ONLY   /* access advanced declarations */
+#define XXH_IMPLEMENTATION   /* access definitions */
+
+#include "xxhash.h"

data/lib/pg_query.rb

@@ -1,16 +1,19 @@
 require 'pg_query/version'
 require 'pg_query/parse_error'
 
+require 'pg_query/pg_query_pb'
+require 'pg_query/node'
+
 require 'pg_query/pg_query'
+require 'pg_query/constants'
 require 'pg_query/parse'
 require 'pg_query/treewalker'
-require 'pg_query/node_types'
-require 'pg_query/deep_dup'
-
-require 'pg_query/legacy_parsetree'
 
 require 'pg_query/filter_columns'
+require 'pg_query/json_field_names'
 require 'pg_query/fingerprint'
 require 'pg_query/param_refs'
 require 'pg_query/deparse'
 require 'pg_query/truncate'
+
+require 'pg_query/scan'

data/lib/pg_query/constants.rb

@@ -0,0 +1,21 @@
+module PgQuery
+  # From Postgres source: src/include/storage/lockdefs.h
+  LOCK_MODE_NO_LOCK = 0 # NoLock is not a lock mode, but a flag value meaning "don't get a lock"
+  LOCK_MODE_ACCESS_SHARE_LOCK = 1 # SELECT
+  LOCK_MODE_ROW_SHARE_LOCK = 2 # SELECT FOR UPDATE/FOR SHARE
+  LOCK_MODE_ROW_EXCLUSIVE_LOCK = 3 # INSERT, UPDATE, DELETE
+  LOCK_MODE_SHARE_UPDATE_EXCLUSIVE_LOCK = 4 # VACUUM (non-FULL),ANALYZE, CREATE INDEX CONCURRENTLY
+  LOCK_MODE_SHARE_LOCK = 5 # CREATE INDEX (WITHOUT CONCURRENTLY)
+  LOCK_MODE_SHARE_ROW_EXCLUSIVE_LOCK = 6 # like EXCLUSIVE MODE, but allows ROW SHARE
+  LOCK_MODE_EXCLUSIVE_LOCK = 7 # blocks ROW SHARE/SELECT...FOR UPDATE
+  LOCK_MODE_ACCESS_EXCLUSIVE_LOCK = 8 # ALTER TABLE, DROP TABLE, VACUUM FULL, and unqualified LOCK TABLE
+
+  # From Postgres source: src/include/catalog/pg_trigger.h
+  TRIGGER_TYPE_ROW = (1 << 0)
+  TRIGGER_TYPE_BEFORE = (1 << 1)
+  TRIGGER_TYPE_INSERT = (1 << 2)
+  TRIGGER_TYPE_DELETE = (1 << 3)
+  TRIGGER_TYPE_UPDATE = (1 << 4)
+  TRIGGER_TYPE_TRUNCATE = (1 << 5)
+  TRIGGER_TYPE_INSTEAD = (1 << 6)
+end