pg_query 6.1.0 → 6.2.1

data/ext/pg_query/src_backend_utils_activity_pgstat_database.c

@@ -130,8 +130,8 @@ __thread SessionEndType pgStatSessionEndCause = DISCONNECT_NORMAL;
 /*
  * Flush out pending stats for the entry
  *
- * If nowait is true, this function returns false if lock could not
- * immediately acquired, otherwise true is returned.
+ * If nowait is true and the lock could not be immediately acquired, returns
+ * false without flushing the entry.  Otherwise returns true.
  */
 #define PGSTAT_ACCUM_DBCOUNT(item)		\
 	(sharedent)->stats.item += (pendingent)->item

data/ext/pg_query/src_backend_utils_error_elog.c

@@ -1939,6 +1939,17 @@ write_stderr(const char *fmt,...)
 }
 
 
+
+
+/*
+ * Write errors to stderr (or by equal means when stderr is
+ * not available) - va_list version
+ */
+#ifdef WIN32
+#endif
+#ifndef WIN32
+#else
+#endif
 #ifdef WIN32
 __thread volatile int pg_signal_queue;
 

data/ext/pg_query/src_backend_utils_mb_mbutils.c

@@ -17,6 +17,8 @@
  * - pg_mbstrlen_with_len
  * - pg_mblen
  * - SetDatabaseEncoding
+ * - pg_mbcharcliplen
+ * - pg_mbstrlen
  * - GetMessageEncoding
  * - MessageEncoding
  *--------------------------------------------------------------------
@@ -386,7 +388,22 @@ pg_mblen(const char *mbstr)
 
 
 /* returns the length (counted in wchars) of a multibyte string */
