embedded-postgres 18.6.0__py3-none-win_amd64.whl

embedded_postgres/pginstall/include/server/utils/jsonpath.h

@@ -0,0 +1,310 @@
+/*-------------------------------------------------------------------------
+ *
+ * jsonpath.h
+ *	Definitions for jsonpath datatype
+ *
+ * Copyright (c) 2019-2025, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	src/include/utils/jsonpath.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef JSONPATH_H
+#define JSONPATH_H
+
+#include "executor/tablefunc.h"
+#include "fmgr.h"
+#include "nodes/pg_list.h"
+#include "nodes/primnodes.h"
+#include "utils/jsonb.h"
+
+typedef struct
+{
+	int32		vl_len_;		/* varlena header (do not touch directly!) */
+	uint32		header;			/* version and flags (see below) */
+	char		data[FLEXIBLE_ARRAY_MEMBER];
+} JsonPath;
+
+#define JSONPATH_VERSION	(0x01)
+#define JSONPATH_LAX		(0x80000000)
+#define JSONPATH_HDRSZ		(offsetof(JsonPath, data))
+
+static inline JsonPath *
+DatumGetJsonPathP(Datum d)
+{
+	return (JsonPath *) PG_DETOAST_DATUM(d);
+}
+
+static inline JsonPath *
+DatumGetJsonPathPCopy(Datum d)
+{
+	return (JsonPath *) PG_DETOAST_DATUM_COPY(d);
+}
+
+#define PG_GETARG_JSONPATH_P(x)			DatumGetJsonPathP(PG_GETARG_DATUM(x))
+#define PG_GETARG_JSONPATH_P_COPY(x)	DatumGetJsonPathPCopy(PG_GETARG_DATUM(x))
+#define PG_RETURN_JSONPATH_P(p)			PG_RETURN_POINTER(p)
+
+#define jspIsScalar(type) ((type) >= jpiNull && (type) <= jpiBool)
+
+/*
+ * All node's type of jsonpath expression
+ *
+ * These become part of the on-disk representation of the jsonpath type.
+ * Therefore, to preserve pg_upgradability, the order must not be changed, and
+ * new values must be added at the end.
+ *
+ * It is recommended that switch cases etc. in other parts of the code also
+ * use this order, to maintain some consistency.
+ */
+typedef enum JsonPathItemType
+{
+	jpiNull = jbvNull,			/* NULL literal */
+	jpiString = jbvString,		/* string literal */
+	jpiNumeric = jbvNumeric,	/* numeric literal */
+	jpiBool = jbvBool,			/* boolean literal: TRUE or FALSE */
+	jpiAnd,						/* predicate && predicate */
+	jpiOr,						/* predicate || predicate */
+	jpiNot,						/* ! predicate */
+	jpiIsUnknown,				/* (predicate) IS UNKNOWN */
+	jpiEqual,					/* expr == expr */
+	jpiNotEqual,				/* expr != expr */
+	jpiLess,					/* expr < expr */
+	jpiGreater,					/* expr > expr */
+	jpiLessOrEqual,				/* expr <= expr */
+	jpiGreaterOrEqual,			/* expr >= expr */
+	jpiAdd,						/* expr + expr */
+	jpiSub,						/* expr - expr */
+	jpiMul,						/* expr * expr */
+	jpiDiv,						/* expr / expr */
+	jpiMod,						/* expr % expr */
+	jpiPlus,					/* + expr */
+	jpiMinus,					/* - expr */
+	jpiAnyArray,				/* [*] */
+	jpiAnyKey,					/* .* */
+	jpiIndexArray,				/* [subscript, ...] */
+	jpiAny,						/* .** */
+	jpiKey,						/* .key */
+	jpiCurrent,					/* @ */
+	jpiRoot,					/* $ */
+	jpiVariable,				/* $variable */
+	jpiFilter,					/* ? (predicate) */
+	jpiExists,					/* EXISTS (expr) predicate */
+	jpiType,					/* .type() item method */
+	jpiSize,					/* .size() item method */
+	jpiAbs,						/* .abs() item method */
+	jpiFloor,					/* .floor() item method */
+	jpiCeiling,					/* .ceiling() item method */
+	jpiDouble,					/* .double() item method */
+	jpiDatetime,				/* .datetime() item method */
+	jpiKeyValue,				/* .keyvalue() item method */
+	jpiSubscript,				/* array subscript: 'expr' or 'expr TO expr' */
+	jpiLast,					/* LAST array subscript */
+	jpiStartsWith,				/* STARTS WITH predicate */
+	jpiLikeRegex,				/* LIKE_REGEX predicate */
+	jpiBigint,					/* .bigint() item method */
+	jpiBoolean,					/* .boolean() item method */
+	jpiDate,					/* .date() item method */
+	jpiDecimal,					/* .decimal() item method */
+	jpiInteger,					/* .integer() item method */
+	jpiNumber,					/* .number() item method */
+	jpiStringFunc,				/* .string() item method */
+	jpiTime,					/* .time() item method */
+	jpiTimeTz,					/* .time_tz() item method */
+	jpiTimestamp,				/* .timestamp() item method */
+	jpiTimestampTz,				/* .timestamp_tz() item method */
+} JsonPathItemType;
+
+/* XQuery regex mode flags for LIKE_REGEX predicate */
+#define JSP_REGEX_ICASE		0x01	/* i flag, case insensitive */
+#define JSP_REGEX_DOTALL	0x02	/* s flag, dot matches newline */
+#define JSP_REGEX_MLINE		0x04	/* m flag, ^/$ match at newlines */
+#define JSP_REGEX_WSPACE	0x08	/* x flag, ignore whitespace in pattern */
+#define JSP_REGEX_QUOTE		0x10	/* q flag, no special characters */
+
+/*
+ * Support functions to parse/construct binary value.
+ * Unlike many other representation of expression the first/main
+ * node is not an operation but left operand of expression. That
+ * allows to implement cheap follow-path descending in jsonb
+ * structure and then execute operator with right operand
+ */
+
+typedef struct JsonPathItem
+{
+	JsonPathItemType type;
+
+	/* position form base to next node */
+	int32		nextPos;
+
+	/*
+	 * pointer into JsonPath value to current node, all positions of current
+	 * are relative to this base
+	 */
+	char	   *base;
+
+	union
+	{
+		/* classic operator with two operands: and, or etc */
+		struct
+		{
+			int32		left;
+			int32		right;
+		}			args;
+
+		/* any unary operation */
+		int32		arg;
+
+		/* storage for jpiIndexArray: indexes of array */
+		struct
+		{
+			int32		nelems;
+			struct
+			{
+				int32		from;
+				int32		to;
+			}		   *elems;
+		}			array;
+
+		/* jpiAny: levels */
+		struct
+		{
+			uint32		first;
+			uint32		last;
+		}			anybounds;
+
+		struct
+		{
+			char	   *data;	/* for bool, numeric and string/key */
+			int32		datalen;	/* filled only for string/key */
+		}			value;
+
+		struct
+		{
+			int32		expr;
+			char	   *pattern;
+			int32		patternlen;
+			uint32		flags;
+		}			like_regex;
+	}			content;
+} JsonPathItem;
+
+#define jspHasNext(jsp) ((jsp)->nextPos > 0)
+
+extern void jspInit(JsonPathItem *v, JsonPath *js);
+extern void jspInitByBuffer(JsonPathItem *v, char *base, int32 pos);
+extern bool jspGetNext(JsonPathItem *v, JsonPathItem *a);
+extern void jspGetArg(JsonPathItem *v, JsonPathItem *a);
+extern void jspGetLeftArg(JsonPathItem *v, JsonPathItem *a);
+extern void jspGetRightArg(JsonPathItem *v, JsonPathItem *a);
+extern Numeric jspGetNumeric(JsonPathItem *v);
+extern bool jspGetBool(JsonPathItem *v);
+extern char *jspGetString(JsonPathItem *v, int32 *len);
+extern bool jspGetArraySubscript(JsonPathItem *v, JsonPathItem *from,
+								 JsonPathItem *to, int i);
+extern bool jspIsMutable(JsonPath *path, List *varnames, List *varexprs);
+
+extern const char *jspOperationName(JsonPathItemType type);
+
+/*
+ * Parsing support data structures.
+ */
+
+typedef struct JsonPathParseItem JsonPathParseItem;
+
+struct JsonPathParseItem
+{
+	JsonPathItemType type;
+	JsonPathParseItem *next;	/* next in path */
+
+	union
+	{
+
+		/* classic operator with two operands: and, or etc */
+		struct
+		{
+			JsonPathParseItem *left;
+			JsonPathParseItem *right;
+		}			args;
+
+		/* any unary operation */
+		JsonPathParseItem *arg;
+
+		/* storage for jpiIndexArray: indexes of array */
+		struct
+		{
+			int			nelems;
+			struct
+			{
+				JsonPathParseItem *from;
+				JsonPathParseItem *to;
+			}		   *elems;
+		}			array;
+
+		/* jpiAny: levels */
+		struct
+		{
+			uint32		first;
+			uint32		last;
+		}			anybounds;
+
+		struct
+		{
+			JsonPathParseItem *expr;
+			char	   *pattern;	/* could not be not null-terminated */
+			uint32		patternlen;
+			uint32		flags;
+		}			like_regex;
+
+		/* scalars */
+		Numeric numeric;
+		bool		boolean;
+		struct
+		{
+			uint32		len;
+			char	   *val;	/* could not be not null-terminated */
+		}			string;
+	}			value;
+};
+
+typedef struct JsonPathParseResult
+{
+	JsonPathParseItem *expr;
+	bool		lax;
+} JsonPathParseResult;
+
+extern JsonPathParseResult *parsejsonpath(const char *str, int len,
+										  struct Node *escontext);
+
+extern bool jspConvertRegexFlags(uint32 xflags, int *result,
+								 struct Node *escontext);
+
+/*
+ * Struct for details about external variables passed into jsonpath executor
+ */
+typedef struct JsonPathVariable
+{
+	char	   *name;
+	int			namelen;		/* strlen(name) as cache for GetJsonPathVar() */
+	Oid			typid;
+	int32		typmod;
+	Datum		value;
+	bool		isnull;
+} JsonPathVariable;
+
+
+/* SQL/JSON query functions */
+extern bool JsonPathExists(Datum jb, JsonPath *jp, bool *error, List *vars);
+extern Datum JsonPathQuery(Datum jb, JsonPath *jp, JsonWrapper wrapper,
+						   bool *empty, bool *error, List *vars,
+						   const char *column_name);
+extern JsonbValue *JsonPathValue(Datum jb, JsonPath *jp, bool *empty,
+								 bool *error, List *vars,
+								 const char *column_name);
+
+/* For JSON_TABLE() */
+extern PGDLLIMPORT const TableFuncRoutine JsonbTableRoutine;
+
+#endif

