pg_query 2.0.3 → 5.1.0

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;

data/ext/pg_query/pg_query_parse_plpgsql.c

@@ -1,4 +1,3 @@
-#define _GNU_SOURCE // Necessary to get asprintf (which is a GNU extension)
 #include <stdio.h>
 
 #include "pg_query.h"
@@ -18,7 +17,7 @@ typedef struct {
 	PgQueryError* error;
 } PgQueryInternalPlpgsqlFuncAndError;
 
-static PgQueryInternalPlpgsqlFuncAndError pg_query_raw_parse_plpgsql(CreateFunctionStmt* stmt);
+static PgQueryInternalPlpgsqlFuncAndError pg_query_raw_parse_plpgsql(Node* stmt);
 
 static void add_dummy_return(PLpgSQL_function *function)
 {
@@ -73,6 +72,36 @@ static void plpgsql_compile_error_callback(void *arg)
 				   plpgsql_error_funcname, plpgsql_latest_lineno());
 }
 
+static PLpgSQL_function *compile_do_stmt(DoStmt* stmt)
+{
+	char *proc_source = NULL;
+	const ListCell *lc;
+	char *language = "plpgsql";
+
+	assert(IsA(stmt, DoStmt));
+
+	foreach(lc, stmt->args)
+	{
+		DefElem* elem = (DefElem*) lfirst(lc);
+
+		if (strcmp(elem->defname, "as") == 0) {
+
+			assert(IsA(elem->arg, String));
+			proc_source = strVal(elem->arg);
+		} else if (strcmp(elem->defname, "language") == 0) {
+			language = strVal(elem->arg);
+		}
+	}
+
+	assert(proc_source != NULL);
+
+	if(strcmp(language, "plpgsql") != 0) {
+		return (PLpgSQL_function *) palloc0(sizeof(PLpgSQL_function));
+	}
+	return plpgsql_compile_inline(proc_source);
+
+}
+
 static PLpgSQL_function *compile_create_function_stmt(CreateFunctionStmt* stmt)
 {
 	char *func_name;
@@ -87,6 +116,7 @@ static PLpgSQL_function *compile_create_function_stmt(CreateFunctionStmt* stmt)
 	const ListCell *lc, *lc2, *lc3;
 	bool is_trigger = false;
 	bool is_setof = false;
+	char *language = "plpgsql";
 
 	assert(IsA(stmt, CreateFunctionStmt));
 
@@ -105,10 +135,16 @@ static PLpgSQL_function *compile_create_function_stmt(CreateFunctionStmt* stmt)
 			{
 				proc_source = strVal(lfirst(lc2));
 			}
+		} else if (strcmp(elem->defname, "language") == 0) {
+			language = strVal(elem->arg);
 		}
 	}
 
-	assert(proc_source);
+	assert(proc_source != NULL);
+
+	if(strcmp(language, "plpgsql") != 0) { 
+		return (PLpgSQL_function *) palloc0(sizeof(PLpgSQL_function));
+	}
 
 	if (stmt->returnType != NULL) {
 		foreach(lc3, stmt->returnType->names)
@@ -179,6 +215,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;
@@ -253,7 +309,7 @@ static PLpgSQL_function *compile_create_function_stmt(CreateFunctionStmt* stmt)
 	return function;
 }
 