+int
+pg_mbstrlen(const char *mbstr)
+{
+	int			len = 0;
 
+	/* optimization for single byte encoding */
+	if (pg_database_encoding_max_length() == 1)
+		return strlen(mbstr);
+
+	while (*mbstr)
+	{
+		mbstr += pg_mblen(mbstr);
+		len++;
+	}
+	return len;
+}
 
 /* returns the length (counted in wchars) of a multibyte string
  * (not necessarily NULL terminated)
@@ -425,7 +442,7 @@ pg_mbcliplen(const char *mbstr, int len, int limit)
 }
 
 /*
- * pg_mbcliplen with specified encoding
+ * pg_mbcliplen with specified encoding; string must be valid in encoding
  */
 int
 pg_encoding_mbcliplen(int encoding, const char *mbstr,
@@ -459,7 +476,29 @@ pg_encoding_mbcliplen(int encoding, const char *mbstr,
  * Similar to pg_mbcliplen except the limit parameter specifies the
  * character length, not the byte length.
  */
+int
+pg_mbcharcliplen(const char *mbstr, int len, int limit)
+{
+	int			clen = 0;
+	int			nch = 0;
+	int			l;
 
+	/* optimization for single byte encoding */
+	if (pg_database_encoding_max_length() == 1)
+		return cliplen(mbstr, len, limit);
+
+	while (len > 0 && *mbstr)
+	{
+		l = pg_mblen(mbstr);
+		nch++;
+		if (nch > limit)
+			break;
+		clen += l;
+		len -= l;
+		mbstr += l;
+	}
+	return clen;
+}
 
 /* mbcliplen for any single-byte encoding */
 static int
@@ -726,12 +765,12 @@ pg_verify_mbstr(int encoding, const char *mbstr, int len, bool noError)
  * report_invalid_encoding: complain about invalid multibyte character
  *
  * note: len is remaining length of string, not length of character;
- * len must be greater than zero, as we always examine the first byte.
+ * len must be greater than zero (or we'd neglect initializing "buf").
  */
 void
 report_invalid_encoding(int encoding, const char *mbstr, int len)
 {
-	int			l = pg_encoding_mblen(encoding, mbstr);
+	int			l = pg_encoding_mblen_or_incomplete(encoding, mbstr, len);
 	char		buf[8 * 5 + 1];
 	char	   *p = buf;
 	int			j,
@@ -758,7 +797,7 @@ report_invalid_encoding(int encoding, const char *mbstr, int len)
  * report_untranslatable_char: complain about untranslatable character
  *
  * note: len is remaining length of string, not length of character;
- * len must be greater than zero, as we always examine the first byte.
+ * len must be greater than zero (or we'd neglect initializing "buf").
  */
 
 

data/ext/pg_query/src_backend_utils_mmgr_alignedalloc.c

@@ -54,6 +54,7 @@ AlignedAllocFree(void *pointer)
 			 GetMemoryChunkContext(unaligned)->name, chunk);
 #endif
 
+	/* Recursively pfree the unaligned chunk */
 	pfree(unaligned);
 }
 
@@ -105,18 +106,32 @@ AlignedAllocRealloc(void *pointer, Size size, int flags)
 	Assert(old_size >= redirchunk->requested_size);
 #endif
 
+	/*
+	 * To keep things simple, we always allocate a new aligned chunk and copy
+	 * data into it.  Because of the above inaccuracy, this may end in copying
+	 * more data than was in the original allocation request size, but that
+	 * should be OK.
+	 */
 	ctx = GetMemoryChunkContext(unaligned);
 	newptr = MemoryContextAllocAligned(ctx, size, alignto, flags);
 
-	/*
-	 * We may memcpy beyond the end of the original allocation request size,
-	 * so we must mark the entire allocation as defined.
-	 */
-	if (likely(newptr != NULL))
+	/* Cope cleanly with OOM */
+	if (unlikely(newptr == NULL))
 	{
-		VALGRIND_MAKE_MEM_DEFINED(pointer, old_size);
-		memcpy(newptr, pointer, Min(size, old_size));
+		VALGRIND_MAKE_MEM_NOACCESS(redirchunk, sizeof(MemoryChunk));
+		return MemoryContextAllocationFailure(ctx, size, flags);
 	}
+
+	/*
+	 * We may memcpy more than the original allocation request size, which
+	 * would result in trying to copy trailing bytes that the original
+	 * MemoryContextAllocAligned call marked NOACCESS.  So we must mark the
+	 * entire old_size as defined.  That's slightly annoying, but probably not
+	 * worth improving.
+	 */
+	VALGRIND_MAKE_MEM_DEFINED(pointer, old_size);
+	memcpy(newptr, pointer, Min(size, old_size));
+
 	pfree(unaligned);
 
 	return newptr;

data/ext/pg_query/src_backend_utils_mmgr_aset.c

@@ -1632,9 +1632,9 @@ AllocSetCheck(MemoryContext context)
 		 prevblock = block, block = block->next)
 	{
 		char	   *bpoz = ((char *) block) + ALLOC_BLOCKHDRSZ;
-		long		blk_used = block->freeptr - bpoz;
-		long		blk_data = 0;
-		long		nchunks = 0;
+		Size		blk_used = block->freeptr - bpoz;
+		Size		blk_data = 0;
+		Size		nchunks = 0;
 		bool		has_external_chunk = false;
 
 		if (IsKeeperBlock(set, block))

data/ext/pg_query/src_backend_utils_mmgr_bump.c

@@ -236,7 +236,7 @@ BumpAllocLarge(MemoryContext context, Size size, int flags)
 
 	block = (BumpBlock *) malloc(blksize);
 	if (block == NULL)
-		return NULL;
+		return MemoryContextAllocationFailure(context, size, flags);
 
 	context->mem_allocated += blksize;
 

data/ext/pg_query/src_common_stringinfo.c

@@ -9,6 +9,8 @@
  * - enlargeStringInfo
  * - appendStringInfo
  * - appendStringInfoSpaces
+ * - makeStringInfo
+ * - destroyStringInfo
  *--------------------------------------------------------------------
  */
 
@@ -51,7 +53,17 @@
  *
  * Create an empty 'StringInfoData' & return a pointer to it.
  */
+StringInfo
+makeStringInfo(void)
+{
+	StringInfo	res;
+
+	res = (StringInfo) palloc(sizeof(StringInfoData));
 
+	initStringInfo(res);
+
+	return res;
+}
 
 /*
  * initStringInfo
@@ -350,4 +362,12 @@ enlargeStringInfo(StringInfo str, int needed)
  * Frees a StringInfo and its buffer (opposite of makeStringInfo()).
  * This must only be called on palloc'd StringInfos.
  */
+void
+destroyStringInfo(StringInfo str)
+{
+	/* don't allow destroys of read-only StringInfos */
+	Assert(str->maxlen != 0);
 
+	pfree(str->data);
+	pfree(str);
+}

data/ext/pg_query/src_common_wchar.c

@@ -76,6 +76,7 @@
  * - pg_johab_dsplen
  * - pg_johab_verifychar
  * - pg_johab_verifystr
+ * - pg_encoding_mblen_or_incomplete
  * - pg_encoding_mblen
  *--------------------------------------------------------------------
  */
@@ -94,6 +95,8 @@
  */
 #include "c.h"
 
+#include <limits.h>
+
 #include "mb/pg_wchar.h"
 #include "utils/ascii.h"
 
@@ -2182,10 +2185,27 @@ const pg_wchar_tbl pg_wchar_table[] = {
 /*
  * Returns the byte length of a multibyte character.
  *
- * Caution: when dealing with text that is not certainly valid in the
- * specified encoding, the result may exceed the actual remaining
- * string length.  Callers that are not prepared to deal with that
- * should use pg_encoding_mblen_bounded() instead.
+ * Choose "mblen" functions based on the input string characteristics.
+ * pg_encoding_mblen() can be used when ANY of these conditions are met:
+ *
+ * - The input string is zero-terminated
+ *
+ * - The input string is known to be valid in the encoding (e.g., string
+ *   converted from database encoding)
+ *
+ * - The encoding is not GB18030 (e.g., when only database encodings are
+ *   passed to 'encoding' parameter)
+ *
+ * encoding==GB18030 requires examining up to two bytes to determine character
+ * length.  Therefore, callers satisfying none of those conditions must use
+ * pg_encoding_mblen_or_incomplete() instead, as access to mbstr[1] cannot be
+ * guaranteed to be within allocation bounds.
+ *
+ * When dealing with text that is not certainly valid in the specified
+ * encoding, the result may exceed the actual remaining string length.
+ * Callers that are not prepared to deal with that should use Min(remaining,
+ * pg_encoding_mblen_or_incomplete()).  For zero-terminated strings, that and
+ * pg_encoding_mblen_bounded() are interchangeable.
  */
 int
 pg_encoding_mblen(int encoding, const char *mbstr)
@@ -2196,8 +2216,28 @@ pg_encoding_mblen(int encoding, const char *mbstr)
 }
 
 /*
- * Returns the byte length of a multibyte character; but not more than
- * the distance to end of string.
+ * Returns the byte length of a multibyte character (possibly not
+ * zero-terminated), or INT_MAX if too few bytes remain to determine a length.
+ */
+int
+pg_encoding_mblen_or_incomplete(int encoding, const char *mbstr,
+								size_t remaining)
+{
+	/*
+	 * Define zero remaining as too few, even for single-byte encodings.
+	 * pg_gb18030_mblen() reads one or two bytes; single-byte encodings read
+	 * zero; others read one.
+	 */
+	if (remaining < 1 ||
+		(encoding == PG_GB18030 && IS_HIGHBIT_SET(*mbstr) && remaining < 2))
+		return INT_MAX;
+	return pg_encoding_mblen(encoding, mbstr);
+}
+
+/*
+ * Returns the byte length of a multibyte character; but not more than the
+ * distance to the terminating zero byte.  For input that might lack a
+ * terminating zero, use Min(remaining, pg_encoding_mblen_or_incomplete()).
  */
 
 

data/lib/pg_query/deparse.rb

@@ -1,18 +1,39 @@
 module PgQuery
   class ParserResult
-    def deparse
-      PgQuery.deparse(@tree)
+    def deparse(opts: nil)
+      PgQuery.deparse(@tree, opts: opts)
     end
   end
 
+  class DeparseComment
+    attr_accessor :match_location, :newlines_before_comment, :newlines_after_comment, :str
+  end
+
+  DeparseOpts = Struct.new(:pretty_print, :comments, :indent_size, :max_line_length,
+                           :trailing_newline, :commas_start_of_line, keyword_init: true)
+
   # Reconstruct all of the parsed queries into their original form
-  def self.deparse(tree)
-    if PgQuery::ParseResult.method(:encode).arity == 1
-      PgQuery.deparse_protobuf(PgQuery::ParseResult.encode(tree)).force_encoding('UTF-8')
-    elsif PgQuery::ParseResult.method(:encode).arity == -1
-      PgQuery.deparse_protobuf(PgQuery::ParseResult.encode(tree, recursion_limit: 1_000)).force_encoding('UTF-8')
+  def self.deparse(tree, opts: nil)
+    protobuf_encoded = if PgQuery::ParseResult.method(:encode).arity == 1
+                         PgQuery::ParseResult.encode(tree)
+                       elsif PgQuery::ParseResult.method(:encode).arity == -1
+                         PgQuery::ParseResult.encode(tree, recursion_limit: 1_000)
+                       else
+                         raise ArgumentError, 'Unsupported protobuf Ruby API'
+                       end
+
+    if opts
+      PgQuery.deparse_protobuf_opts(
+        protobuf_encoded,
+        opts.pretty_print,
+        opts.comments || [],
+        opts.indent_size || 0,
+        opts.max_line_length || 0,
+        opts.trailing_newline,
+        opts.commas_start_of_line
+      ).force_encoding('UTF-8')
     else
-      raise ArgumentError, 'Unsupported protobuf Ruby API'
+      PgQuery.deparse_protobuf(protobuf_encoded).force_encoding('UTF-8')
     end
   end
 

data/lib/pg_query/parse.rb

@@ -106,6 +106,7 @@ module PgQuery
       statements = @tree.stmts.dup.to_a.map(&:stmt)
       from_clause_items = [] # types: select, dml, ddl
       subselect_items = []
+      call_items = [] # CALL fn()
 
       loop do
         statement = statements.shift
@@ -171,6 +172,8 @@ module PgQuery
           when :copy_stmt
             from_clause_items << { item: PgQuery::Node.new(range_var: statement.copy_stmt.relation), type: :dml } if statement.copy_stmt.relation
             statements << statement.copy_stmt.query
+          when :call_stmt
+            call_items << statement.call_stmt
           # The following statement types are DDL (changing table structure)
           when :alter_table_stmt
             case statement.alter_table_stmt.objtype
@@ -276,15 +279,20 @@ module PgQuery
             end
           when :bool_expr
             subselect_items.concat(next_item.bool_expr.args.to_ary)
+          when :boolean_test
+            subselect_items << next_item.boolean_test.arg
           when :coalesce_expr
             subselect_items.concat(next_item.coalesce_expr.args.to_ary)
           when :min_max_expr
             subselect_items.concat(next_item.min_max_expr.args.to_ary)
+          when :null_test
+            subselect_items << next_item.null_test.arg
           when :res_target
             subselect_items << next_item.res_target.val
           when :sub_link
             statements << next_item.sub_link.subselect
           when :func_call
+            # See also CALL below
             subselect_items.concat(next_item.func_call.args.to_ary)
             @functions << {
               function: next_item.func_call.funcname.map { |f| f.string.sval }.join('.'),
@@ -299,6 +307,17 @@ module PgQuery
           end
         end
 
+        # CALL fn()
+        next_item = call_items.shift
+        if next_item
+          # Treat as a sub-select. Note the difference in underscore in func_call versus the above.
+          subselect_items.concat(next_item.funccall.args.to_ary)
+          @functions << {
+            function: next_item.funccall.funcname.map { |f| f.string.sval }.join('.'),
+            type: :call
+          }
+        end
+
         next_item = from_clause_items.shift
         if next_item && next_item[:item]
           case next_item[:item].node