embedded_postgres/pginstall/include/server/utils/logtape.h

@@ -0,0 +1,77 @@
+/*-------------------------------------------------------------------------
+ *
+ * logtape.h
+ *	  Management of "logical tapes" within temporary files.
+ *
+ * See logtape.c for explanations.
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/utils/logtape.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef LOGTAPE_H
+#define LOGTAPE_H
+
+#include "storage/sharedfileset.h"
+
+/*
+ * LogicalTapeSet and LogicalTape are opaque types whose details are not
+ * known outside logtape.c.
+ */
+typedef struct LogicalTapeSet LogicalTapeSet;
+typedef struct LogicalTape LogicalTape;
+
+
+/*
+ * The approach tuplesort.c takes to parallel external sorts is that workers,
+ * whose state is almost the same as independent serial sorts, are made to
+ * produce a final materialized tape of sorted output in all cases.  This is
+ * frozen, just like any case requiring a final materialized tape.  However,
+ * there is one difference, which is that freezing will also export an
+ * underlying shared fileset BufFile for sharing.  Freezing produces TapeShare
+ * metadata for the worker when this happens, which is passed along through
+ * shared memory to leader.
+ *
+ * The leader process can then pass an array of TapeShare metadata (one per
+ * worker participant) to LogicalTapeSetCreate(), alongside a handle to a
+ * shared fileset, which is sufficient to construct a new logical tapeset that
+ * consists of each of the tapes materialized by workers.
+ *
+ * Note that while logtape.c does create an empty leader tape at the end of the
+ * tapeset in the leader case, it can never be written to due to a restriction
+ * in the shared buffile infrastructure.
+ */
+typedef struct TapeShare
+{
+	/*
+	 * Currently, all the leader process needs is the location of the
+	 * materialized tape's first block.
+	 */
+	int64		firstblocknumber;
+} TapeShare;
+
+/*
+ * prototypes for functions in logtape.c
+ */
+
+extern LogicalTapeSet *LogicalTapeSetCreate(bool preallocate,
+											SharedFileSet *fileset, int worker);
+extern void LogicalTapeClose(LogicalTape *lt);
+extern void LogicalTapeSetClose(LogicalTapeSet *lts);
+extern LogicalTape *LogicalTapeCreate(LogicalTapeSet *lts);
+extern LogicalTape *LogicalTapeImport(LogicalTapeSet *lts, int worker, TapeShare *shared);
+extern void LogicalTapeSetForgetFreeSpace(LogicalTapeSet *lts);
+extern size_t LogicalTapeRead(LogicalTape *lt, void *ptr, size_t size);
+extern void LogicalTapeWrite(LogicalTape *lt, const void *ptr, size_t size);
+extern void LogicalTapeRewindForRead(LogicalTape *lt, size_t buffer_size);
+extern void LogicalTapeFreeze(LogicalTape *lt, TapeShare *share);
+extern size_t LogicalTapeBackspace(LogicalTape *lt, size_t size);
+extern void LogicalTapeSeek(LogicalTape *lt, int64 blocknum, int offset);
+extern void LogicalTapeTell(LogicalTape *lt, int64 *blocknum, int *offset);
+extern int64 LogicalTapeSetBlocks(LogicalTapeSet *lts);
+
+#endif							/* LOGTAPE_H */

