pg_query 2.0.1 → 2.1.1

data/ext/pg_query/pg_query_normalize.c

@@ -1,5 +1,6 @@
 #include "pg_query.h"
 #include "pg_query_internal.h"
+#include "pg_query_fingerprint.h"
 
 #include "parser/parser.h"
 #include "parser/scanner.h"
@@ -14,6 +15,7 @@ typedef struct pgssLocationLen
 {
 	int			location;		/* start offset in query text */
 	int			length;			/* length in bytes, or -1 to ignore */
+	int			param_id;		/* Param id to use - if negative prefix, need to abs(..) and add highest_extern_param_id */
 } pgssLocationLen;
 
 /*
@@ -30,14 +32,32 @@ typedef struct pgssConstLocations
 	/* Current number of valid entries in clocations array */
 	int			clocations_count;
 
+	/* highest Param id we have assigned, not yet taking into account external param refs */
+	int			highest_normalize_param_id;
+
 	/* highest Param id we've seen, in order to start normalization correctly */
 	int			highest_extern_param_id;
 
 	/* query text */
 	const char * query;
 	int			query_len;
+
+	/* optional recording of assigned or discovered param refs, only active if param_refs is not NULL */
+	int *param_refs;
+	int param_refs_buf_size;
+	int param_refs_count;
 } pgssConstLocations;
 
+/*
+ * Intermediate working state struct to remember param refs for individual target list elements
+ */
+typedef struct FpAndParamRefs
+{
+	uint64_t fp;
+	int* param_refs;
+	int param_refs_count;
+} FpAndParamRefs;
+
 /*
  * comp_location: comparator for qsorting pgssLocationLen structs by location
  */
