pg_query 4.2.3 → 5.0.0

data/ext/pg_query/src_backend_utils_mb_mbutils.c

@@ -45,7 +45,7 @@
  * the result is validly encoded according to the destination encoding.
  *
  *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
@@ -62,6 +62,7 @@
 #include "utils/builtins.h"
 #include "utils/memutils.h"
 #include "utils/syscache.h"
+#include "varatt.h"
 
 /*
  * We maintain a simple linked list caching the fmgr lookup info for the
@@ -184,7 +185,7 @@ pg_get_client_encoding(void)
  *
  * The output is null-terminated.
  *
- * If destlen < srclen * MAX_CONVERSION_LENGTH + 1, the converted output
+ * If destlen < srclen * MAX_CONVERSION_INPUT_LENGTH + 1, the converted output
  * wouldn't necessarily fit in the output buffer, and the function will not
  * convert the whole input.
  *
@@ -339,12 +340,20 @@ pg_unicode_to_server(pg_wchar c, unsigned char *s)
 	FunctionCall6(Utf8ToServerConvProc,
 				  Int32GetDatum(PG_UTF8),
 				  Int32GetDatum(server_encoding),
-				  CStringGetDatum(c_as_utf8),
-				  CStringGetDatum(s),
+				  CStringGetDatum((char *) c_as_utf8),
+				  CStringGetDatum((char *) s),
 				  Int32GetDatum(c_as_utf8_len),
 				  BoolGetDatum(false));
 }
 
+/*
+ * Convert a single Unicode code point into a string in the server encoding.
+ *
+ * Same as pg_unicode_to_server(), except that we don't throw errors,
+ * but simply return false on conversion failure.
+ */
+
+
 
 /* convert a multibyte string to a wchar */
 

data/ext/pg_query/src_backend_utils_misc_guc_tables.c