embedded_postgres/pginstall/include/server/utils/lsyscache.h

@@ -0,0 +1,224 @@
+/*-------------------------------------------------------------------------
+ *
+ * lsyscache.h
+ *	  Convenience routines for common queries in the system catalog cache.
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/utils/lsyscache.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef LSYSCACHE_H
+#define LSYSCACHE_H
+
+#include "access/attnum.h"
+#include "access/cmptype.h"
+#include "access/htup.h"
+#include "nodes/pg_list.h"
+
+/* avoid including subscripting.h here */
+struct SubscriptRoutines;
+
+/* Result list element for get_op_index_interpretation */
+typedef struct OpIndexInterpretation
+{
+	Oid			opfamily_id;	/* opfamily containing operator */
+	CompareType cmptype;		/* its generic comparison type */
+	Oid			oplefttype;		/* declared left input datatype */
+	Oid			oprighttype;	/* declared right input datatype */
+} OpIndexInterpretation;
+
+/* I/O function selector for get_type_io_data */
+typedef enum IOFuncSelector
+{
+	IOFunc_input,
+	IOFunc_output,
+	IOFunc_receive,
+	IOFunc_send,
+} IOFuncSelector;
+
+/* Flag bits for get_attstatsslot */
+#define ATTSTATSSLOT_VALUES		0x01
+#define ATTSTATSSLOT_NUMBERS	0x02
+
+/* Result struct for get_attstatsslot */
+typedef struct AttStatsSlot
+{
+	/* Always filled: */
+	Oid			staop;			/* Actual staop for the found slot */
+	Oid			stacoll;		/* Actual collation for the found slot */
+	/* Filled if ATTSTATSSLOT_VALUES is specified: */
+	Oid			valuetype;		/* Actual datatype of the values */
+	Datum	   *values;			/* slot's "values" array, or NULL if none */
+	int			nvalues;		/* length of values[], or 0 */
+	/* Filled if ATTSTATSSLOT_NUMBERS is specified: */
+	float4	   *numbers;		/* slot's "numbers" array, or NULL if none */
+	int			nnumbers;		/* length of numbers[], or 0 */
+
+	/* Remaining fields are private to get_attstatsslot/free_attstatsslot */
+	void	   *values_arr;		/* palloc'd values array, if any */
+	void	   *numbers_arr;	/* palloc'd numbers array, if any */
+} AttStatsSlot;
+
+/* Hook for plugins to get control in get_attavgwidth() */
+typedef int32 (*get_attavgwidth_hook_type) (Oid relid, AttrNumber attnum);
+extern PGDLLIMPORT get_attavgwidth_hook_type get_attavgwidth_hook;
+
+extern bool op_in_opfamily(Oid opno, Oid opfamily);
+extern int	get_op_opfamily_strategy(Oid opno, Oid opfamily);
+extern Oid	get_op_opfamily_sortfamily(Oid opno, Oid opfamily);
+extern void get_op_opfamily_properties(Oid opno, Oid opfamily, bool ordering_op,
+									   int *strategy,
+									   Oid *lefttype,
+									   Oid *righttype);
+extern Oid	get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype,
+								int16 strategy);
+extern Oid	get_opfamily_member_for_cmptype(Oid opfamily, Oid lefttype, Oid righttype,
+											CompareType cmptype);
+extern bool get_ordering_op_properties(Oid opno,
+									   Oid *opfamily, Oid *opcintype, CompareType *cmptype);
+extern Oid	get_equality_op_for_ordering_op(Oid opno, bool *reverse);
+extern Oid	get_ordering_op_for_equality_op(Oid opno, bool use_lhs_type);
+extern List *get_mergejoin_opfamilies(Oid opno);
+extern bool get_compatible_hash_operators(Oid opno,
+										  Oid *lhs_opno, Oid *rhs_opno);
+extern bool get_op_hash_functions(Oid opno,
+								  RegProcedure *lhs_procno, RegProcedure *rhs_procno);
+extern bool get_op_hash_functions_ext(Oid opno, Oid inputtype,
+									  RegProcedure *lhs_procno, RegProcedure *rhs_procno);
+extern List *get_op_index_interpretation(Oid opno);
+extern bool equality_ops_are_compatible(Oid opno1, Oid opno2);
+extern bool comparison_ops_are_compatible(Oid opno1, Oid opno2);
+extern bool collations_agree_on_equality(Oid coll1, Oid coll2);
+extern bool op_is_safe_index_member(Oid opno);
+extern Oid	get_opfamily_proc(Oid opfamily, Oid lefttype, Oid righttype,
+							  int16 procnum);
+extern char *get_attname(Oid relid, AttrNumber attnum, bool missing_ok);
+extern AttrNumber get_attnum(Oid relid, const char *attname);
+extern char get_attgenerated(Oid relid, AttrNumber attnum);
+extern Oid	get_atttype(Oid relid, AttrNumber attnum);
+extern void get_atttypetypmodcoll(Oid relid, AttrNumber attnum,
+								  Oid *typid, int32 *typmod, Oid *collid);
+extern Datum get_attoptions(Oid relid, int16 attnum);
+extern Oid	get_cast_oid(Oid sourcetypeid, Oid targettypeid, bool missing_ok);
+extern char *get_collation_name(Oid colloid);
+extern bool get_collation_isdeterministic(Oid colloid);
+extern char *get_constraint_name(Oid conoid);
+extern Oid	get_constraint_index(Oid conoid);
+extern char get_constraint_type(Oid conoid);
+
+extern char *get_language_name(Oid langoid, bool missing_ok);
+extern Oid	get_opclass_family(Oid opclass);
+extern Oid	get_opclass_input_type(Oid opclass);
+extern bool get_opclass_opfamily_and_input_type(Oid opclass,
+												Oid *opfamily, Oid *opcintype);
+extern Oid	get_opclass_method(Oid opclass);
+extern Oid	get_opfamily_method(Oid opfid);
+extern char *get_opfamily_name(Oid opfid, bool missing_ok);
+extern RegProcedure get_opcode(Oid opno);
+extern char *get_opname(Oid opno);
+extern Oid	get_op_rettype(Oid opno);
+extern void op_input_types(Oid opno, Oid *lefttype, Oid *righttype);
+extern bool op_mergejoinable(Oid opno, Oid inputtype);
+extern bool op_hashjoinable(Oid opno, Oid inputtype);
+extern bool op_strict(Oid opno);
+extern char op_volatile(Oid opno);
+extern Oid	get_commutator(Oid opno);
+extern Oid	get_negator(Oid opno);
+extern RegProcedure get_oprrest(Oid opno);
+extern RegProcedure get_oprjoin(Oid opno);
+extern char *get_func_name(Oid funcid);
+extern Oid	get_func_namespace(Oid funcid);
+extern Oid	get_func_rettype(Oid funcid);
+extern int	get_func_nargs(Oid funcid);
+extern Oid	get_func_signature(Oid funcid, Oid **argtypes, int *nargs);
+extern Oid	get_func_variadictype(Oid funcid);
+extern bool get_func_retset(Oid funcid);
+extern bool func_strict(Oid funcid);
+extern char func_volatile(Oid funcid);
+extern char func_parallel(Oid funcid);
+extern char get_func_prokind(Oid funcid);
+extern bool get_func_leakproof(Oid funcid);
+extern RegProcedure get_func_support(Oid funcid);
+extern Oid	get_relname_relid(const char *relname, Oid relnamespace);
+extern char *get_rel_name(Oid relid);
+extern Oid	get_rel_namespace(Oid relid);
+extern Oid	get_rel_type_id(Oid relid);
+extern char get_rel_relkind(Oid relid);
+extern bool get_rel_relispartition(Oid relid);
+extern Oid	get_rel_tablespace(Oid relid);
+extern char get_rel_persistence(Oid relid);
+extern Oid	get_rel_relam(Oid relid);
+extern Oid	get_transform_fromsql(Oid typid, Oid langid, List *trftypes);
+extern Oid	get_transform_tosql(Oid typid, Oid langid, List *trftypes);
+extern bool get_typisdefined(Oid typid);
+extern int16 get_typlen(Oid typid);
+extern bool get_typbyval(Oid typid);
+extern void get_typlenbyval(Oid typid, int16 *typlen, bool *typbyval);
+extern void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval,
+								 char *typalign);
+extern Oid	getTypeIOParam(HeapTuple typeTuple);
+extern void get_type_io_data(Oid typid,
+							 IOFuncSelector which_func,
+							 int16 *typlen,
+							 bool *typbyval,
+							 char *typalign,
+							 char *typdelim,
+							 Oid *typioparam,
+							 Oid *func);
+extern char get_typstorage(Oid typid);
+extern Node *get_typdefault(Oid typid);
+extern char get_typtype(Oid typid);
+extern bool type_is_rowtype(Oid typid);
+extern bool type_is_enum(Oid typid);
+extern bool type_is_range(Oid typid);
+extern bool type_is_multirange(Oid typid);
+extern void get_type_category_preferred(Oid typid,
+										char *typcategory,
+										bool *typispreferred);
+extern Oid	get_typ_typrelid(Oid typid);
+extern Oid	get_element_type(Oid typid);
+extern Oid	get_array_type(Oid typid);
+extern Oid	get_promoted_array_type(Oid typid);
+extern Oid	get_base_element_type(Oid typid);
+extern void getTypeInputInfo(Oid type, Oid *typInput, Oid *typIOParam);
+extern void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena);
+extern void getTypeBinaryInputInfo(Oid type, Oid *typReceive, Oid *typIOParam);
+extern void getTypeBinaryOutputInfo(Oid type, Oid *typSend, bool *typIsVarlena);
+extern Oid	get_typmodin(Oid typid);
+extern Oid	get_typcollation(Oid typid);
+extern bool type_is_collatable(Oid typid);
+extern RegProcedure get_typsubscript(Oid typid, Oid *typelemp);
+extern const struct SubscriptRoutines *getSubscriptingRoutines(Oid typid,
+															   Oid *typelemp);
+extern Oid	getBaseType(Oid typid);
+extern Oid	getBaseTypeAndTypmod(Oid typid, int32 *typmod);
+extern int32 get_typavgwidth(Oid typid, int32 typmod);
+extern int32 get_attavgwidth(Oid relid, AttrNumber attnum);
+extern bool get_attstatsslot(AttStatsSlot *sslot, HeapTuple statstuple,
+							 int reqkind, Oid reqop, int flags);
+extern void free_attstatsslot(AttStatsSlot *sslot);
+extern char *get_namespace_name(Oid nspid);
+extern char *get_namespace_name_or_temp(Oid nspid);
+extern Oid	get_range_subtype(Oid rangeOid);
+extern Oid	get_range_collation(Oid rangeOid);
+extern Oid	get_range_multirange(Oid rangeOid);
+extern Oid	get_multirange_range(Oid multirangeOid);
+extern Oid	get_index_column_opclass(Oid index_oid, int attno);
+extern bool get_index_isreplident(Oid index_oid);
+extern bool get_index_isvalid(Oid index_oid);
+extern bool get_index_isclustered(Oid index_oid);
+extern Oid	get_publication_oid(const char *pubname, bool missing_ok);
+extern char *get_publication_name(Oid pubid, bool missing_ok);
+extern Oid	get_subscription_oid(const char *subname, bool missing_ok);
+extern char *get_subscription_name(Oid subid, bool missing_ok);
+
+#define type_is_array(typid)  (get_element_type(typid) != InvalidOid)
+/* type_is_array_domain accepts both plain arrays and domains over arrays */
+#define type_is_array_domain(typid)  (get_base_element_type(typid) != InvalidOid)
+
+#define TypeIsToastable(typid)	(get_typstorage(typid) != TYPSTORAGE_PLAIN)
+
+#endif							/* LSYSCACHE_H */