@@ -230,7 +250,8 @@ generate_normalized_query(pgssConstLocations *jstate, int query_loc, int* query_
 	for (i = 0; i < jstate->clocations_count; i++)
 	{
 		int			off,		/* Offset from start for cur tok */
-					tok_len;	/* Length (in bytes) of that tok */
+					tok_len,	/* Length (in bytes) of that tok */
+					param_id;	/* Param ID to be assigned */
 
 		off = jstate->clocations[i].location;
 		/* Adjust recorded location if we're dealing with partial string */
@@ -250,8 +271,10 @@ generate_normalized_query(pgssConstLocations *jstate, int query_loc, int* query_
 		n_quer_loc += len_to_wrt;
 
 		/* And insert a param symbol in place of the constant token */
-		n_quer_loc += sprintf(norm_query + n_quer_loc, "$%d",
-							  i + 1 + jstate->highest_extern_param_id);
+		param_id = (jstate->clocations[i].param_id < 0) ?
+					jstate->highest_extern_param_id + abs(jstate->clocations[i].param_id) :
+					jstate->clocations[i].param_id;
+		n_quer_loc += sprintf(norm_query + n_quer_loc, "$%d", param_id);
 
 		quer_loc = off + tok_len;
 		last_off = off;
@@ -292,6 +315,18 @@ static void RecordConstLocation(pgssConstLocations *jstate, int location)
 		jstate->clocations[jstate->clocations_count].location = location;
 		/* initialize lengths to -1 to simplify fill_in_constant_lengths */
 		jstate->clocations[jstate->clocations_count].length = -1;
+		/* by default we assume that we need a new param ref */
+		jstate->clocations[jstate->clocations_count].param_id = - jstate->highest_normalize_param_id;
+		jstate->highest_normalize_param_id++;
+		/* record param ref number if requested */
+		if (jstate->param_refs != NULL) {
+			jstate->param_refs[jstate->param_refs_count] = jstate->clocations[jstate->clocations_count].param_id;
+			jstate->param_refs_count++;
+			if (jstate->param_refs_count >= jstate->param_refs_buf_size) {
+				jstate->param_refs_buf_size *= 2;
+				jstate->param_refs = (int *) repalloc(jstate->param_refs, jstate->param_refs_buf_size * sizeof(int));
+			}
+		}
 		jstate->clocations_count++;
 	}
 }
@@ -303,69 +338,188 @@ static bool const_record_walker(Node *node, pgssConstLocations *jstate)
 
 	if (node == NULL) return false;
 
-	if (IsA(node, A_Const))
+	switch (nodeTag(node))
 	{
-		RecordConstLocation(jstate, castNode(A_Const, node)->location);
-	}
-	else if (IsA(node, ParamRef))
-	{
-		/* Track the highest ParamRef number */
-		if (((ParamRef *) node)->number > jstate->highest_extern_param_id)
-			jstate->highest_extern_param_id = castNode(ParamRef, node)->number;
-	}
-	else if (IsA(node, DefElem))
-	{
-		DefElem * defElem = (DefElem *) node;
-		if (defElem->arg != NULL && IsA(defElem->arg, String)) {
-			for (int i = defElem->location; i < jstate->query_len; i++) {
-				if (jstate->query[i] == '\'')
-					RecordConstLocation(jstate, i);
+		case T_A_Const:
+			RecordConstLocation(jstate, castNode(A_Const, node)->location);
+			break;
+		case T_ParamRef:
+			{
+				/* Track the highest ParamRef number */
+				if (((ParamRef *) node)->number > jstate->highest_extern_param_id)
+					jstate->highest_extern_param_id = castNode(ParamRef, node)->number;
+
+				if (jstate->param_refs != NULL) {
+					jstate->param_refs[jstate->param_refs_count] = ((ParamRef *) node)->number;
+					jstate->param_refs_count++;
+					if (jstate->param_refs_count >= jstate->param_refs_buf_size) {
+						jstate->param_refs_buf_size *= 2;
+						jstate->param_refs = (int *) repalloc(jstate->param_refs, jstate->param_refs_buf_size * sizeof(int));
+					}
+				}
 			}
-		}
-		return const_record_walker((Node *) ((DefElem *) node)->arg, jstate);
-	}
-	else if (IsA(node, RawStmt))
-	{
-		return const_record_walker((Node *) ((RawStmt *) node)->stmt, jstate);
-	}
-	else if (IsA(node, VariableSetStmt))
-	{
-		return const_record_walker((Node *) ((VariableSetStmt *) node)->args, jstate);
-	}
-	else if (IsA(node, CopyStmt))
-	{
-		return const_record_walker((Node *) ((CopyStmt *) node)->query, jstate);
-	}
-	else if (IsA(node, ExplainStmt))
-	{
-		return const_record_walker((Node *) ((ExplainStmt *) node)->query, jstate);
-	}
-	else if (IsA(node, CreateRoleStmt))
-	{
-		return const_record_walker((Node *) ((CreateRoleStmt *) node)->options, jstate);
-	}
-	else if (IsA(node, AlterRoleStmt))
-	{
-		return const_record_walker((Node *) ((AlterRoleStmt *) node)->options, jstate);
-	}
-	else if (IsA(node, DeclareCursorStmt))
-	{
-		return const_record_walker((Node *) ((DeclareCursorStmt *) node)->query, jstate);
-	}
+			break;
+		case T_DefElem:
+			{
+				DefElem * defElem = (DefElem *) node;
+				if (defElem->arg != NULL && IsA(defElem->arg, String)) {
+					for (int i = defElem->location; i < jstate->query_len; i++) {
+						if (jstate->query[i] == '\'') {
+							RecordConstLocation(jstate, i);
+							break;
+						}
+					}
+				}
+				return const_record_walker((Node *) ((DefElem *) node)->arg, jstate);
+			}
+			break;
+		case T_RawStmt:
+			return const_record_walker((Node *) ((RawStmt *) node)->stmt, jstate);
+		case T_VariableSetStmt:
+			return const_record_walker((Node *) ((VariableSetStmt *) node)->args, jstate);
+		case T_CopyStmt:
+			return const_record_walker((Node *) ((CopyStmt *) node)->query, jstate);
+		case T_ExplainStmt:
+			return const_record_walker((Node *) ((ExplainStmt *) node)->query, jstate);
+		case T_CreateRoleStmt:
+			return const_record_walker((Node *) ((CreateRoleStmt *) node)->options, jstate);
+		case T_AlterRoleStmt:
+			return const_record_walker((Node *) ((AlterRoleStmt *) node)->options, jstate);
+		case T_DeclareCursorStmt:
+			return const_record_walker((Node *) ((DeclareCursorStmt *) node)->query, jstate);
+		case T_TypeName:
+			/* Don't normalize constants in typmods or arrayBounds */
+			return false;
+		case T_SelectStmt:
+			{
+				SelectStmt *stmt = (SelectStmt *) node;
+				ListCell *lc;
+				List *fp_and_param_refs_list = NIL;
+
+				if (const_record_walker((Node *) stmt->distinctClause, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->intoClause, jstate))
+					return true;
+				foreach(lc, stmt->targetList)
+				{
+					ResTarget *res_target = lfirst_node(ResTarget, lc);
+					FpAndParamRefs *fp_and_param_refs = palloc0(sizeof(FpAndParamRefs));
+
+					/* Save all param refs we encounter or assign */
+					jstate->param_refs = palloc0(1 * sizeof(int));
+					jstate->param_refs_buf_size = 1;
+					jstate->param_refs_count = 0;
+
+					/* Walk the element */
+					if (const_record_walker((Node *) res_target, jstate))
+						return true;
+
+					/* Remember fingerprint and param refs for later */
+					fp_and_param_refs->fp = pg_query_fingerprint_node(res_target->val);
+					fp_and_param_refs->param_refs = jstate->param_refs;
+					fp_and_param_refs->param_refs_count = jstate->param_refs_count;
+					fp_and_param_refs_list = lappend(fp_and_param_refs_list, fp_and_param_refs);
+
+					/* Reset for next element, or stop recording if this is the last element */
+					jstate->param_refs = NULL;
+					jstate->param_refs_buf_size = 0;
+					jstate->param_refs_count = 0;
+				}
+				if (const_record_walker((Node *) stmt->fromClause, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->whereClause, jstate))
+					return true;
 
-	PG_TRY();
-	{
-		result = raw_expression_tree_walker(node, const_record_walker, (void*) jstate);
-	}
-	PG_CATCH();
-	{
-		MemoryContextSwitchTo(normalize_context);
-		result = false;
-		FlushErrorState();
+				/*
+				 * Instead of walking all of groupClause (like raw_expression_tree_walker does),
+				 * only walk certain items.
+				 */
+				foreach(lc, stmt->groupClause)
+				{
+					/*
+					 * Do not walk A_Const values that are simple integers, this avoids
+					 * turning "GROUP BY 1" into "GROUP BY $n", which obscures an important
+					 * semantic meaning. This matches how pg_stat_statements handles the
+					 * GROUP BY clause (i.e. it doesn't touch these constants)
+					 */
+					if (IsA(lfirst(lc), A_Const) && IsA(&castNode(A_Const, lfirst(lc))->val, Integer))
+						continue;
+
+					/*
+					 * Match up GROUP BY clauses against the target list, to assign the same
+					 * param refs as used in the target list - this ensures the query is valid,
+					 * instead of throwing a bogus "columns ... must appear in the GROUP BY
+					 * clause or be used in an aggregate function" error
+					 */
+					uint64_t fp = pg_query_fingerprint_node(lfirst(lc));
+					FpAndParamRefs *fppr = NULL;
+					ListCell *lc2;
+					foreach(lc2, fp_and_param_refs_list) {
+						if (fp == ((FpAndParamRefs *) lfirst(lc2))->fp) {
+							fppr = (FpAndParamRefs *) lfirst(lc2);
+							foreach_delete_current(fp_and_param_refs_list, lc2);
+							break;
+						}
+					}
+
+					int prev_cloc_count = jstate->clocations_count;
+					if (const_record_walker((Node *) lfirst(lc), jstate))
+						return true;
+
+					if (fppr != NULL && fppr->param_refs_count == jstate->clocations_count - prev_cloc_count) {
+						for (int i = prev_cloc_count; i < jstate->clocations_count; i++) {
+							jstate->clocations[i].param_id = fppr->param_refs[i - prev_cloc_count];
+						}
+						jstate->highest_normalize_param_id -= fppr->param_refs_count;
+					}
+				}
+				foreach(lc, stmt->sortClause)
+				{
+					/* Similarly, don't turn "ORDER BY 1" into "ORDER BY $n" */
+					if (IsA(lfirst(lc), SortBy) && IsA(castNode(SortBy, lfirst(lc))->node, A_Const) &&
+					    IsA(&castNode(A_Const, castNode(SortBy, lfirst(lc))->node)->val, Integer))
+						continue;
+
+					if (const_record_walker((Node *) lfirst(lc), jstate))
+						return true;
+				}
+				if (const_record_walker((Node *) stmt->havingClause, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->windowClause, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->valuesLists, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->limitOffset, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->limitCount, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->lockingClause, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->withClause, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->larg, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->rarg, jstate))
+					return true;
+
+				return false;
+			}
+		default:
+			{
+				PG_TRY();
+				{
+					return raw_expression_tree_walker(node, const_record_walker, (void*) jstate);
+				}
+				PG_CATCH();
+				{
+					MemoryContextSwitchTo(normalize_context);
+					FlushErrorState();
+				}
+				PG_END_TRY();
+			}
 	}
-	PG_END_TRY();
 
-	return result;
+	return false;
 }
 
 PgQueryNormalizeResult pg_query_normalize(const char* input)
@@ -391,9 +545,13 @@ PgQueryNormalizeResult pg_query_normalize(const char* input)
 		jstate.clocations = (pgssLocationLen *)
 			palloc(jstate.clocations_buf_size * sizeof(pgssLocationLen));
 		jstate.clocations_count = 0;
+		jstate.highest_normalize_param_id = 1;
 		jstate.highest_extern_param_id = 0;
 		jstate.query = input;
 		jstate.query_len = query_len;
+		jstate.param_refs = NULL;
+		jstate.param_refs_buf_size = 0;
+		jstate.param_refs_count = 0;
 
 		/* Walk tree and record const locations */
 		const_record_walker((Node *) tree, &jstate);
@@ -412,6 +570,8 @@ PgQueryNormalizeResult pg_query_normalize(const char* input)
 		error = malloc(sizeof(PgQueryError));
 		error->message   = strdup(error_data->message);
 		error->filename  = strdup(error_data->filename);
+		error->funcname  = strdup(error_data->funcname);
+		error->context   = NULL;
 		error->lineno    = error_data->lineno;
 		error->cursorpos = error_data->cursorpos;
 
@@ -430,6 +590,7 @@ void pg_query_free_normalize_result(PgQueryNormalizeResult result)
   if (result.error) {
     free(result.error->message);
     free(result.error->filename);
+    free(result.error->funcname);
     free(result.error);
   }
 

data/ext/pg_query/pg_query_parse_plpgsql.c

@@ -108,7 +108,7 @@ static PLpgSQL_function *compile_create_function_stmt(CreateFunctionStmt* stmt)
 		}
 	}
 
