embedded-postgres 18.6.0__py3-none-win_amd64.whl

embedded_postgres/pginstall/include/server/common/int128.h

@@ -0,0 +1,276 @@
+/*-------------------------------------------------------------------------
+ *
+ * int128.h
+ *	  Roll-our-own 128-bit integer arithmetic.
+ *
+ * We make use of the native int128 type if there is one, otherwise
+ * implement things the hard way based on two int64 halves.
+ *
+ * See src/tools/testint128.c for a simple test harness for this file.
+ *
+ * Copyright (c) 2017-2025, PostgreSQL Global Development Group
+ *
+ * src/include/common/int128.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef INT128_H
+#define INT128_H
+
+/*
+ * For testing purposes, use of native int128 can be switched on/off by
+ * predefining USE_NATIVE_INT128.
+ */
+#ifndef USE_NATIVE_INT128
+#ifdef HAVE_INT128
+#define USE_NATIVE_INT128 1
+#else
+#define USE_NATIVE_INT128 0
+#endif
+#endif
+
+
+#if USE_NATIVE_INT128
+
+typedef int128 INT128;
+
+/*
+ * Add an unsigned int64 value into an INT128 variable.
+ */
+static inline void
+int128_add_uint64(INT128 *i128, uint64 v)
+{
+	*i128 += v;
+}
+
+/*
+ * Add a signed int64 value into an INT128 variable.
+ */
+static inline void
+int128_add_int64(INT128 *i128, int64 v)
+{
+	*i128 += v;
+}
+
+/*
+ * Add the 128-bit product of two int64 values into an INT128 variable.
+ *
+ * XXX with a stupid compiler, this could actually be less efficient than
+ * the other implementation; maybe we should do it by hand always?
+ */
+static inline void
+int128_add_int64_mul_int64(INT128 *i128, int64 x, int64 y)
+{
+	*i128 += (int128) x * (int128) y;
+}
+
+/*
+ * Compare two INT128 values, return -1, 0, or +1.
+ */
+static inline int
+int128_compare(INT128 x, INT128 y)
+{
+	if (x < y)
+		return -1;
+	if (x > y)
+		return 1;
+	return 0;
+}
+
+/*
+ * Widen int64 to INT128.
+ */
+static inline INT128
+int64_to_int128(int64 v)
+{
+	return (INT128) v;
+}
+
+/*
+ * Convert INT128 to int64 (losing any high-order bits).
+ * This also works fine for casting down to uint64.
+ */
+static inline int64
+int128_to_int64(INT128 val)
+{
+	return (int64) val;
+}
+
+#else							/* !USE_NATIVE_INT128 */
+
+/*
+ * We lay out the INT128 structure with the same content and byte ordering
+ * that a native int128 type would (probably) have.  This makes no difference
+ * for ordinary use of INT128, but allows union'ing INT128 with int128 for
+ * testing purposes.
+ */
+typedef struct
+{
+#ifdef WORDS_BIGENDIAN
+	int64		hi;				/* most significant 64 bits, including sign */
+	uint64		lo;				/* least significant 64 bits, without sign */
+#else
+	uint64		lo;				/* least significant 64 bits, without sign */
+	int64		hi;				/* most significant 64 bits, including sign */
+#endif
+} INT128;
+
+/*
+ * Add an unsigned int64 value into an INT128 variable.
+ */
+static inline void
+int128_add_uint64(INT128 *i128, uint64 v)
+{
+	/*
+	 * First add the value to the .lo part, then check to see if a carry needs
+	 * to be propagated into the .hi part.  A carry is needed if both inputs
+	 * have high bits set, or if just one input has high bit set while the new
+	 * .lo part doesn't.  Remember that .lo part is unsigned; we cast to
+	 * signed here just as a cheap way to check the high bit.
+	 */
+	uint64		oldlo = i128->lo;
+
+	i128->lo += v;
+	if (((int64) v < 0 && (int64) oldlo < 0) ||
+		(((int64) v < 0 || (int64) oldlo < 0) && (int64) i128->lo >= 0))
+		i128->hi++;
+}
+
+/*
+ * Add a signed int64 value into an INT128 variable.
+ */
+static inline void
+int128_add_int64(INT128 *i128, int64 v)
+{
+	/*
+	 * This is much like the above except that the carry logic differs for
+	 * negative v.  Ordinarily we'd need to subtract 1 from the .hi part
+	 * (corresponding to adding the sign-extended bits of v to it); but if
+	 * there is a carry out of the .lo part, that cancels and we do nothing.
+	 */
+	uint64		oldlo = i128->lo;
+
+	i128->lo += v;
+	if (v >= 0)
+	{
+		if ((int64) oldlo < 0 && (int64) i128->lo >= 0)
+			i128->hi++;
+	}
+	else
+	{
+		if (!((int64) oldlo < 0 || (int64) i128->lo >= 0))
+			i128->hi--;
+	}
+}
+
+/*
+ * INT64_AU32 extracts the most significant 32 bits of int64 as int64, while
+ * INT64_AL32 extracts the least significant 32 bits as uint64.
+ */
+#define INT64_AU32(i64) ((i64) >> 32)
+#define INT64_AL32(i64) ((i64) & UINT64CONST(0xFFFFFFFF))
+
+/*
+ * Add the 128-bit product of two int64 values into an INT128 variable.
+ */
+static inline void
+int128_add_int64_mul_int64(INT128 *i128, int64 x, int64 y)
+{
+	/* INT64_AU32 must use arithmetic right shift */
+	StaticAssertDecl(((int64) -1 >> 1) == (int64) -1,
+					 "arithmetic right shift is needed");
+
+	/*----------
+	 * Form the 128-bit product x * y using 64-bit arithmetic.
+	 * Considering each 64-bit input as having 32-bit high and low parts,
+	 * we can compute
+	 *
+	 *	 x * y = ((x.hi << 32) + x.lo) * (((y.hi << 32) + y.lo)
+	 *		   = (x.hi * y.hi) << 64 +
+	 *			 (x.hi * y.lo) << 32 +
+	 *			 (x.lo * y.hi) << 32 +
+	 *			 x.lo * y.lo
+	 *
+	 * Each individual product is of 32-bit terms so it won't overflow when
+	 * computed in 64-bit arithmetic.  Then we just have to shift it to the
+	 * correct position while adding into the 128-bit result.  We must also
+	 * keep in mind that the "lo" parts must be treated as unsigned.
+	 *----------
+	 */
+
+	/* No need to work hard if product must be zero */
+	if (x != 0 && y != 0)
+	{
+		int64		x_u32 = INT64_AU32(x);
+		uint64		x_l32 = INT64_AL32(x);
+		int64		y_u32 = INT64_AU32(y);
+		uint64		y_l32 = INT64_AL32(y);
+		int64		tmp;
+
+		/* the first term */
+		i128->hi += x_u32 * y_u32;
+
+		/* the second term: sign-extend it only if x is negative */
+		tmp = x_u32 * y_l32;
+		if (x < 0)
+			i128->hi += INT64_AU32(tmp);
+		else
+			i128->hi += ((uint64) tmp) >> 32;
+		int128_add_uint64(i128, ((uint64) INT64_AL32(tmp)) << 32);
+
+		/* the third term: sign-extend it only if y is negative */
+		tmp = x_l32 * y_u32;
+		if (y < 0)
+			i128->hi += INT64_AU32(tmp);
+		else
+			i128->hi += ((uint64) tmp) >> 32;
+		int128_add_uint64(i128, ((uint64) INT64_AL32(tmp)) << 32);
+
+		/* the fourth term: always unsigned */
+		int128_add_uint64(i128, x_l32 * y_l32);
+	}
+}
+
+/*
+ * Compare two INT128 values, return -1, 0, or +1.
+ */
+static inline int
+int128_compare(INT128 x, INT128 y)
+{
+	if (x.hi < y.hi)
+		return -1;
+	if (x.hi > y.hi)
+		return 1;
+	if (x.lo < y.lo)
+		return -1;
+	if (x.lo > y.lo)
+		return 1;
+	return 0;
+}
+
+/*
+ * Widen int64 to INT128.
+ */
+static inline INT128
+int64_to_int128(int64 v)
+{
+	INT128		val;
+
+	val.lo = (uint64) v;
+	val.hi = (v < 0) ? -INT64CONST(1) : INT64CONST(0);
+	return val;
+}
+
+/*
+ * Convert INT128 to int64 (losing any high-order bits).
+ * This also works fine for casting down to uint64.
+ */
+static inline int64
+int128_to_int64(INT128 val)
+{
+	return (int64) val.lo;
+}
+
+#endif							/* USE_NATIVE_INT128 */
+
+#endif							/* INT128_H */