embedded_postgres/pginstall/include/server/utils/memdebug.h

@@ -0,0 +1,82 @@
+/*-------------------------------------------------------------------------
+ *
+ * memdebug.h
+ *	  Memory debugging support.
+ *
+ * Currently, this file either wraps <valgrind/memcheck.h> or substitutes
+ * empty definitions for Valgrind client request macros we use.
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/utils/memdebug.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MEMDEBUG_H
+#define MEMDEBUG_H
+
+#ifdef USE_VALGRIND
+#include <valgrind/memcheck.h>
+#else
+#define VALGRIND_CHECK_MEM_IS_DEFINED(addr, size)			do {} while (0)
+#define VALGRIND_CREATE_MEMPOOL(context, redzones, zeroed)	do {} while (0)
+#define VALGRIND_DESTROY_MEMPOOL(context)					do {} while (0)
+#define VALGRIND_MAKE_MEM_DEFINED(addr, size)				do {} while (0)
+#define VALGRIND_MAKE_MEM_NOACCESS(addr, size)				do {} while (0)
+#define VALGRIND_MAKE_MEM_UNDEFINED(addr, size)				do {} while (0)
+#define VALGRIND_MEMPOOL_ALLOC(context, addr, size)			do {} while (0)
+#define VALGRIND_MEMPOOL_FREE(context, addr)				do {} while (0)
+#define VALGRIND_MEMPOOL_CHANGE(context, optr, nptr, size)	do {} while (0)
+#endif
+
+
+#ifdef CLOBBER_FREED_MEMORY
+
+/* Wipe freed memory for debugging purposes */
+static inline void
+wipe_mem(void *ptr, size_t size)
+{
+	VALGRIND_MAKE_MEM_UNDEFINED(ptr, size);
+	memset(ptr, 0x7F, size);
+	VALGRIND_MAKE_MEM_NOACCESS(ptr, size);
+}
+
+#endif							/* CLOBBER_FREED_MEMORY */
+
+#ifdef MEMORY_CONTEXT_CHECKING
+
+static inline void
+set_sentinel(void *base, Size offset)
+{
+	char	   *ptr = (char *) base + offset;
+
+	VALGRIND_MAKE_MEM_UNDEFINED(ptr, 1);
+	*ptr = 0x7E;
+	VALGRIND_MAKE_MEM_NOACCESS(ptr, 1);
+}
+
+static inline bool
+sentinel_ok(const void *base, Size offset)
+{
+	const char *ptr = (const char *) base + offset;
+	bool		ret;
+
+	VALGRIND_MAKE_MEM_DEFINED(ptr, 1);
+	ret = *ptr == 0x7E;
+	VALGRIND_MAKE_MEM_NOACCESS(ptr, 1);
+
+	return ret;
+}
+
+#endif							/* MEMORY_CONTEXT_CHECKING */
+
+#ifdef RANDOMIZE_ALLOCATED_MEMORY
+
+void		randomize_mem(char *ptr, size_t size);
+
+#endif							/* RANDOMIZE_ALLOCATED_MEMORY */
+
+
+#endif							/* MEMDEBUG_H */