-PgQueryInternalPlpgsqlFuncAndError pg_query_raw_parse_plpgsql(CreateFunctionStmt* stmt)
+PgQueryInternalPlpgsqlFuncAndError pg_query_raw_parse_plpgsql(Node* stmt)
 {
 	PgQueryInternalPlpgsqlFuncAndError result = {0};
 	MemoryContext cctx = CurrentMemoryContext;
@@ -286,7 +342,13 @@ PgQueryInternalPlpgsqlFuncAndError pg_query_raw_parse_plpgsql(CreateFunctionStmt
 
 	PG_TRY();
 	{
-		result.func = compile_create_function_stmt(stmt);
+		if (IsA(stmt, CreateFunctionStmt)) {
+			result.func = compile_create_function_stmt((CreateFunctionStmt *) stmt);
+		} else if (IsA(stmt, DoStmt)){
+			result.func = compile_do_stmt((DoStmt *) stmt);
+		} else {
+			elog(ERROR, "Unexpected node type for PL/pgSQL parsing: %d", nodeTag(stmt));
+		}
 
 #ifndef DEBUG
 		// Save stderr for result
@@ -334,36 +396,36 @@ PgQueryInternalPlpgsqlFuncAndError pg_query_raw_parse_plpgsql(CreateFunctionStmt
 	return result;
 }
 
-typedef struct createFunctionStmts
+typedef struct plStmts
 {
-	CreateFunctionStmt **stmts;
+	Node **stmts;
 	int stmts_buf_size;
 	int stmts_count;
-} createFunctionStmts;
+} plStmts;
 
-static bool create_function_stmts_walker(Node *node, createFunctionStmts *state)
+static bool stmts_walker(Node *node, plStmts *state)
 {
 	bool result;
 	MemoryContext ccxt = CurrentMemoryContext;
 
 	if (node == NULL) return false;
 
-	if (IsA(node, CreateFunctionStmt))
+	if (IsA(node, CreateFunctionStmt) || IsA(node, DoStmt))
 	{
 		if (state->stmts_count >= state->stmts_buf_size)
 		{
 			state->stmts_buf_size *= 2;
-			state->stmts = (CreateFunctionStmt**) repalloc(state->stmts, state->stmts_buf_size * sizeof(CreateFunctionStmt*));
+			state->stmts = (Node**) repalloc(state->stmts, state->stmts_buf_size * sizeof(Node*));
 		}
-		state->stmts[state->stmts_count] = (CreateFunctionStmt *) node;
+		state->stmts[state->stmts_count] = (Node *) node;
 		state->stmts_count++;
 	} else if (IsA(node, RawStmt)) {
-		return create_function_stmts_walker((Node *) ((RawStmt *) node)->stmt, state);
+		return stmts_walker((Node *) ((RawStmt *) node)->stmt, state);
 	}
 
 	PG_TRY();
 	{
-		result = raw_expression_tree_walker(node, create_function_stmts_walker, (void*) state);
+		result = raw_expression_tree_walker(node, stmts_walker, (void*) state);
 	}
 	PG_CATCH();
 	{
@@ -381,12 +443,12 @@ PgQueryPlpgsqlParseResult pg_query_parse_plpgsql(const char* input)
 	MemoryContext ctx = NULL;
 	PgQueryPlpgsqlParseResult result = {0};
 	PgQueryInternalParsetreeAndError parse_result;
-	createFunctionStmts statements;
+	plStmts statements;
 	size_t i;
 
 	ctx = pg_query_enter_memory_context();
 
-	parse_result = pg_query_raw_parse(input);
+	parse_result = pg_query_raw_parse(input, PG_QUERY_PARSE_DEFAULT);
 	result.error = parse_result.error;
 	if (result.error != NULL) {
 		pg_query_exit_memory_context(ctx);
@@ -394,10 +456,10 @@ PgQueryPlpgsqlParseResult pg_query_parse_plpgsql(const char* input)
 	}
 
 	statements.stmts_buf_size = 100;
-	statements.stmts = (CreateFunctionStmt**) palloc(statements.stmts_buf_size * sizeof(CreateFunctionStmt*));
+	statements.stmts = (Node**) palloc(statements.stmts_buf_size * sizeof(Node*));
 	statements.stmts_count = 0;
 
-	create_function_stmts_walker((Node*) parse_result.tree, &statements);
+	stmts_walker((Node*) parse_result.tree, &statements);
 
 	if (statements.stmts_count == 0) {
 		result.plpgsql_funcs = strdup("[]");
@@ -423,14 +485,17 @@ PgQueryPlpgsqlParseResult pg_query_parse_plpgsql(const char* input)
 		if (func_and_error.func != NULL) {
 			char *func_json;
 			char *new_out;
+			size_t new_out_len;
 
 			func_json = plpgsqlToJSON(func_and_error.func);
 			plpgsql_free_function_memory(func_and_error.func);
 
-			int err = asprintf(&new_out, "%s%s,\n", result.plpgsql_funcs, func_json);
-			if (err == -1) {
+			new_out_len = strlen(result.plpgsql_funcs) + strlen(func_json) + 3;
+			new_out = malloc(new_out_len);
+			int n = snprintf(new_out, new_out_len, "%s%s,\n", result.plpgsql_funcs, func_json);
+			if (n < 0 || n >= new_out_len) {
 				PgQueryError* error = malloc(sizeof(PgQueryError));
-				error->message = strdup("Failed to output PL/pgSQL functions due to asprintf failure");
+				error->message = strdup("Failed to output PL/pgSQL functions due to snprintf failure");
 				result.error = error;
 			} else {
 				free(result.plpgsql_funcs);

data/ext/pg_query/pg_query_readfuncs_protobuf.c

@@ -14,6 +14,7 @@
 
 #define READ_INT_FIELD(outname, outname_json, fldname) node->fldname = msg->outname;
 #define READ_UINT_FIELD(outname, outname_json, fldname) node->fldname = msg->outname;
+#define READ_UINT64_FIELD(outname, outname_json, fldname) node->fldname = msg->outname;
 #define READ_LONG_FIELD(outname, outname_json, fldname) node->fldname = msg->outname;
 #define READ_FLOAT_FIELD(outname, outname_json, fldname) node->fldname = msg->outname;
 #define READ_BOOL_FIELD(outname, outname_json, fldname) node->fldname = msg->outname;
@@ -74,6 +75,12 @@
 
 static Node * _readNode(PgQuery__Node *msg);
 
+static String *
+_readString(PgQuery__String* msg)
+{
+	return makeString(pstrdup(msg->sval));
+}
+
 #include "pg_query_enum_defs.c"
 #include "pg_query_readfuncs_defs.c"
 
@@ -96,17 +103,45 @@ static Node * _readNode(PgQuery__Node *msg)
 		case PG_QUERY__NODE__NODE_INTEGER:
 			return (Node *) makeInteger(msg->integer->ival);
 		case PG_QUERY__NODE__NODE_FLOAT:
-			return (Node *) makeFloat(pstrdup(msg->float_->str));
+			return (Node *) makeFloat(pstrdup(msg->float_->fval));
+		case PG_QUERY__NODE__NODE_BOOLEAN:
+			return (Node *) makeBoolean(msg->boolean->boolval);
 		case PG_QUERY__NODE__NODE_STRING:
-			return (Node *) makeString(pstrdup(msg->string->str));
+			return (Node *) makeString(pstrdup(msg->string->sval));
 		case PG_QUERY__NODE__NODE_BIT_STRING:
-			return (Node *) makeBitString(pstrdup(msg->bit_string->str));
-		case PG_QUERY__NODE__NODE_NULL:
-			{
-				Value *v = makeNode(Value);
-				v->type = T_Null;
-				return (Node *) v;
+			return (Node *) makeBitString(pstrdup(msg->bit_string->bsval));
+		case PG_QUERY__NODE__NODE_A_CONST: {
+			A_Const *ac = makeNode(A_Const);
+			ac->location = msg->a_const->location;
+
+			if (msg->a_const->isnull) {
+				ac->isnull = true;
+			} else {
+				switch (msg->a_const->val_case) {
+					case PG_QUERY__A__CONST__VAL_IVAL:
+						ac->val.ival = *makeInteger(msg->a_const->ival->ival);
+						break;
+					case PG_QUERY__A__CONST__VAL_FVAL:
+						ac->val.fval = *makeFloat(pstrdup(msg->a_const->fval->fval));
+						break;
+					case PG_QUERY__A__CONST__VAL_BOOLVAL:
+						ac->val.boolval = *makeBoolean(msg->a_const->boolval->boolval);
+						break;
+					case PG_QUERY__A__CONST__VAL_SVAL:
+						ac->val.sval = *makeString(pstrdup(msg->a_const->sval->sval));
+						break;
+					case PG_QUERY__A__CONST__VAL_BSVAL:
+						ac->val.bsval = *makeBitString(pstrdup(msg->a_const->bsval->bsval));
+						break;
+					case PG_QUERY__A__CONST__VAL__NOT_SET:
+					case _PG_QUERY__A__CONST__VAL__CASE_IS_INT_SIZE:
+						Assert(false);
+						break;
+				}
 			}
+
+			return (Node *) ac;
+		}
 		case PG_QUERY__NODE__NODE_LIST:
 			return (Node *) _readList(msg->list);
 		case PG_QUERY__NODE__NODE__NOT_SET:

data/ext/pg_query/pg_query_ruby.c

@@ -14,7 +14,7 @@ VALUE pg_query_ruby_fingerprint(VALUE self, VALUE input);
 VALUE pg_query_ruby_scan(VALUE self, VALUE input);
 VALUE pg_query_ruby_hash_xxh3_64(VALUE self, VALUE input, VALUE seed);
 
-void Init_pg_query(void)
+__attribute__((visibility ("default"))) void Init_pg_query(void)
 {
 	VALUE cPgQuery;
 
@@ -221,5 +221,10 @@ VALUE pg_query_ruby_hash_xxh3_64(VALUE self, VALUE input, VALUE seed)
 	Check_Type(input, T_STRING);
 	Check_Type(seed, T_FIXNUM);
 
+#ifdef HAVE_LONG_LONG
+	return ULL2NUM(XXH3_64bits_withSeed(StringValuePtr(input), RSTRING_LEN(input), NUM2ULONG(seed)));
+#else
 	return ULONG2NUM(XXH3_64bits_withSeed(StringValuePtr(input), RSTRING_LEN(input), NUM2ULONG(seed)));
+#endif
+	
 }

data/ext/pg_query/pg_query_ruby_freebsd.sym

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

data/ext/pg_query/pg_query_scan.c

@@ -1,7 +1,7 @@
 #include "pg_query.h"
 #include "pg_query_internal.h"
 
-#include "parser/gramparse.h"
+#include "gramparse.h"
 #include "lib/stringinfo.h"
 
 #include "protobuf/pg_query.pb-c.h"
@@ -101,8 +101,9 @@ PgQueryScanResult pg_query_scan(const char* input)
       output_tokens[i]->token = tok;
 
       switch (tok) {
-      #define PG_KEYWORD(a,b,c) case b: output_tokens[i]->keyword_kind = c + 1; break;
+      #define PG_KEYWORD(a,b,c,d) case b: output_tokens[i]->keyword_kind = c + 1; break;
       #include "parser/kwlist.h"
+      #undef PG_KEYWORD
       default: output_tokens[i]->keyword_kind = 0;
       }
     }

data/ext/pg_query/pg_query_split.c

@@ -1,7 +1,7 @@
 #include "pg_query.h"
 #include "pg_query_internal.h"
 
-#include "parser/gramparse.h"
+#include "gramparse.h"
 #include "lib/stringinfo.h"
 
 #include <unistd.h>
@@ -59,8 +59,9 @@ PgQuerySplitResult pg_query_split_with_scanner(const char* input)
     {
       int tok = core_yylex(&yylval, &yylloc, yyscanner);
       switch (tok) {
-      #define PG_KEYWORD(a,b,c) case b: is_keyword = true; break;
+      #define PG_KEYWORD(a,b,c,d) case b: is_keyword = true; break;
       #include "parser/kwlist.h"
+      #undef PG_KEYWORD
       default: is_keyword = false;
       }
       if (is_keyword)
@@ -88,7 +89,7 @@ PgQuerySplitResult pg_query_split_with_scanner(const char* input)
     {
       int tok = core_yylex(&yylval, &yylloc, yyscanner);
       switch (tok) {
-      #define PG_KEYWORD(a,b,c) case b: is_keyword = true; break;
+      #define PG_KEYWORD(a,b,c,d) case b: is_keyword = true; break;
       #include "parser/kwlist.h"
       default: is_keyword = false;
       }
@@ -165,11 +166,11 @@ PgQuerySplitResult pg_query_split_with_parser(const char* input)
 {
 	MemoryContext ctx = NULL;
 	PgQueryInternalParsetreeAndError parsetree_and_error;
-	PgQuerySplitResult result = {};
+	PgQuerySplitResult result = {0};
 
 	ctx = pg_query_enter_memory_context();
 
-	parsetree_and_error = pg_query_raw_parse(input);
+	parsetree_and_error = pg_query_raw_parse(input, PG_QUERY_PARSE_DEFAULT);
 
 	// 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;