embedded_postgres/pginstall/include/server/common/ip.h

@@ -0,0 +1,33 @@
+/*-------------------------------------------------------------------------
+ *
+ * ip.h
+ *	  Definitions for IPv6-aware network access.
+ *
+ * These definitions are used by both frontend and backend code.
+ *
+ * Copyright (c) 2003-2025, PostgreSQL Global Development Group
+ *
+ * src/include/common/ip.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef IP_H
+#define IP_H
+
+#include <netdb.h>
+#include <sys/socket.h>
+
+#include "libpq/pqcomm.h"
+
+
+extern int	pg_getaddrinfo_all(const char *hostname, const char *servname,
+							   const struct addrinfo *hintp,
+							   struct addrinfo **result);
+extern void pg_freeaddrinfo_all(int hint_ai_family, struct addrinfo *ai);
+
+extern int	pg_getnameinfo_all(const struct sockaddr_storage *addr, int salen,
+							   char *node, int nodelen,
+							   char *service, int servicelen,
+							   int flags);
+
+#endif							/* IP_H */

embedded_postgres/pginstall/include/server/common/jsonapi.h

@@ -0,0 +1,267 @@
+/*-------------------------------------------------------------------------
+ *
+ * jsonapi.h
+ *	  Declarations for JSON API support.
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/common/jsonapi.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef JSONAPI_H
+#define JSONAPI_H
+
+typedef enum JsonTokenType
+{
+	JSON_TOKEN_INVALID,
+	JSON_TOKEN_STRING,
+	JSON_TOKEN_NUMBER,
+	JSON_TOKEN_OBJECT_START,
+	JSON_TOKEN_OBJECT_END,
+	JSON_TOKEN_ARRAY_START,
+	JSON_TOKEN_ARRAY_END,
+	JSON_TOKEN_COMMA,
+	JSON_TOKEN_COLON,
+	JSON_TOKEN_TRUE,
+	JSON_TOKEN_FALSE,
+	JSON_TOKEN_NULL,
+	JSON_TOKEN_END,
+} JsonTokenType;
+
+typedef enum JsonParseErrorType
+{
+	JSON_SUCCESS,
+	JSON_INCOMPLETE,
+	JSON_INVALID_LEXER_TYPE,
+	JSON_NESTING_TOO_DEEP,
+	JSON_ESCAPING_INVALID,
+	JSON_ESCAPING_REQUIRED,
+	JSON_EXPECTED_ARRAY_FIRST,
+	JSON_EXPECTED_ARRAY_NEXT,
+	JSON_EXPECTED_COLON,
+	JSON_EXPECTED_END,
+	JSON_EXPECTED_JSON,
+	JSON_EXPECTED_MORE,
+	JSON_EXPECTED_OBJECT_FIRST,
+	JSON_EXPECTED_OBJECT_NEXT,
+	JSON_EXPECTED_STRING,
+	JSON_INVALID_TOKEN,
+	JSON_OUT_OF_MEMORY,
+	JSON_UNICODE_CODE_POINT_ZERO,
+	JSON_UNICODE_ESCAPE_FORMAT,
+	JSON_UNICODE_HIGH_ESCAPE,
+	JSON_UNICODE_UNTRANSLATABLE,
+	JSON_UNICODE_HIGH_SURROGATE,
+	JSON_UNICODE_LOW_SURROGATE,
+	JSON_SEM_ACTION_FAILED,		/* error should already be reported */
+} JsonParseErrorType;
+
+/* Parser state private to jsonapi.c */
+typedef struct JsonParserStack JsonParserStack;
+typedef struct JsonIncrementalState JsonIncrementalState;
+
+/*
+ * Don't depend on the internal type header for strval; if callers need access
+ * then they can include the appropriate header themselves.
+ */
+#ifdef JSONAPI_USE_PQEXPBUFFER
+#define jsonapi_StrValType PQExpBufferData
+#else
+#define jsonapi_StrValType StringInfoData
+#endif
+
+/*
+ * All the fields in this structure should be treated as read-only.
+ *
+ * If strval is not null, then it should contain the de-escaped value
+ * of the lexeme if it's a string. Otherwise most of these field names
+ * should be self-explanatory.
+ *
+ * line_number and line_start are principally for use by the parser's
+ * error reporting routines.
+ * token_terminator and prev_token_terminator point to the character
+ * AFTER the end of the token, i.e. where there would be a nul byte
+ * if we were using nul-terminated strings.
+ *
+ * The prev_token_terminator field should not be used when incremental is
+ * true, as the previous token might have started in a previous piece of input,
+ * and thus it can't be used in any pointer arithmetic or other operations in
+ * conjunction with token_start.
+ *
+ * JSONLEX_FREE_STRUCT/STRVAL are used to drive freeJsonLexContext.
+ * JSONLEX_CTX_OWNS_TOKENS is used by setJsonLexContextOwnsTokens.
+ */
+#define JSONLEX_FREE_STRUCT			(1 << 0)
+#define JSONLEX_FREE_STRVAL			(1 << 1)
+#define JSONLEX_CTX_OWNS_TOKENS		(1 << 2)
+typedef struct JsonLexContext
+{
+	const char *input;
+	size_t		input_length;
+	int			input_encoding;
+	const char *token_start;
+	const char *token_terminator;
+	const char *prev_token_terminator;
+	bool		incremental;
+	JsonTokenType token_type;
+	int			lex_level;
+	bits32		flags;
+	int			line_number;	/* line number, starting from 1 */
+	const char *line_start;		/* where that line starts within input */
+	JsonParserStack *pstack;
+	JsonIncrementalState *inc_state;
+	bool		need_escapes;
+	struct jsonapi_StrValType *strval;	/* only used if need_escapes == true */
+	struct jsonapi_StrValType *errormsg;
+} JsonLexContext;
+
+/*
+ * Function types for custom json parsing actions.
+ *
+ * fname will be NULL if the context has need_escapes=false, as will token for
+ * string type values.
+ */
+typedef JsonParseErrorType (*json_struct_action) (void *state);
+typedef JsonParseErrorType (*json_ofield_action) (void *state, char *fname, bool isnull);
+typedef JsonParseErrorType (*json_aelem_action) (void *state, bool isnull);
+typedef JsonParseErrorType (*json_scalar_action) (void *state, char *token, JsonTokenType tokentype);
+
+
+/*
+ * Semantic Action structure for use in parsing json.
+ *
+ * Any of these actions can be NULL, in which case nothing is done at that
+ * point, Likewise, semstate can be NULL. Using an all-NULL structure amounts
+ * to doing a pure parse with no side-effects, and is therefore exactly
+ * what the json input routines do.
+ *
+ * By default, the 'fname' and 'token' strings passed to these actions are
+ * palloc'd.  They are not free'd or used further by the parser, so the action
+ * function is free to do what it wishes with them. This behavior may be
+ * modified by setJsonLexContextOwnsTokens().
+ *
+ * All action functions return JsonParseErrorType.  If the result isn't
+ * JSON_SUCCESS, the parse is abandoned and that error code is returned.
+ * If it is JSON_SEM_ACTION_FAILED, the action function is responsible
+ * for having reported the error in some appropriate way.
+ */
+typedef struct JsonSemAction
+{
+	void	   *semstate;
+	json_struct_action object_start;
+	json_struct_action object_end;
+	json_struct_action array_start;
+	json_struct_action array_end;
+	json_ofield_action object_field_start;
+	json_ofield_action object_field_end;
+	json_aelem_action array_element_start;
+	json_aelem_action array_element_end;
+	json_scalar_action scalar;
+} JsonSemAction;
+
+/*
+ * pg_parse_json will parse the string in the lex calling the
+ * action functions in sem at the appropriate points. It is
+ * up to them to keep what state they need in semstate. If they
+ * need access to the state of the lexer, then its pointer
+ * should be passed to them as a member of whatever semstate
+ * points to. If the action pointers are NULL the parser
+ * does nothing and just continues.
+ */
+extern JsonParseErrorType pg_parse_json(JsonLexContext *lex,
+										const JsonSemAction *sem);
+
+extern JsonParseErrorType pg_parse_json_incremental(JsonLexContext *lex,
+													const JsonSemAction *sem,
+													const char *json,
+													size_t len,
+													bool is_last);
+
+/* the null action object used for pure validation */
+extern PGDLLIMPORT const JsonSemAction nullSemAction;
+
+/*
+ * json_count_array_elements performs a fast secondary parse to determine the
+ * number of elements in passed array lex context. It should be called from an
+ * array_start action.
+ *
+ * The return value indicates whether any error occurred, while the number
+ * of elements is stored into *elements (but only if the return value is
+ * JSON_SUCCESS).
+ */
+extern JsonParseErrorType json_count_array_elements(JsonLexContext *lex,
+													int *elements);
+
+/*
+ * initializer for JsonLexContext.
+ *
+ * If a valid 'lex' pointer is given, it is initialized.  This can be used
+ * for stack-allocated structs, saving overhead.  If NULL is given, a new
+ * struct is allocated.
+ *
+ * If need_escapes is true, ->strval stores the unescaped lexemes.
+ *
+ * Setting need_escapes to true is necessary if the operation needs
+ * to reference field names or scalar string values. This is true of most
+ * operations beyond purely checking the json-validity of the source
+ * document.
+ *
+ * Unescaping is expensive, so only request it when necessary.
+ *
+ * If need_escapes is true or lex was given as NULL, then the caller is
+ * responsible for freeing the returned struct, either by calling
+ * freeJsonLexContext() or (in backends) via memory context cleanup.
+ */
+extern JsonLexContext *makeJsonLexContextCstringLen(JsonLexContext *lex,
+													const char *json,
+													size_t len,
+													int encoding,
+													bool need_escapes);
+
+/*
+ * make a JsonLexContext suitable for incremental parsing.
+ * the string chunks will be handed to pg_parse_json_incremental,
+ * so there's no need for them here.
+ */
+extern JsonLexContext *makeJsonLexContextIncremental(JsonLexContext *lex,
+													 int encoding,
+													 bool need_escapes);
+
+/*
+ * Sets whether tokens passed to semantic action callbacks are owned by the
+ * context (in which case, the callback must duplicate the tokens for long-term
+ * storage) or by the callback (in which case, the callback must explicitly
+ * free tokens to avoid leaks).
+ *
+ * By default, this setting is false: the callback owns the tokens that are
+ * passed to it (and if parsing fails between the two object-field callbacks,
+ * the field name token will likely leak). If set to true, tokens will be freed
+ * by the lexer after the callback completes.
+ *
+ * Setting this to true is important for long-lived clients (such as libpq)
+ * that must not leak memory during a parse failure. For a server backend using
+ * memory contexts, or a client application which will exit on parse failure,
+ * this setting is less critical.
+ */
+extern void setJsonLexContextOwnsTokens(JsonLexContext *lex,
+										bool owned_by_context);
+
+extern void freeJsonLexContext(JsonLexContext *lex);
+
+/* lex one token */
+extern JsonParseErrorType json_lex(JsonLexContext *lex);
+
+/* construct an error detail string for a json error */
+extern char *json_errdetail(JsonParseErrorType error, JsonLexContext *lex);
+
+/*
+ * Utility function to check if a string is a valid JSON number.
+ *
+ * str argument does not need to be nul-terminated.
+ */
+extern bool IsValidJsonNumber(const char *str, size_t len);
+
+#endif							/* JSONAPI_H */