-	assert(proc_source);
+	assert(proc_source != NULL);
 
 	if (stmt->returnType != NULL) {
 		foreach(lc3, stmt->returnType->names)
@@ -179,6 +179,26 @@ static PLpgSQL_function *compile_create_function_stmt(CreateFunctionStmt* stmt)
 	plpgsql_DumpExecTree = false;
 	plpgsql_start_datums();
 
+	/* Setup parameter names */
+	foreach(lc, stmt->parameters)
+	{
+		FunctionParameter *param = lfirst_node(FunctionParameter, lc);
+		if (param->name != NULL)
+		{
+			char buf[32];
+			PLpgSQL_type *argdtype;
+			PLpgSQL_variable *argvariable;
+			PLpgSQL_nsitem_type argitemtype;
+			snprintf(buf, sizeof(buf), "$%d", foreach_current_index(lc) + 1);
+			argdtype = plpgsql_build_datatype(UNKNOWNOID, -1, InvalidOid, NULL);
+			argvariable = plpgsql_build_variable(param->name ? param->name : buf, 0, argdtype, false);
+			argitemtype = argvariable->dtype == PLPGSQL_DTYPE_VAR ? PLPGSQL_NSTYPE_VAR : PLPGSQL_NSTYPE_REC;
+			plpgsql_ns_additem(argitemtype, argvariable->dno, buf);
+			if (param->name != NULL)
+				plpgsql_ns_additem(argitemtype, argvariable->dno, param->name);
+		}
+	}
+
 	/* Set up as though in a function returning VOID */
 	function->fn_rettype = VOIDOID;
 	function->fn_retset = is_setof;

data/ext/pg_query/pg_query_ruby.sym

@@ -1 +1,2 @@
 _Init_pg_query
+Init_pg_query

data/ext/pg_query/protobuf-c.c

@@ -84,7 +84,9 @@
 # define PROTOBUF_C_UNPACK_ERROR(...)
 #endif
 
+#if !defined(_WIN32) || !defined(PROTOBUF_C_USE_SHARED_LIB)
 const char protobuf_c_empty_string[] = "";
+#endif
 
 /**
  * Internal `ProtobufCMessage` manipulation macro.
@@ -148,12 +150,14 @@ protobuf_c_version_number(void)
 static void *
 system_alloc(void *allocator_data, size_t size)
 {
+	(void)allocator_data;
 	return malloc(size);
 }
 
 static void
 system_free(void *allocator_data, void *data)
 {
+	(void)allocator_data;
 	free(data);
 }
 
@@ -1618,22 +1622,19 @@ required_field_pack_to_buffer(const ProtobufCFieldDescriptor *field,
 		break;
 	}
 	case PROTOBUF_C_TYPE_MESSAGE: {
-		uint8_t simple_buffer_scratch[256];
-		size_t sublen;
 		const ProtobufCMessage *msg = *(ProtobufCMessage * const *) member;
-		ProtobufCBufferSimple simple_buffer =
-			PROTOBUF_C_BUFFER_SIMPLE_INIT(simple_buffer_scratch);
-
+		
 		scratch[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
-		if (msg == NULL)
-			sublen = 0;
-		else
-			sublen = protobuf_c_message_pack_to_buffer(msg, &simple_buffer.base);
-		rv += uint32_pack(sublen, scratch + rv);
-		buffer->append(buffer, rv, scratch);
-		buffer->append(buffer, sublen, simple_buffer.data);
-		rv += sublen;
-		PROTOBUF_C_BUFFER_SIMPLE_CLEAR(&simple_buffer);
+		if (msg == NULL) {
+			rv += uint32_pack(0, scratch + rv);
+			buffer->append(buffer, rv, scratch);
+		} else {
+			size_t sublen = protobuf_c_message_get_packed_size(msg);
+			rv += uint32_pack(sublen, scratch + rv);
+			buffer->append(buffer, rv, scratch);
+			protobuf_c_message_pack_to_buffer(msg, buffer);
+			rv += sublen;
+		}
 		break;
 	}
 	default:
@@ -2063,7 +2064,7 @@ static size_t
 parse_tag_and_wiretype(size_t len,
 		       const uint8_t *data,
 		       uint32_t *tag_out,
-		       ProtobufCWireType *wiretype_out)
+		       uint8_t *wiretype_out)
 {
 	unsigned max_rv = len > 5 ? 5 : len;
 	uint32_t tag = (data[0] & 0x7f) >> 3;
@@ -2095,9 +2096,9 @@ parse_tag_and_wiretype(size_t len,
 
 /* sizeof(ScannedMember) must be <= (1UL<<BOUND_SIZEOF_SCANNED_MEMBER_LOG2) */
 #define BOUND_SIZEOF_SCANNED_MEMBER_LOG2 5
-typedef struct _ScannedMember ScannedMember;
+typedef struct ScannedMember ScannedMember;
 /** Field as it's being read. */
-struct _ScannedMember {
+struct ScannedMember {
 	uint32_t tag;              /**< Field tag. */
 	uint8_t wire_type;         /**< Field type. */
 	uint8_t length_prefix_len; /**< Prefix length. */
@@ -2132,11 +2133,13 @@ scan_length_prefixed_data(size_t len, const uint8_t *data,
 		// Protobuf messages should always be less than 2 GiB in size.
 		// We also want to return early here so that hdr_len + val does
 		// not overflow on 32-bit systems.
-		PROTOBUF_C_UNPACK_ERROR("length prefix of %lu is too large", val);
+		PROTOBUF_C_UNPACK_ERROR("length prefix of %lu is too large",
+			(unsigned long int)val);
 		return 0;
 	}
 	if (hdr_len + val > len) {
-		PROTOBUF_C_UNPACK_ERROR("data too short after length-prefix of %lu", val);
+		PROTOBUF_C_UNPACK_ERROR("data too short after length-prefix of %lu",
+			(unsigned long int)val);
 		return 0;
 	}
 	return hdr_len + val;
@@ -2498,7 +2501,7 @@ parse_required_member(ScannedMember *scanned_member,
 {
 	unsigned len = scanned_member->len;
 	const uint8_t *data = scanned_member->data;
-	ProtobufCWireType wire_type = scanned_member->wire_type;
+	uint8_t wire_type = scanned_member->wire_type;
 
 	switch (scanned_member->field->type) {
 	case PROTOBUF_C_TYPE_ENUM:
@@ -2579,7 +2582,7 @@ parse_required_member(ScannedMember *scanned_member,
 		{
 			do_free(allocator, bd->data);
 		}
-		if (len - pref_len > 0) {
+		if (len > pref_len) {
 			bd->data = do_alloc(allocator, len - pref_len);
 			if (bd->data == NULL)
 				return FALSE;
@@ -2747,7 +2750,9 @@ parse_packed_repeated_member(ScannedMember *scanned_member,
 	const uint8_t *at = scanned_member->data + scanned_member->length_prefix_len;
 	size_t rem = scanned_member->len - scanned_member->length_prefix_len;
 	size_t count = 0;
+#if defined(WORDS_BIGENDIAN)
 	unsigned i;
+#endif
 
 	switch (field->type) {
 	case PROTOBUF_C_TYPE_SFIXED32:
@@ -2840,13 +2845,15 @@ parse_packed_repeated_member(ScannedMember *scanned_member,
 		}
 		break;
 	case PROTOBUF_C_TYPE_BOOL:
-		count = rem;
-		for (i = 0; i < count; i++) {
-			if (at[i] > 1) {
+		while (rem > 0) {
+			unsigned s = scan_varint(rem, at);
+			if (s == 0) {
 				PROTOBUF_C_UNPACK_ERROR("bad packed-repeated boolean value");
 				return FALSE;
 			}
-			((protobuf_c_boolean *) array)[i] = at[i];
+			((protobuf_c_boolean *) array)[count++] = parse_boolean(s, at);
+			at += s;
+			rem -= s;
 		}
 		break;
 	default:
@@ -3080,7 +3087,7 @@ protobuf_c_message_unpack(const ProtobufCMessageDescriptor *desc,
 
 	while (rem > 0) {
 		uint32_t tag;
-		ProtobufCWireType wire_type;
+		uint8_t wire_type;
 		size_t used = parse_tag_and_wiretype(rem, at, &tag, &wire_type);
 		const ProtobufCFieldDescriptor *field;
 		ScannedMember tmp;
@@ -3657,4 +3664,4 @@ protobuf_c_service_descriptor_get_method_by_name(const ProtobufCServiceDescripto
 	if (strcmp(desc->methods[desc->method_indices_by_name[start]].name, name) == 0)
 		return desc->methods + desc->method_indices_by_name[start];
 	return NULL;
-}
+}

data/ext/pg_query/src_backend_utils_mmgr_mcxt.c

@@ -28,6 +28,7 @@
  * - CurrentMemoryContext
  * - MemoryContextDelete
  * - palloc0
+ * - MemoryContextAllocExtended
  *--------------------------------------------------------------------
  */
 
@@ -840,7 +841,42 @@ MemoryContextAllocZeroAligned(MemoryContext context, Size size)
  * MemoryContextAllocExtended
  *		Allocate space within the specified context using the given flags.
  */
+void *
+MemoryContextAllocExtended(MemoryContext context, Size size, int flags)
+{
+	void	   *ret;
+
+	AssertArg(MemoryContextIsValid(context));
+	AssertNotInCriticalSection(context);
+
+	if (((flags & MCXT_ALLOC_HUGE) != 0 && !AllocHugeSizeIsValid(size)) ||
+		((flags & MCXT_ALLOC_HUGE) == 0 && !AllocSizeIsValid(size)))
+		elog(ERROR, "invalid memory alloc request size %zu", size);
+
+	context->isReset = false;
+
+	ret = context->methods->alloc(context, size);
+	if (unlikely(ret == NULL))
+	{
+		if ((flags & MCXT_ALLOC_NO_OOM) == 0)
+		{
+			MemoryContextStats(TopMemoryContext);
+			ereport(ERROR,
+					(errcode(ERRCODE_OUT_OF_MEMORY),
+					 errmsg("out of memory"),
+					 errdetail("Failed on request of size %zu in memory context \"%s\".",
+							   size, context->name)));
+		}
+		return NULL;
+	}
 
+	VALGRIND_MEMPOOL_ALLOC(context, ret, size);
+
+	if ((flags & MCXT_ALLOC_ZERO) != 0)
+		MemSetAligned(ret, 0, size);
+
+	return ret;
+}
 
 void *
 palloc(Size size)