pg_query 2.2.0 → 6.1.0

data/ext/pg_query/pg_query_fingerprint.c

@@ -1,5 +1,3 @@
-// Ensure we have asprintf's definition on glibc-based platforms to avoid compiler warnings
-#define _GNU_SOURCE
 #include <stdio.h>
 
 #include "pg_query.h"
@@ -93,34 +91,48 @@ _fingerprintString(FingerprintContext *ctx, const char *str)
 }
 
 static void
-_fingerprintInteger(FingerprintContext *ctx, const Value *node)
+_fingerprintInteger(FingerprintContext *ctx, const union ValUnion *value)
 {
-	if (node->val.ival != 0) {
+	if (value->ival.ival != 0) {
 		_fingerprintString(ctx, "Integer");
 		_fingerprintString(ctx, "ival");
 		char buffer[50];
-		sprintf(buffer, "%d", node->val.ival);
+		sprintf(buffer, "%d", value->ival.ival);
 		_fingerprintString(ctx, buffer);
 	}
 }
 
 static void
-_fingerprintFloat(FingerprintContext *ctx, const Value *node)
+_fingerprintFloat(FingerprintContext *ctx, const union ValUnion *value)
 {
-	if (node->val.str != NULL) {
+	if (value->fval.fval != NULL) {
+		// NB: We output `str` here intentionally, to match the output format from libpg_query 14
+		// and below. This results in stable fingerprints, despite the field name being changed in
+		// PG15 to `fval`.
 		_fingerprintString(ctx, "Float");
 		_fingerprintString(ctx, "str");
-		_fingerprintString(ctx, node->val.str);
+		_fingerprintString(ctx, value->fval.fval);
 	}
 }
 
 static void
-_fingerprintBitString(FingerprintContext *ctx, const Value *node)
+_fingerprintBoolean(FingerprintContext *ctx, const union ValUnion *value)
 {
-	if (node->val.str != NULL) {
+	_fingerprintString(ctx, "Boolean");
+	_fingerprintString(ctx, "boolval");
+	_fingerprintString(ctx, value->boolval.boolval ? "true" : "false");
+}
+
+static void
+_fingerprintBitString(FingerprintContext *ctx, const union ValUnion *value)
+{
+	if (value->bsval.bsval != NULL) {
+		// NB: We output `str` here intentionally, to match the output format from libpg_query 14
+		// and below. This results in stable fingerprints, despite the field name being changed in
+		// PG15 to `bsval`.
 		_fingerprintString(ctx, "BitString");
 		_fingerprintString(ctx, "str");
-		_fingerprintString(ctx, node->val.str);
+		_fingerprintString(ctx, value->bsval.bsval);
 	}
 }
 
@@ -272,10 +284,16 @@ _fingerprintNode(FingerprintContext *ctx, const void *obj, const void *parent, c
 		case T_Float:
 			_fingerprintFloat(ctx, obj);
 			break;
+		case T_Boolean:
+			_fingerprintBoolean(ctx, obj);
+			break;
 		case T_String:
+			// NB: We output `str` here intentionally, to match the output format from libpg_query
+			// 14 and below. This results in stable fingerprints, despite the field name being
+			// changed in PG15 to `sval`.
 			_fingerprintString(ctx, "String");
 			_fingerprintString(ctx, "str");
-			_fingerprintString(ctx, ((Value*) obj)->val.str);
+			_fingerprintString(ctx, ((union ValUnion*) obj)->sval.sval);
 			break;
 		case T_BitString:
 			_fingerprintBitString(ctx, obj);
@@ -306,7 +324,7 @@ uint64_t pg_query_fingerprint_node(const void *node)
 	return result;
 }
 
-PgQueryFingerprintResult pg_query_fingerprint_with_opts(const char* input, bool printTokens)
+PgQueryFingerprintResult pg_query_fingerprint_with_opts(const char* input, int parser_options, bool printTokens)
 {
 	MemoryContext ctx = NULL;
 	PgQueryInternalParsetreeAndError parsetree_and_error;
@@ -314,7 +332,7 @@ PgQueryFingerprintResult pg_query_fingerprint_with_opts(const char* input, bool
 
 	ctx = pg_query_enter_memory_context();
 
-	parsetree_and_error = pg_query_raw_parse(input);
+	parsetree_and_error = pg_query_raw_parse(input, parser_options);
 
 	// These are all malloc-ed and will survive exiting the memory context, the caller is responsible to free them now
 	result.stderr_buffer = parsetree_and_error.stderr_buffer;
@@ -349,12 +367,13 @@ PgQueryFingerprintResult pg_query_fingerprint_with_opts(const char* input, bool
 		_fingerprintFreeContext(&ctx);
 
 		XXH64_canonicalFromHash(&chash, result.fingerprint);
-		int err = asprintf(&result.fingerprint_str, "%02x%02x%02x%02x%02x%02x%02x%02x",
+		result.fingerprint_str = malloc(17 * sizeof(char));
+		int n = snprintf(result.fingerprint_str, 17, "%02x%02x%02x%02x%02x%02x%02x%02x",
 						   chash.digest[0], chash.digest[1], chash.digest[2], chash.digest[3],
 						   chash.digest[4], chash.digest[5], chash.digest[6], chash.digest[7]);
-		if (err == -1) {
+		if (n < 0 || n >= 17) {
 			PgQueryError* error = malloc(sizeof(PgQueryError));
-			error->message = strdup("Failed to output fingerprint string due to asprintf failure");
+			error->message = strdup("Failed to output fingerprint string due to snprintf failure");
 			result.error = error;
 		}
 	}
@@ -366,7 +385,12 @@ PgQueryFingerprintResult pg_query_fingerprint_with_opts(const char* input, bool
 
 PgQueryFingerprintResult pg_query_fingerprint(const char* input)
 {
-	return pg_query_fingerprint_with_opts(input, false);
+	return pg_query_fingerprint_with_opts(input, PG_QUERY_PARSE_DEFAULT, false);
+}
+
+PgQueryFingerprintResult pg_query_fingerprint_opts(const char* input, int parser_options)
+{
+	return pg_query_fingerprint_with_opts(input, parser_options, false);
 }
 
 void pg_query_free_fingerprint_result(PgQueryFingerprintResult result)

data/ext/pg_query/pg_query_fingerprint.h

@@ -3,7 +3,7 @@
 
 #include <stdbool.h>
 
-extern PgQueryFingerprintResult pg_query_fingerprint_with_opts(const char* input, bool printTokens);
+extern PgQueryFingerprintResult pg_query_fingerprint_with_opts(const char* input, int parser_options, bool printTokens);
 
 extern uint64_t pg_query_fingerprint_node(const void * node);
 

data/ext/pg_query/pg_query_internal.h

@@ -14,7 +14,7 @@ typedef struct {
   PgQueryError* error;
 } PgQueryInternalParsetreeAndError;
 
-PgQueryInternalParsetreeAndError pg_query_raw_parse(const char* input);
+PgQueryInternalParsetreeAndError pg_query_raw_parse(const char* input, int parser_options);
 
 void pg_query_free_error(PgQueryError *error);
 

data/ext/pg_query/pg_query_json_plpgsql.c

@@ -96,7 +96,6 @@ static void dump_row(StringInfo out, PLpgSQL_row *stmt);
 static void dump_var(StringInfo out, PLpgSQL_var *stmt);
 static void dump_variable(StringInfo out, PLpgSQL_variable *stmt);
 static void dump_record_field(StringInfo out, PLpgSQL_recfield *node);
-static void dump_array_elem(StringInfo out, PLpgSQL_arrayelem *node);
 static void dump_stmt(StringInfo out, PLpgSQL_stmt *stmt);
 static void dump_block(StringInfo out, PLpgSQL_stmt_block *block);
 static void dump_exception_block(StringInfo out, PLpgSQL_exception_block *node);
@@ -130,7 +129,6 @@ static void dump_perform(StringInfo out, PLpgSQL_stmt_perform *stmt);
 static void dump_call(StringInfo out, PLpgSQL_stmt_call *stmt);
 static void dump_commit(StringInfo out, PLpgSQL_stmt_commit *stmt);
 static void dump_rollback(StringInfo out, PLpgSQL_stmt_rollback *stmt);
-static void dump_set(StringInfo out, PLpgSQL_stmt_set *stmt);
 static void dump_expr(StringInfo out, PLpgSQL_expr *expr);
 static void dump_function(StringInfo out, PLpgSQL_function *func);
 static void dump_exception(StringInfo out, PLpgSQL_exception *node);
@@ -224,9 +222,6 @@ dump_stmt(StringInfo out, PLpgSQL_stmt *node)
 		case PLPGSQL_STMT_ROLLBACK:
 			dump_rollback(out, (PLpgSQL_stmt_rollback *) node);
 			break;
-		case PLPGSQL_STMT_SET:
-			dump_set(out, (PLpgSQL_stmt_set *) node);
-			break;
 		default:
 			elog(ERROR, "unrecognized cmd_type: %d", node->cmd_type);
 			break;
@@ -493,15 +488,6 @@ dump_rollback(StringInfo out, PLpgSQL_stmt_rollback *node)
 	WRITE_BOOL_FIELD(chain, chain, chain);
 }
 
-static void
-dump_set(StringInfo out, PLpgSQL_stmt_set *node)
-{
-	WRITE_NODE_TYPE("PLpgSQL_stmt_set");
-
-	WRITE_INT_FIELD(lineno, lineno, lineno);
-	WRITE_EXPR_FIELD(expr);
-}
-
 static void
 dump_exit(StringInfo out, PLpgSQL_stmt_exit *node)
 {
@@ -640,6 +626,7 @@ dump_expr(StringInfo out, PLpgSQL_expr *node)
 	WRITE_NODE_TYPE("PLpgSQL_expr");
 
 	WRITE_STRING_FIELD(query, query, query);
+	WRITE_ENUM_FIELD(parseMode, parseMode, parseMode);
 }
 
 static void
@@ -673,9 +660,6 @@ dump_function(StringInfo out, PLpgSQL_function *node)
 			case PLPGSQL_DTYPE_RECFIELD:
 				dump_record_field(out, (PLpgSQL_recfield *) d);
 				break;
-			case PLPGSQL_DTYPE_ARRAYELEM:
-				dump_array_elem(out, (PLpgSQL_arrayelem *) d);
-				break;
 			default:
 				elog(WARNING, "could not dump unrecognized dtype: %d",
 					 (int) d->dtype);
@@ -780,14 +764,6 @@ dump_record_field(StringInfo out, PLpgSQL_recfield *node) {
 	WRITE_INT_FIELD(recparentno, recparentno, recparentno);
 }
 
-static void
-dump_array_elem(StringInfo out, PLpgSQL_arrayelem *node) {
-	WRITE_NODE_TYPE("PLpgSQL_arrayelem");
-
-	WRITE_EXPR_FIELD(subscript);
-	WRITE_INT_FIELD(arrayparentno, arrayparentno, arrayparentno);
-}
-
 char *
 plpgsqlToJSON(PLpgSQL_function *func)
 {

data/ext/pg_query/pg_query_normalize.c

@@ -48,6 +48,9 @@ typedef struct pgssConstLocations
 	int *param_refs;
 	int param_refs_buf_size;
 	int param_refs_count;
+
+	/* Should only utility statements be normalized? Set by pg_query_normalize_utility */
+	bool normalize_utility_only;
 } pgssConstLocations;
 
 /*
@@ -398,8 +401,10 @@ static bool const_record_walker(Node *node, pgssConstLocations *jstate)
 		case T_RawStmt:
 			return const_record_walker((Node *) ((RawStmt *) node)->stmt, jstate);
 		case T_VariableSetStmt:
+			if (jstate->normalize_utility_only) return false;
 			return const_record_walker((Node *) ((VariableSetStmt *) node)->args, jstate);
 		case T_CopyStmt:
+			if (jstate->normalize_utility_only) return false;
 			return const_record_walker((Node *) ((CopyStmt *) node)->query, jstate);
 		case T_ExplainStmt:
 			return const_record_walker((Node *) ((ExplainStmt *) node)->query, jstate);
@@ -408,16 +413,19 @@ static bool const_record_walker(Node *node, pgssConstLocations *jstate)
 		case T_AlterRoleStmt:
 			return const_record_walker((Node *) ((AlterRoleStmt *) node)->options, jstate);
 		case T_DeclareCursorStmt:
+			if (jstate->normalize_utility_only) return false;
 			return const_record_walker((Node *) ((DeclareCursorStmt *) node)->query, jstate);
 		case T_CreateFunctionStmt:
+			if (jstate->normalize_utility_only) return false;
 			return const_record_walker((Node *) ((CreateFunctionStmt *) node)->options, jstate);
 		case T_DoStmt:
+			if (jstate->normalize_utility_only) return false;
 			return const_record_walker((Node *) ((DoStmt *) node)->args, jstate);
 		case T_CreateSubscriptionStmt:
 			record_matching_string(jstate, ((CreateSubscriptionStmt *) node)->conninfo);
 			break;
 		case T_AlterSubscriptionStmt:
-			record_matching_string(jstate, ((CreateSubscriptionStmt *) node)->conninfo);
+			record_matching_string(jstate, ((AlterSubscriptionStmt *) node)->conninfo);
 			break;
 		case T_CreateUserMappingStmt:
 			return const_record_walker((Node *) ((CreateUserMappingStmt *) node)->options, jstate);
@@ -428,6 +436,7 @@ static bool const_record_walker(Node *node, pgssConstLocations *jstate)
 			return false;
 		case T_SelectStmt:
 			{
+				if (jstate->normalize_utility_only) return false;
 				SelectStmt *stmt = (SelectStmt *) node;
 				ListCell *lc;
 				List *fp_and_param_refs_list = NIL;
@@ -540,6 +549,26 @@ static bool const_record_walker(Node *node, pgssConstLocations *jstate)
 
 				return false;
 			}
+		case T_MergeStmt:
+			{
+				if (jstate->normalize_utility_only) return false;
+				return raw_expression_tree_walker(node, const_record_walker, (void*) jstate);
+			}
+		case T_InsertStmt:
+			{
+				if (jstate->normalize_utility_only) return false;
+				return raw_expression_tree_walker(node, const_record_walker, (void*) jstate);
+			}
+		case T_UpdateStmt:
+			{
+				if (jstate->normalize_utility_only) return false;
+				return raw_expression_tree_walker(node, const_record_walker, (void*) jstate);
+			}
+		case T_DeleteStmt:
+			{
+				if (jstate->normalize_utility_only) return false;
+				return raw_expression_tree_walker(node, const_record_walker, (void*) jstate);
+			}
 		default:
 			{
 				PG_TRY();
@@ -558,7 +587,7 @@ static bool const_record_walker(Node *node, pgssConstLocations *jstate)
 	return false;
 }
 
-PgQueryNormalizeResult pg_query_normalize(const char* input)
+PgQueryNormalizeResult pg_query_normalize_ext(const char* input, bool normalize_utility_only)
 {
 	MemoryContext ctx = NULL;
 	PgQueryNormalizeResult result = {0};
@@ -572,7 +601,7 @@ PgQueryNormalizeResult pg_query_normalize(const char* input)
 		int query_len;
 
 		/* Parse query */
-		tree = raw_parser(input);
+		tree = raw_parser(input, RAW_PARSE_DEFAULT);
 
 		query_len = (int) strlen(input);
 
@@ -588,6 +617,7 @@ PgQueryNormalizeResult pg_query_normalize(const char* input)
 		jstate.param_refs = NULL;
 		jstate.param_refs_buf_size = 0;
 		jstate.param_refs_count = 0;
+		jstate.normalize_utility_only = normalize_utility_only;
 
 		/* Walk tree and record const locations */
 		const_record_walker((Node *) tree, &jstate);
@@ -621,6 +651,17 @@ PgQueryNormalizeResult pg_query_normalize(const char* input)
 	return result;
 }
 
+PgQueryNormalizeResult pg_query_normalize(const char* input)
+{
+	return pg_query_normalize_ext(input, false);
+}
+
+
+PgQueryNormalizeResult pg_query_normalize_utility(const char* input)
+{
+	return pg_query_normalize_ext(input, true);
+}
+
 void pg_query_free_normalize_result(PgQueryNormalizeResult result)
 {
   if (result.error) {

data/ext/pg_query/pg_query_outfuncs_json.c

@@ -36,6 +36,12 @@
 		appendStringInfo(out, "\"" CppAsString(outname_json) "\":%u,", node->fldname); \
 	}
 
+/* Write an unsigned integer field */
+#define WRITE_UINT64_FIELD(outname, outname_json, fldname) \
+	if (node->fldname != 0) { \
+		appendStringInfo(out, "\"" CppAsString(outname_json) "\":" UINT64_FORMAT ",", node->fldname); \
+	}
+
 /* Write a long-integer field */
 #define WRITE_LONG_FIELD(outname, outname_json, fldname) \
 	if (node->fldname != 0) { \
@@ -195,39 +201,79 @@ _outOidList(StringInfo out, const List *node)
 }
 
 static void
-_outInteger(StringInfo out, const Value *node)
+_outInteger(StringInfo out, const Integer *node)
 {
-	appendStringInfo(out, "\"ival\":%d,", node->val.ival);
+	/* Don't output anything if the value is the default (0), to match
+	 * protobuf's behavior. */
+	if (node->ival != 0)
+		appendStringInfo(out, "\"ival\":%d", node->ival);
 }
 
 static void
-_outFloat(StringInfo out, const Value *node)
+_outBoolean(StringInfo out, const Boolean *node)
 {
-	appendStringInfo(out, "\"str\":");
-	_outToken(out, node->val.str);
-	appendStringInfo(out, ",");
+	appendStringInfo(out, "\"boolval\":%s", booltostr(node->boolval));
 }
 
 static void
-_outString(StringInfo out, const Value *node)
+_outFloat(StringInfo out, const Float *node)
 {
-	appendStringInfo(out, "\"str\":");
-	_outToken(out, node->val.str);
-	appendStringInfo(out, ",");
+	appendStringInfo(out, "\"fval\":");
+	_outToken(out, node->fval);
 }
 
 static void
-_outBitString(StringInfo out, const Value *node)
+_outString(StringInfo out, const String *node)
 {
-	appendStringInfo(out, "\"str\":");
-	_outToken(out, node->val.str);
-	appendStringInfo(out, ",");
+	appendStringInfo(out, "\"sval\":");
+	_outToken(out, node->sval);
 }
 
 static void
-_outNull(StringInfo out, const Value *node)
+_outBitString(StringInfo out, const BitString *node)
 {
-	// No fields
+	appendStringInfo(out, "\"bsval\":");
+	_outToken(out, node->bsval);
+}
+
+static void
+_outAConst(StringInfo out, const A_Const *node)
+{
+	if (node->isnull) {
+		appendStringInfo(out, "\"isnull\":true");
+	} else {
+		switch (node->val.node.type) {
+			case T_Integer:
+				appendStringInfoString(out, "\"ival\":{");
+				_outInteger(out, &node->val.ival);
+				appendStringInfoChar(out, '}');
+				break;
+			case T_Float:
+				appendStringInfoString(out, "\"fval\":{");
+				_outFloat(out, &node->val.fval);
+				appendStringInfoChar(out, '}');
+				break;
+			case T_Boolean:
+				appendStringInfo(out, "\"boolval\":{%s}", node->val.boolval.boolval ? "\"boolval\":true" : "");
+				break;
+			case T_String:
+				appendStringInfoString(out, "\"sval\":{");
+				_outString(out, &node->val.sval);
+				appendStringInfoChar(out, '}');
+				break;
+			case T_BitString:
+				appendStringInfoString(out, "\"bsval\":{");
+				_outBitString(out, &node->val.bsval);
+				appendStringInfoChar(out, '}');
+				break;
+
+			// Unreachable, A_Const cannot contain any other nodes.
+			default:
+				Assert(false);
+		}
+	}
+
+	appendStringInfo(out, ",\"location\":%d", node->location);
 }
 
 #include "pg_query_enum_defs.c"

data/ext/pg_query/pg_query_outfuncs_protobuf.c

@@ -23,6 +23,7 @@
 
 #define WRITE_INT_FIELD(outname, outname_json, fldname) out->outname = node->fldname;
 #define WRITE_UINT_FIELD(outname, outname_json, fldname) out->outname = node->fldname;
+#define WRITE_UINT64_FIELD(outname, outname_json, fldname) out->outname = node->fldname;
 #define WRITE_LONG_FIELD(outname, outname_json, fldname) out->outname = node->fldname;
 #define WRITE_FLOAT_FIELD(outname, outname_json, fldname) out->outname = node->fldname;
 #define WRITE_BOOL_FIELD(outname, outname_json, fldname) out->outname = node->fldname;
@@ -57,11 +58,11 @@
 #define WRITE_BITMAPSET_FIELD(outname, outname_json, fldname) \
 	if (!bms_is_empty(node->fldname)) \
 	{ \
-		int x = 0; \
+		int x = -1; \
 		int i = 0; \
 		out->n_##outname = bms_num_members(node->fldname); \
 		out->outname = palloc(sizeof(PgQuery__Node*) * out->n_##outname); \
-		while ((x = bms_first_member(node->fldname)) >= 0) \
+		while ((x = bms_next_member(node->fldname, x)) >= 0) \
 			out->outname[i++] = x; \
     }
 
@@ -150,33 +151,93 @@ _outOidList(PgQuery__OidList* out, const List *node)
 // TODO: Add Bitmapset
 
 static void
-_outInteger(PgQuery__Integer* out, const Value *node)
+_outInteger(PgQuery__Integer* out, const Integer *node)
 {
-  out->ival = node->val.ival;
+  out->ival = node->ival;
 }
 
 static void
-_outFloat(PgQuery__Float* out, const Value *node)
+_outFloat(PgQuery__Float* out, const Float *node)
 {
-  out->str = node->val.str;
+  out->fval = node->fval;
 }
 
 static void
-_outString(PgQuery__String* out, const Value *node)
+_outBoolean(PgQuery__Boolean* out, const Boolean *node)
 {
-  out->str = node->val.str;
+  out->boolval = node->boolval;
 }
 
 static void
-_outBitString(PgQuery__BitString* out, const Value *node)
+_outString(PgQuery__String* out, const String *node)
 {
-  out->str = node->val.str;
+  out->sval = node->sval;
 }
 
 static void
-_outNull(PgQuery__Null* out, const Value *node)
+_outBitString(PgQuery__BitString* out, const BitString *node)
 {
-  // Null has no fields
+  out->bsval = node->bsval;
+}
+
+static void
+_outAConst(PgQuery__AConst* out, const A_Const *node)
+{
+  out->isnull = node->isnull;
+  out->location = node->location;
+
+  if (!node->isnull) {
+    switch (nodeTag(&node->val.node)) {
+      case T_Integer: {
+        PgQuery__Integer *value = palloc(sizeof(PgQuery__Integer));
+        pg_query__integer__init(value);
+        value->ival = node->val.ival.ival;
+
+        out->val_case = PG_QUERY__A__CONST__VAL_IVAL;
+        out->ival = value;
+        break;
+      }
+      case T_Float: {
+        PgQuery__Float *value = palloc(sizeof(PgQuery__Float));
+        pg_query__float__init(value);
+        value->fval = pstrdup(node->val.fval.fval);
+
+        out->val_case = PG_QUERY__A__CONST__VAL_FVAL;
+        out->fval = value;
+        break;
+      }
+      case T_Boolean: {
+        PgQuery__Boolean *value = palloc(sizeof(PgQuery__Boolean));
+        pg_query__boolean__init(value);
+        value->boolval = node->val.boolval.boolval;
+
+        out->val_case = PG_QUERY__A__CONST__VAL_BOOLVAL;
+        out->boolval = value;
+        break;
+      }
+      case T_String: {
+        PgQuery__String *value = palloc(sizeof(PgQuery__String));
+	pg_query__string__init(value);
+	value->sval = pstrdup(node->val.sval.sval);
+
+	out->val_case = PG_QUERY__A__CONST__VAL_SVAL;
+	out->sval = value;
+	break;
+      }
+      case T_BitString: {
+        PgQuery__BitString *value = palloc(sizeof(PgQuery__BitString));
+	pg_query__bit_string__init(value);
+	value->bsval = pstrdup(node->val.bsval.bsval);
+
+	out->val_case = PG_QUERY__A__CONST__VAL_BSVAL;
+	out->bsval = value;
+	break;
+      }
+      default:
+        // Unreachable
+        Assert(false);
+    }
+  }
 }
 
 #include "pg_query_enum_defs.c"

data/ext/pg_query/pg_query_parse.c

@@ -9,7 +9,7 @@
 #include <unistd.h>
 #include <fcntl.h>
 
-PgQueryInternalParsetreeAndError pg_query_raw_parse(const char* input)
+PgQueryInternalParsetreeAndError pg_query_raw_parse(const char* input, int parser_options)
 {
 	PgQueryInternalParsetreeAndError result = {0};
 	MemoryContext parse_context = CurrentMemoryContext;
@@ -42,7 +42,39 @@ PgQueryInternalParsetreeAndError pg_query_raw_parse(const char* input)
 
 	PG_TRY();
 	{
-		result.tree = raw_parser(input);
+		RawParseMode rawParseMode = RAW_PARSE_DEFAULT;
+		switch (parser_options & PG_QUERY_PARSE_MODE_BITMASK)
+		{
+			case PG_QUERY_PARSE_TYPE_NAME:
+				rawParseMode = RAW_PARSE_TYPE_NAME;
+				break;
+			case PG_QUERY_PARSE_PLPGSQL_EXPR:
+				rawParseMode = RAW_PARSE_PLPGSQL_EXPR;
+				break;
+			case PG_QUERY_PARSE_PLPGSQL_ASSIGN1:
+				rawParseMode = RAW_PARSE_PLPGSQL_ASSIGN1;
+				break;
+			case PG_QUERY_PARSE_PLPGSQL_ASSIGN2:
+				rawParseMode = RAW_PARSE_PLPGSQL_ASSIGN2;
+				break;
+			case PG_QUERY_PARSE_PLPGSQL_ASSIGN3:
+				rawParseMode = RAW_PARSE_PLPGSQL_ASSIGN3;
+				break;
+		}
+
+		if ((parser_options & PG_QUERY_DISABLE_BACKSLASH_QUOTE) == PG_QUERY_DISABLE_BACKSLASH_QUOTE) {
+			backslash_quote = BACKSLASH_QUOTE_OFF;
+		} else {
+			backslash_quote = BACKSLASH_QUOTE_SAFE_ENCODING;
+		}
+		standard_conforming_strings = !((parser_options & PG_QUERY_DISABLE_STANDARD_CONFORMING_STRINGS) == PG_QUERY_DISABLE_STANDARD_CONFORMING_STRINGS);
+		escape_string_warning = !((parser_options & PG_QUERY_DISABLE_ESCAPE_STRING_WARNING) == PG_QUERY_DISABLE_ESCAPE_STRING_WARNING);
+
+		result.tree = raw_parser(input, rawParseMode);
+
+		backslash_quote = BACKSLASH_QUOTE_SAFE_ENCODING;
+		standard_conforming_strings = true;
+		escape_string_warning = true;
 
 #ifndef DEBUG
 		// Save stderr for result
@@ -84,6 +116,11 @@ PgQueryInternalParsetreeAndError pg_query_raw_parse(const char* input)
 }
 
 PgQueryParseResult pg_query_parse(const char* input)
+{
+	return pg_query_parse_opts(input, PG_QUERY_PARSE_DEFAULT);
+}
+
+PgQueryParseResult pg_query_parse_opts(const char* input, int parser_options)
 {
 	MemoryContext ctx = NULL;
 	PgQueryInternalParsetreeAndError parsetree_and_error;
@@ -92,7 +129,7 @@ PgQueryParseResult pg_query_parse(const char* input)
 
 	ctx = pg_query_enter_memory_context();
 
-	parsetree_and_error = pg_query_raw_parse(input);
+	parsetree_and_error = pg_query_raw_parse(input, parser_options);
 
 	// These are all malloc-ed and will survive exiting the memory context, the caller is responsible to free them now
 	result.stderr_buffer = parsetree_and_error.stderr_buffer;
@@ -108,14 +145,19 @@ PgQueryParseResult pg_query_parse(const char* input)
 }
 
 PgQueryProtobufParseResult pg_query_parse_protobuf(const char* input)
+{
+	return pg_query_parse_protobuf_opts(input, PG_QUERY_PARSE_DEFAULT);
+}
+
+PgQueryProtobufParseResult pg_query_parse_protobuf_opts(const char* input, int parser_options)
 {
 	MemoryContext ctx = NULL;
 	PgQueryInternalParsetreeAndError parsetree_and_error;
-	PgQueryProtobufParseResult result = {};
+	PgQueryProtobufParseResult result = {0};
 
 	ctx = pg_query_enter_memory_context();
 
-	parsetree_and_error = pg_query_raw_parse(input);
+	parsetree_and_error = pg_query_raw_parse(input, parser_options);
 
 	// These are all malloc-ed and will survive exiting the memory context, the caller is responsible to free them now
 	result.stderr_buffer = parsetree_and_error.stderr_buffer;