embedded_postgres/pginstall/include/server/common/keywords.h

@@ -0,0 +1,29 @@
+/*-------------------------------------------------------------------------
+ *
+ * keywords.h
+ *	  PostgreSQL's list of SQL keywords
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/common/keywords.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef KEYWORDS_H
+#define KEYWORDS_H
+
+#include "common/kwlookup.h"
+
+/* Keyword categories --- should match lists in gram.y */
+#define UNRESERVED_KEYWORD		0
+#define COL_NAME_KEYWORD		1
+#define TYPE_FUNC_NAME_KEYWORD	2
+#define RESERVED_KEYWORD		3
+
+extern PGDLLIMPORT const ScanKeywordList ScanKeywords;
+extern PGDLLIMPORT const uint8 ScanKeywordCategories[];
+extern PGDLLIMPORT const bool ScanKeywordBareLabel[];
+
+#endif							/* KEYWORDS_H */

embedded_postgres/pginstall/include/server/common/kwlookup.h

@@ -0,0 +1,44 @@
+/*-------------------------------------------------------------------------
+ *
+ * kwlookup.h
+ *	  Key word lookup for PostgreSQL
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/common/kwlookup.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef KWLOOKUP_H
+#define KWLOOKUP_H
+
+/* Hash function used by ScanKeywordLookup */
+typedef int (*ScanKeywordHashFunc) (const void *key, size_t keylen);
+
+/*
+ * This struct contains the data needed by ScanKeywordLookup to perform a
+ * search within a set of keywords.  The contents are typically generated by
+ * src/tools/gen_keywordlist.pl from a header containing PG_KEYWORD macros.
+ */
+typedef struct ScanKeywordList
+{
+	const char *kw_string;		/* all keywords in order, separated by \0 */
+	const uint16 *kw_offsets;	/* offsets to the start of each keyword */
+	ScanKeywordHashFunc hash;	/* perfect hash function for keywords */
+	int			num_keywords;	/* number of keywords */
+	int			max_kw_len;		/* length of longest keyword */
+} ScanKeywordList;
+
+
+extern int	ScanKeywordLookup(const char *str, const ScanKeywordList *keywords);
+
+/* Code that wants to retrieve the text of the N'th keyword should use this. */
+static inline const char *
+GetScanKeyword(int n, const ScanKeywordList *keywords)
+{
+	return keywords->kw_string + keywords->kw_offsets[n];
+}
+
+#endif							/* KWLOOKUP_H */

embedded_postgres/pginstall/include/server/common/link-canary.h

@@ -0,0 +1,17 @@
+/*-------------------------------------------------------------------------
+ *
+ * link-canary.h
+ *	  Detect whether src/common functions came from frontend or backend.
+ *
+ * Copyright (c) 2018-2025, PostgreSQL Global Development Group
+ *
+ * src/include/common/link-canary.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef LINK_CANARY_H
+#define LINK_CANARY_H
+
+extern bool pg_link_canary_is_frontend(void);
+
+#endif							/* LINK_CANARY_H */