@@ -0,0 +1,494 @@
+/*--------------------------------------------------------------------
+ * Symbols referenced in this file:
+ * - log_min_messages
+ * - client_min_messages
+ * - backtrace_functions
+ * - check_function_bodies
+ *--------------------------------------------------------------------
+ */
+
+/*--------------------------------------------------------------------
+ *
+ * guc_tables.c
+ *
+ * Static tables for the Grand Unified Configuration scheme.
+ *
+ * Many of these tables are const.  However, ConfigureNamesBool[]
+ * and so on are not, because the structs in those arrays are actually
+ * the live per-variable state data that guc.c manipulates.  While many of
+ * their fields are intended to be constant, some fields change at runtime.
+ *
+ *
+ * Copyright (c) 2000-2023, PostgreSQL Global Development Group
+ * Written by Peter Eisentraut <peter_e@gmx.net>.
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/misc/guc_tables.c
+ *
+ *--------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <float.h>
+#include <limits.h>
+#ifdef HAVE_SYSLOG
+#include <syslog.h>
+#endif
+
+#include "access/commit_ts.h"
+#include "access/gin.h"
+#include "access/toast_compression.h"
+#include "access/twophase.h"
+#include "access/xlog_internal.h"
+#include "access/xlogprefetcher.h"
+#include "access/xlogrecovery.h"
+#include "archive/archive_module.h"
+#include "catalog/namespace.h"
+#include "catalog/storage.h"
+#include "commands/async.h"
+#include "commands/tablespace.h"
+#include "commands/trigger.h"
+#include "commands/user.h"
+#include "commands/vacuum.h"
+#include "common/scram-common.h"
+#include "jit/jit.h"
+#include "libpq/auth.h"
+#include "libpq/libpq.h"
+#include "libpq/scram.h"
+#include "nodes/queryjumble.h"
+#include "optimizer/cost.h"
+#include "optimizer/geqo.h"
+#include "optimizer/optimizer.h"
+#include "optimizer/paths.h"
+#include "optimizer/planmain.h"
+#include "parser/parse_expr.h"
+#include "parser/parser.h"
+#include "pgstat.h"
+#include "postmaster/autovacuum.h"
+#include "postmaster/bgworker_internals.h"
+#include "postmaster/bgwriter.h"
+#include "postmaster/postmaster.h"
+#include "postmaster/startup.h"
+#include "postmaster/syslogger.h"
+#include "postmaster/walwriter.h"
+#include "replication/logicallauncher.h"
+#include "replication/slot.h"
+#include "replication/syncrep.h"
+#include "storage/bufmgr.h"
+#include "storage/large_object.h"
+#include "storage/pg_shmem.h"
+#include "storage/predicate.h"
+#include "storage/standby.h"
+#include "tcop/tcopprot.h"
+#include "tsearch/ts_cache.h"
+#include "utils/builtins.h"
+#include "utils/bytea.h"
+#include "utils/float.h"
+#include "utils/guc_hooks.h"
+#include "utils/guc_tables.h"
+#include "utils/memutils.h"
+#include "utils/pg_locale.h"
+#include "utils/portal.h"
+#include "utils/ps_status.h"
+#include "utils/inval.h"
+#include "utils/xml.h"
+
+/* This value is normally passed in from the Makefile */
+#ifndef PG_KRB_SRVTAB
+#define PG_KRB_SRVTAB ""
+#endif
+
+/* XXX these should appear in other modules' header files */
+extern bool Log_disconnections;
+extern int	CommitDelay;
+extern int	CommitSiblings;
+extern char *default_tablespace;
+extern char *temp_tablespaces;
+extern bool ignore_checksum_failure;
+extern bool ignore_invalid_pages;
+
+#ifdef TRACE_SYNCSCAN
+extern bool trace_syncscan;
+#endif
+#ifdef DEBUG_BOUNDED_SORT
+extern bool optimize_bounded_sort;
+#endif
+
+/*
+ * Options for enum values defined in this module.
+ *
+ * NOTE! Option values may not contain double quotes!
+ */
+
+
+
+StaticAssertDecl(lengthof(bytea_output_options) == (BYTEA_OUTPUT_HEX + 2),
+				 "array length mismatch");
+
+/*
+ * We have different sets for client and server message level options because
+ * they sort slightly different (see "log" level), and because "fatal"/"panic"
+ * aren't sensible for client_min_messages.
+ */
+
+
+
+
+
+
+
+
+StaticAssertDecl(lengthof(intervalstyle_options) == (INTSTYLE_ISO_8601 + 2),
+				 "array length mismatch");
+
+
+
+StaticAssertDecl(lengthof(log_error_verbosity_options) == (PGERROR_VERBOSE + 2),
+				 "array length mismatch");
+
+
+
+StaticAssertDecl(lengthof(log_statement_options) == (LOGSTMT_ALL + 2),
+				 "array length mismatch");
+
+
+
+
+
+StaticAssertDecl(lengthof(session_replication_role_options) == (SESSION_REPLICATION_ROLE_LOCAL + 2),
+				 "array length mismatch");
+
+#ifdef HAVE_SYSLOG
+#else
+#endif
+
+
+
+StaticAssertDecl(lengthof(track_function_options) == (TRACK_FUNC_ALL + 2),
+				 "array length mismatch");
+
+
+
+StaticAssertDecl(lengthof(stats_fetch_consistency) == (PGSTAT_FETCH_CONSISTENCY_SNAPSHOT + 2),
+				 "array length mismatch");
+
+
+
+StaticAssertDecl(lengthof(xmlbinary_options) == (XMLBINARY_HEX + 2),
+				 "array length mismatch");
+
+
+
+StaticAssertDecl(lengthof(xmloption_options) == (XMLOPTION_CONTENT + 2),
+				 "array length mismatch");
+
+/*
+ * Although only "on", "off", and "safe_encoding" are documented, we
+ * accept all the likely variants of "on" and "off".
+ */
+
+
+/*
+ * Although only "on", "off", and "auto" are documented, we accept
+ * all the likely variants of "on" and "off".
+ */
+
+
+/*
+ * Although only "on", "off", and "partition" are documented, we
+ * accept all the likely variants of "on" and "off".
+ */
+
+
+/*
+ * Although only "on", "off", "remote_apply", "remote_write", and "local" are
+ * documented, we accept all the likely variants of "on" and "off".
+ */
+
+
+/*
+ * Although only "on", "off", "try" are documented, we accept all the likely
+ * variants of "on" and "off".
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+StaticAssertDecl(lengthof(ssl_protocol_versions_info) == (PG_TLS1_3_VERSION + 2),
+				 "array length mismatch");
+
+#ifdef HAVE_SYNCFS
+#endif
+
+#ifndef WIN32
+#endif
+#ifndef EXEC_BACKEND
+#endif
+#ifdef WIN32
+#endif
+
+#ifdef  USE_LZ4
+#endif
+
+#ifdef USE_LZ4
+#endif
+#ifdef USE_ZSTD
+#endif
+
+/*
+ * Options for enum values stored in other modules
+ */
+extern const struct config_enum_entry wal_level_options[];
+extern const struct config_enum_entry archive_mode_options[];
+extern const struct config_enum_entry recovery_target_action_options[];
+extern const struct config_enum_entry sync_method_options[];
+extern const struct config_enum_entry dynamic_shared_memory_options[];
+
+/*
+ * GUC option variables that are exported from this module
+ */
+
+
+
+
+
+
+
+
+
+	/* this is sort of all three above
+											 * together */
+
+
+
+
+__thread bool		check_function_bodies = true;
+
+
+/*
+ * This GUC exists solely for backward compatibility, check its definition for
+ * details.
+ */
+
+
+
+
+__thread int			log_min_messages = WARNING;
+
+__thread int			client_min_messages = NOTICE;
+
+
+
+
+
+
+
+
+
+__thread char	   *backtrace_functions;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ * SSL renegotiation was been removed in PostgreSQL 9.5, but we tolerate it
+ * being set to zero (meaning never renegotiate) for backward compatibility.
+ * This avoids breaking compatibility with clients that have never supported
+ * renegotiation and therefore always try to zero it.
+ */
+
+
+/*
+ * This really belongs in pg_shmem.c, but is defined here so that it doesn't
+ * need to be duplicated in all the different implementations of pg_shmem.c.
+ */
+
+
+
+/*
+ * These variables are all dummies that don't do anything, except in some
+ * cases provide the value for SHOW to display.  The real state is elsewhere
+ * and is kept in sync by assign_hooks.
+ */
+
+
+
+
+
+
+
+
+
+#ifdef HAVE_SYSLOG
+#define	DEFAULT_SYSLOG_FACILITY LOG_LOCAL0
+#else
+#define	DEFAULT_SYSLOG_FACILITY 0
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#ifdef USE_ASSERT_CHECKING
+#define DEFAULT_ASSERT_ENABLED true
+#else
+#define DEFAULT_ASSERT_ENABLED false
+#endif
+
+
+
+
+
+
+
+
+/* should be static, but commands/variable.c needs to get at this */
+
+
+/* should be static, but guc.c needs to get at this */
+
+
+
+/*
+ * Displayable names for context types (enum GucContext)
+ *
+ * Note: these strings are deliberately not localized.
+ */
+
+
+StaticAssertDecl(lengthof(GucContext_Names) == (PGC_USERSET + 1),
+				 "array length mismatch");
+
+/*
+ * Displayable names for source types (enum GucSource)
+ *
+ * Note: these strings are deliberately not localized.
+ */
+
+
+StaticAssertDecl(lengthof(GucSource_Names) == (PGC_S_SESSION + 1),
+				 "array length mismatch");
+
+/*
+ * Displayable names for the groupings defined in enum config_group
+ */
+
+
+StaticAssertDecl(lengthof(config_group_names) == (DEVELOPER_OPTIONS + 2),
+				 "array length mismatch");
+
+/*
+ * Displayable names for GUC variable types (enum config_type)
+ *
+ * Note: these strings are deliberately not localized.
+ */
+
+
+StaticAssertDecl(lengthof(config_type_names) == (PGC_ENUM + 1),
+				 "array length mismatch");
+
+
+/*
+ * Contents of GUC tables
+ *
+ * See src/backend/utils/misc/README for design notes.
+ *
+ * TO ADD AN OPTION:
+ *
+ * 1. Declare a global variable of type bool, int, double, or char*
+ *	  and make use of it.
+ *
+ * 2. Decide at what times it's safe to set the option. See guc.h for
+ *	  details.
+ *
+ * 3. Decide on a name, a default value, upper and lower bounds (if
+ *	  applicable), etc.
+ *
+ * 4. Add a record below.
+ *
+ * 5. Add it to src/backend/utils/misc/postgresql.conf.sample, if
+ *	  appropriate.
+ *
+ * 6. Don't forget to document the option (at least in config.sgml).
+ *
+ * 7. If it's a new GUC_LIST_QUOTE option, you must add it to
+ *	  variable_is_guc_list_quote() in src/bin/pg_dump/dumputils.c.
+ */
+
+#ifdef BTREE_BUILD_STATS
+#endif
+#ifdef LOCK_DEBUG
+#endif
+#ifdef TRACE_SORT
+#endif
+#ifdef TRACE_SYNCSCAN
+#endif
+#ifdef DEBUG_BOUNDED_SORT
+#endif
+#ifdef WAL_DEBUG
+#endif
+
+
+#ifdef LOCK_DEBUG
+#endif
+#ifdef DISCARD_CACHES_ENABLED
+#if defined(CLOBBER_CACHE_RECURSIVELY)
+#else
+#endif
+#else							/* not DISCARD_CACHES_ENABLED */
+#endif							/* not DISCARD_CACHES_ENABLED */
+
+
+
+
+
+#ifdef USE_SSL
+#else
+#endif
+#ifdef USE_OPENSSL
+#else
+#endif
+#ifdef USE_SSL
+#else
+#endif
+
+
+

data/ext/pg_query/src_backend_utils_mmgr_alignedalloc.c

@@ -0,0 +1,163 @@
+/*--------------------------------------------------------------------
+ * Symbols referenced in this file:
+ * - AlignedAllocFree
+ * - AlignedAllocRealloc
+ * - AlignedAllocGetChunkContext
+ * - AlignedAllocGetChunkSpace
+ *--------------------------------------------------------------------
+ */
+
+/*-------------------------------------------------------------------------
+ *
+ * alignedalloc.c
+ *	  Allocator functions to implement palloc_aligned
+ *
+ * This is not a fully-fledged MemoryContext type as there is no means to
+ * create a MemoryContext of this type.  The code here only serves to allow
+ * operations such as pfree() and repalloc() to work correctly on a memory
+ * chunk that was allocated by palloc_aligned().
+ *
+ * Portions Copyright (c) 2022-2023, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/mmgr/alignedalloc.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "utils/memdebug.h"
+#include "utils/memutils_memorychunk.h"
+
+/*
+ * AlignedAllocFree
+*		Frees allocated memory; memory is removed from its owning context.
+*/
+void
+AlignedAllocFree(void *pointer)
+{
+	MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
+	void	   *unaligned;
+
+	VALGRIND_MAKE_MEM_DEFINED(chunk, sizeof(MemoryChunk));
+
+	Assert(!MemoryChunkIsExternal(chunk));
+
+	/* obtain the original (unaligned) allocated pointer */
+	unaligned = MemoryChunkGetBlock(chunk);
+
+#ifdef MEMORY_CONTEXT_CHECKING
+	/* Test for someone scribbling on unused space in chunk */
+	if (!sentinel_ok(pointer, chunk->requested_size))
+		elog(WARNING, "detected write past chunk end in %s %p",
+			 GetMemoryChunkContext(unaligned)->name, chunk);
+#endif
+
+	pfree(unaligned);
+}
+
+/*
+ * AlignedAllocRealloc
+ *		Change the allocated size of a chunk and return possibly a different
+ *		pointer to a memory address aligned to the same boundary as the
+ *		originally requested alignment.  The contents of 'pointer' will be
+ *		copied into the returned pointer up until 'size'.  Any additional
+ *		memory will be uninitialized.
+ */
+void *
+AlignedAllocRealloc(void *pointer, Size size)
+{
+	MemoryChunk *redirchunk = PointerGetMemoryChunk(pointer);
+	Size		alignto;
+	void	   *unaligned;
+	MemoryContext ctx;
+	Size		old_size;
+	void	   *newptr;
+
+	VALGRIND_MAKE_MEM_DEFINED(redirchunk, sizeof(MemoryChunk));
+
+	alignto = MemoryChunkGetValue(redirchunk);
+	unaligned = MemoryChunkGetBlock(redirchunk);
+
+	/* sanity check this is a power of 2 value */
+	Assert((alignto & (alignto - 1)) == 0);
+
+	/*
+	 * Determine the size of the original allocation.  We can't determine this
+	 * exactly as GetMemoryChunkSpace() returns the total space used for the
+	 * allocation, which for contexts like aset includes rounding up to the
+	 * next power of 2.  However, this value is just used to memcpy() the old
+	 * data into the new allocation, so we only need to concern ourselves with
+	 * not reading beyond the end of the original allocation's memory.  The
+	 * drawback here is that we may copy more bytes than we need to, which
+	 * only amounts to wasted effort.  We can safely subtract the extra bytes
+	 * that we requested to allow us to align the pointer.  We must also
+	 * subtract the space for the unaligned pointer's MemoryChunk since
+	 * GetMemoryChunkSpace should have included that.  This does assume that
+	 * all context types use MemoryChunk as a chunk header.
+	 */
+	old_size = GetMemoryChunkSpace(unaligned) -
+		PallocAlignedExtraBytes(alignto) - sizeof(MemoryChunk);
+
+#ifdef MEMORY_CONTEXT_CHECKING
+	/* check that GetMemoryChunkSpace returned something realistic */
+	Assert(old_size >= redirchunk->requested_size);
+#endif
+
+	ctx = GetMemoryChunkContext(unaligned);
+	newptr = MemoryContextAllocAligned(ctx, size, alignto, 0);
+
+	/*
+	 * We may memcpy beyond the end of the original allocation request size,
+	 * so we must mark the entire allocation as defined.
+	 */
+	VALGRIND_MAKE_MEM_DEFINED(pointer, old_size);
+	memcpy(newptr, pointer, Min(size, old_size));
+	pfree(unaligned);
+
+	return newptr;
+}
+
+/*
+ * AlignedAllocGetChunkContext
+ *		Return the MemoryContext that 'pointer' belongs to.
+ */
+MemoryContext
+AlignedAllocGetChunkContext(void *pointer)
+{
+	MemoryChunk *redirchunk = PointerGetMemoryChunk(pointer);
+	MemoryContext cxt;
+
+	VALGRIND_MAKE_MEM_DEFINED(redirchunk, sizeof(MemoryChunk));
+
+	Assert(!MemoryChunkIsExternal(redirchunk));
+
+	cxt = GetMemoryChunkContext(MemoryChunkGetBlock(redirchunk));
+
+	VALGRIND_MAKE_MEM_NOACCESS(redirchunk, sizeof(MemoryChunk));
+
+	return cxt;
+}
+
+/*
+ * AlignedAllocGetChunkSpace
+ *		Given a currently-allocated chunk, determine the total space
+ *		it occupies (including all memory-allocation overhead).
+ */
+Size
+AlignedAllocGetChunkSpace(void *pointer)
+{
+	MemoryChunk *redirchunk = PointerGetMemoryChunk(pointer);
+	void	   *unaligned;
+	Size		space;
+
+	VALGRIND_MAKE_MEM_DEFINED(redirchunk, sizeof(MemoryChunk));
+
+	unaligned = MemoryChunkGetBlock(redirchunk);
+	space = GetMemoryChunkSpace(unaligned);
+
+	VALGRIND_MAKE_MEM_NOACCESS(redirchunk, sizeof(MemoryChunk));
+
+	return space;
+}