pg_query 2.1.0 → 4.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ede23ff0f5d9af4599a7732fe624b3e2fba355ebb54bb6b88df3ef3932d7692a
-  data.tar.gz: d11105ea7323b8908dde6b328908190858d150f12a13a109d943ae3bf8af475b
+  metadata.gz: 32a51d0f608ebfe0e27991db81924289d86c7f0b9a90ab56a321b9ef5c21794e
+  data.tar.gz: 0d56fc7fd092c3406a40d102f420d637347d45f77203cc4de2f4613a111438dc
 SHA512:
-  metadata.gz: 37b3301df52b4743098ded9bbb69b05f4a360f7e1335386833ac619f4e5423f7b3c42a6506b3519c59ed3d0bb62e6e59ef04c8515fc9a3eb5daa95c53ab228e7
-  data.tar.gz: cd94026574593d6e78ac41e88c3378a6c46ea6d0869f8ddd9a200c367a969ff67695a780b0609518eafcff7a8dfaff015ce6408662eff7616cb866b46b52593a
+  metadata.gz: f1adefd8ebb6ab5595bf97f79ca027fb5e3c6cc351fbac310252a1a0f6d13c566c2a09b268ff5c173d0ab968ce7171f6b29dc2c071814b407883d77c315d50ae
+  data.tar.gz: 824faa4086e30b42199491049a16c4e7287a9c5b6146aba89ef353b77cfe6a3452ae4f2f09169b5851ff3b266df71bd02a948141f2e4bd05e02425e09db5b6f1

data/CHANGELOG.md

@@ -5,6 +5,110 @@
 * ...
 
 
+## 4.2.1     2023-05-19
+
+* Parse: Fix `ALTER INDEX my_index_name` to return `tables=[]` ([#285](https://github.com/pganalyze/pg_query/pull/285))
+* Parse: Detect tables in a SELECT INTO clause as DDL tables ([#281](https://github.com/pganalyze/pg_query/pull/281))
+* Add support for Ruby 3.2 ([#283](https://github.com/pganalyze/pg_query/pull/283))
+* Bump up `google-protobuf` dependency to `>= 3.22.3`
+  - 3.22.0 or newer is required for Ruby 3.2 support
+* Update to libpg_query 15-4.2.1
+  - Deparser: Handle INTERVAL correctly when used in SET statements
+  - Deparser: Ensure index names are quoted as identifiers
+
+
+## 4.2.0     2023-02-08
+
+* Update to libpg_query 15-4.2.0
+  - Update to PostgreSQL 15.1
+
+
+## 2.2.1     2023-01-20
+
+* Detect tables used in the query of a PREPARE statement ([#273](https://github.com/pganalyze/pg_query/pull/273))
+* Expose recursive walk functionality via walk! ([#268](https://github.com/pganalyze/pg_query/pull/268))
+* Retain schema in name when parsing out functions ([#272](https://github.com/pganalyze/pg_query/pull/272))
+
+
+## 2.2.0     2022-11-02
+
+* Update to libpg_query 13-2.2.0 ([#264](https://github.com/pganalyze/pg_query/pull/264))
+  - Fingerprinting version 3.1
+    - Fixes issue with "SELECT DISTINCT" having the same fingerprint as "SELECT"
+      (fingerprints for "SELECT DISTINCT" will change with this revision)
+    - Group additional DDL statements together that otherwise generate a lot of
+      unique fingerprints (ListenStmt, UnlistenStmt, NotifyStmt, CreateFunctionStmt,
+      FunctionParameter and DoStmt)
+  - Deparser improvements
+    - Prefix errors with "deparse", and remove some asserts
+    - Fix potential segfault when passing invalid protobuf (RawStmt without Stmt)
+  - Update to Postgres 13.8 patch release
+  - Backport Xcode 14.1 build fix from upcoming 13.9 release
+  - Normalize additional DDL statements
+  - Add support for analyzing PL/pgSQL code inside DO blocks
+  - Fix memory leak in pg_query_fingerprint error handling
+  - PL/pgSQL parser: Add support for Assert, SET, COMMIT, ROLLBACK and CALL
+  - Add support for parsing more operators that include a `?` character
+* Support deparsing deeply nested queries ([#259](https://github.com/pganalyze/pg_query/pull/259))
+
+
+## 2.1.4     2022-09-19
+
+* Truncate: Simplify VALUES(...) lists
+* Truncate: Correctly handle UPDATE and ON CONFLICT target lists
+* Support complex queries with deeply nested ASTs ([#238](https://github.com/pganalyze/pg_query/pull/238))
+* Find table references inside type casts
+* Find function calls referenced in expression indexes ([#249](https://github.com/pganalyze/pg_query/pull/249))
+* Drop `Init_pg_query` from exported symbol map ([#256](https://github.com/pganalyze/pg_query/pull/256))
+
+
+## 2.1.3     2022-01-28
+
+* Track tables in EXCEPT and INTERSECT queries ([#239](https://github.com/pganalyze/pg_query/pull/239))
+* Get filter_columns working with UNION/EXCEPT/INTERSECT ([#240](https://github.com/pganalyze/pg_query/pull/240))
+* Update google-protobuf to address CVE scanner complaints
+  - Note that none of the CVEs apply to pg_query, but this avoids unnecessary errors when
+    the google-protobuf dependency is pulled in
+
+
+## 2.1.2     2021-11-12
+
+* Find tables in using clause of delete statement ([#234](https://github.com/pganalyze/pg_query/pull/234))
+* Find tables in case statements ([#235](https://github.com/pganalyze/pg_query/pull/235))
+* Correctly find nested tables in a subselect in a join condition ([#233](https://github.com/pganalyze/pg_query/pull/233))
+* Mark Postgres methods as visibility hidden, to avoid bloating dynamic symbol table ([#232](https://github.com/pganalyze/pg_query/pull/232))
+  - This is required on ELF platforms (i.e. Linux, etc) to avoid including all global
+    symbols in the shared library's symbol table, bloating the size, and causing
+    potential conflicts with other C libraries using the same symbol names.
+
+
+## 2.1.1     2021-10-13
+
+* Update to libpg_query 13-2.1.0 ([#230](https://github.com/pganalyze/pg_query/pull/230))
+  - Normalize: add funcname error object
+  - Normalize: Match GROUP BY against target list and re-use param refs
+  - PL/pgSQL: Setup namespace items for parameters, support RECORD types
+    - This significantly improves parsing for PL/pgSQL functions, to the extent
+      that most functions should now parse successfully
+  - Normalize: Don't modify constants in TypeName typmods/arrayBounds fields
+    - This matches how pg_stat_statement behaves, and avoids causing parsing
+      errors on the normalized statement
+  - Don't fail builds on systems that have strchrnul support (FreeBSD)
+* Fix build on FreeBSD ([#222](https://github.com/pganalyze/pg_query/pull/222))
+* Add workaround for Ruby garbage collection bug ([#227](https://github.com/pganalyze/pg_query/pull/227))
+  - The Ruby interpreter has a bug in `String#concat` where the appended
+    array may be garbage collected prematurely because the compiler
+    optimized out a Ruby stack variable. We now call `to_ary` on the
+    Protobuf object to ensure the array lands on the Ruby stack so the
+    garbage collector sees it.
+  - The real fix in the interpreter is described in
+    https://bugs.ruby-lang.org/issues/18140#note-2, but most current Ruby
+    interpreters won't have this fix for some time.
+* Table/function extraction: Support subselects and LATERAL better ([#229](https://github.com/pganalyze/pg_query/pull/229))
+  - This reworks the parsing logic so we don't ignore certain kinds of
+    subselects.
+
+
 ## 2.1.0     2021-07-04
 
 * Update to libpg_query 13-2.0.6

data/README.md

@@ -2,11 +2,11 @@
 
 This Ruby extension uses the actual PostgreSQL server source to parse SQL queries and return the internal PostgreSQL parsetree.
 
-In addition the extension allows you to normalize queries (replacing constant values with ?) and parse these normalized queries into a parsetree again.
+In addition the extension allows you to normalize queries (replacing constant values with $n) and parse these normalized queries into a parsetree again.
 
 When you build this extension, it builds parts of the PostgreSQL server source (see [libpg_query](https://github.com/pganalyze/libpg_query)), and then statically links it into this extension.
 
-This is slightly crazy, but is the only reliable way of parsing all valid PostgreSQL queries.
+This may seem like a lot of complexity, but is the only reliable way of parsing all valid PostgreSQL queries.
 
 You can find further examples and a longer rationale here: https://pganalyze.com/blog/parse-postgresql-queries-in-ruby.html
 
@@ -25,10 +25,10 @@ Due to compiling parts of PostgreSQL, installation might take a while on slower
 ```ruby
 PgQuery.parse("SELECT 1")
 
-=> #<PgQuery::ParserResult:0x00007fb69a958820
+=> #<PgQuery::ParserResult:0x000000012000c438
   @query="SELECT 1",
   @tree=<PgQuery::ParseResult:
-    version: 130002,
+    version: 150001,
     stmts: [
       <PgQuery::RawStmt:
         stmt: <PgQuery::Node:
@@ -41,10 +41,11 @@ PgQuery.parse("SELECT 1")
                   indirection: [],
                   val: <PgQuery::Node:
                     a_const: <PgQuery::A_Const:
-                      val: <PgQuery::Node:
-                        integer: <PgQuery::Integer: ival: 1>
-                      >,
-                      location: 7
+                      isnull: false,
+                      location: 7,
+                      ival: <PgQuery::Integer:
+                        ival: 1
+                      >
                     >
                   >,
                   location: 7
@@ -53,6 +54,7 @@ PgQuery.parse("SELECT 1")
             ],
             from_clause: [],
             group_clause: [],
+            group_distinct: false,
             window_clause: [],
             values_lists: [],
             sort_clause: [],
@@ -67,11 +69,18 @@ PgQuery.parse("SELECT 1")
       >
     ]
   >,
-  @warnings=[]>
+  @warnings=[],
+  @tables=nil,
+  @aliases=nil,
+  @cte_names=nil,
+  @functions=nil
+>
 ```
 
 ### Modifying a parsed query and turning it into SQL again
 
+This is a simple example for `deparse`, for more complex modification, use `walk!`.
+
 ```ruby
 parsed_query = PgQuery.parse("SELECT * FROM users")
 
@@ -90,20 +99,12 @@ parsed_query.deparse
 PgQuery.normalize("SELECT 1 FROM x WHERE y = 'foo'")
 
 => "SELECT $1 FROM x WHERE y = $2"
-
-# Parsing a normalized query (pre-Postgres 10 style)
-PgQuery.parse("SELECT ? FROM x WHERE y = ?")
-
-=> #<PgQuery::ParserResult:0x00007fb69a97a5d8
-  @query="SELECT ? FROM x WHERE y = ?",
-  @tree=<PgQuery::ParseResult: ...>,
-  @warnings=[]>
 ```
 
 ### Extracting tables from a query
 
 ```ruby
-PgQuery.parse("SELECT ? FROM x JOIN y USING (id) WHERE z = ?").tables
+PgQuery.parse("SELECT $1 FROM x JOIN y USING (id) WHERE z = $2").tables
 
 => ["x", "y"]
 ```
@@ -111,7 +112,7 @@ PgQuery.parse("SELECT ? FROM x JOIN y USING (id) WHERE z = ?").tables
 ### Extracting columns from a query
 
 ```ruby
-PgQuery.parse("SELECT ? FROM x WHERE x.y = ? AND z = ?").filter_columns
+PgQuery.parse("SELECT $1 FROM x WHERE x.y = $2 AND z = $3").filter_columns
 
 => [["x", "y"], [nil, "z"]]
 ```
@@ -128,7 +129,7 @@ PgQuery.parse("SELECT 2; --- comment").fingerprint
 => "50fde20626009aba"
 
 # Faster fingerprint method that is implemented inside the native C library
-PgQuery.fingerprint("SELECT ?")
+PgQuery.fingerprint("SELECT $1")
 
 => "50fde20626009aba"
 ```
@@ -138,27 +139,52 @@ PgQuery.fingerprint("SELECT ?")
 ```ruby
 PgQuery.scan('SELECT 1 --comment')
 
-=> [<PgQuery::ScanResult: version: 130002, tokens: [
+=> [<PgQuery::ScanResult: version: 150001, tokens: [
 <PgQuery::ScanToken: start: 0, end: 6, token: :SELECT, keyword_kind: :RESERVED_KEYWORD>,
 <PgQuery::ScanToken: start: 7, end: 8, token: :ICONST, keyword_kind: :NO_KEYWORD>,
 <PgQuery::ScanToken: start: 9, end: 18, token: :SQL_COMMENT, keyword_kind: :NO_KEYWORD>]>,
  []]
 ```
 
-## Differences from Upstream PostgreSQL
+### Walking the parse tree
+
+For generalized use, PgQuery provides `walk!` as a means to recursively work with the parsed query.
+
+This can be used to create a bespoke pretty printer:
+
+```ruby
+parsed_query = PgQuery.parse "SELECT * FROM tbl"
+parsed_query.walk! { |node, k, v, location| puts k }
+```
+
+More usefully, this can be used to rewrite a query. For example:
+
+```ruby
+parsed_query.walk! do |node, k, v, location| puts k
+  next unless k.eql?(:range_var) || k.eql?(:relation)
+  next if v.relname.nil?
+  v.relname = "X_" + v.relname
+end
+
+parsed_query.deparse
+```
+
+There are some caveats, and limitations, in this example.
+
+First, some of the tree nodes are frozen. You can replace them, but you cannot modify in place.
 
-This gem is based on [libpg_query](https://github.com/pganalyze/libpg_query),
-which uses the latest stable PostgreSQL version, but with a patch applied
-to support parsing normalized queries containing `?` replacement characters.
+Second, table rewriting is a bit more nuanced than this example. While this will rewrite the table names, it will
+not correctly handle all CTEs, or rewrite columns with explicit table names.
 
 ## Supported Ruby Versions
 
 Currently tested and officially supported Ruby versions:
 
-* CRuby 2.5
 * CRuby 2.6
 * CRuby 2.7
 * CRuby 3.0
+* CRuby 3.1
+* CRuby 3.2
 
 Not supported:
 
@@ -182,7 +208,7 @@ Once that is done, follow the following steps:
 
 ## Resources
 
-See [libpg_query](https://github.com/pganalyze/libpg_query/blob/13-latest/README.md#resources) for pg_query in other languages, as well as products/tools built on pg_query.
+See [libpg_query](https://github.com/pganalyze/libpg_query/blob/15-latest/README.md#resources) for pg_query in other languages, as well as products/tools built on pg_query.
 
 ## Original Author
 
@@ -196,8 +222,10 @@ See [libpg_query](https://github.com/pganalyze/libpg_query/blob/13-latest/README
 
 ## License
 
-Copyright (c) 2015, pganalyze Team <team@pganalyze.com><br>
-pg_query is licensed under the 3-clause BSD license, see LICENSE file for details.
+PostgreSQL server source code, used under the [PostgreSQL license](https://www.postgresql.org/about/licence/).<br>
+Portions Copyright (c) 1996-2023, The PostgreSQL Global Development Group<br>
+Portions Copyright (c) 1994, The Regents of the University of California
 
-Query normalization code:<br>
-Copyright (c) 2008-2015, PostgreSQL Global Development Group
+All other parts are licensed under the 3-clause BSD license, see LICENSE file for details.<br>
+Copyright (c) 2015, Lukas Fittl <lukas@fittl.com><br>
+Copyright (c) 2016-2023, Duboce Labs, Inc. (pganalyze) <team@pganalyze.com>

data/Rakefile

@@ -5,8 +5,8 @@ require 'rspec/core/rake_task'
 require 'rubocop/rake_task'
 require 'open-uri'
 
-LIB_PG_QUERY_TAG = '13-2.0.6'.freeze
-LIB_PG_QUERY_SHA256SUM = '61f384ac949bd7404efe6bcc37a8a6fca79030e59c02659f108ee1db45e93414'.freeze
+LIB_PG_QUERY_TAG = '15-4.2.1'.freeze
+LIB_PG_QUERY_SHA256SUM = '5828124517d8fd3091336fad6897e16ab49ec0b0b188f5859b3b928fc91608c2'.freeze
 
 Rake::ExtensionTask.new 'pg_query' do |ext|
   ext.lib_dir = 'lib/pg_query'

data/ext/pg_query/extconf.rb

@@ -7,11 +7,17 @@ require 'pathname'
 
 $objs = Dir.glob(File.join(__dir__, '*.c')).map { |f| Pathname.new(f).sub_ext('.o').to_s }
 
-$CFLAGS << " -O3 -Wall -fno-strict-aliasing -fwrapv -fstack-protector -Wno-unused-function -Wno-unused-variable -g"
+$CFLAGS << " -fvisibility=hidden -O3 -Wall -fno-strict-aliasing -fwrapv -fstack-protector -Wno-unused-function -Wno-unused-variable -Wno-clobbered -Wno-sign-compare -Wno-discarded-qualifiers -g"
 
 $INCFLAGS = "-I#{File.join(__dir__, 'include')} " + $INCFLAGS
 
-SYMFILE = File.join(__dir__, 'pg_query_ruby.sym')
+SYMFILE =
+  if RUBY_PLATFORM =~ /freebsd/
+    File.join(__dir__, 'pg_query_ruby_freebsd.sym')
+  else
+    File.join(__dir__, 'pg_query_ruby.sym')
+  end
+
 if RUBY_PLATFORM =~ /darwin/
   $DLDFLAGS << " -Wl,-exported_symbols_list #{SYMFILE}" unless defined?(::Rubinius)
 else

data/ext/pg_query/include/access/amapi.h

@@ -3,7 +3,7 @@
  * amapi.h
  *	  API for Postgres index access methods.
  *
- * Copyright (c) 2015-2020, PostgreSQL Global Development Group
+ * Copyright (c) 2015-2022, PostgreSQL Global Development Group
  *
  * src/include/access/amapi.h
  *
@@ -54,6 +54,42 @@ typedef enum IndexAMProperty
 	AMPROP_CAN_INCLUDE
 } IndexAMProperty;
 
+/*
+ * We use lists of this struct type to keep track of both operators and
+ * support functions while building or adding to an opclass or opfamily.
+ * amadjustmembers functions receive lists of these structs, and are allowed
+ * to alter their "ref" fields.
+ *
+ * The "ref" fields define how the pg_amop or pg_amproc entry should depend
+ * on the associated objects (that is, which dependency type to use, and
+ * which opclass or opfamily it should depend on).
+ *
+ * If ref_is_hard is true, the entry will have a NORMAL dependency on the
+ * operator or support func, and an INTERNAL dependency on the opclass or
+ * opfamily.  This forces the opclass or opfamily to be dropped if the
+ * operator or support func is dropped, and requires the CASCADE option
+ * to do so.  Nor will ALTER OPERATOR FAMILY DROP be allowed.  This is
+ * the right behavior for objects that are essential to an opclass.
+ *
+ * If ref_is_hard is false, the entry will have an AUTO dependency on the
+ * operator or support func, and also an AUTO dependency on the opclass or
+ * opfamily.  This allows ALTER OPERATOR FAMILY DROP, and causes that to
+ * happen automatically if the operator or support func is dropped.  This
+ * is the right behavior for inessential ("loose") objects.
+ */
+typedef struct OpFamilyMember
+{
+	bool		is_func;		/* is this an operator, or support func? */
+	Oid			object;			/* operator or support func's OID */
+	int			number;			/* strategy or support func number */
+	Oid			lefttype;		/* lefttype */
+	Oid			righttype;		/* righttype */
+	Oid			sortfamily;		/* ordering operator's sort opfamily, or 0 */
+	bool		ref_is_hard;	/* hard or soft dependency? */
+	bool		ref_is_family;	/* is dependency on opclass or opfamily? */
+	Oid			refobjid;		/* OID of opclass or opfamily */
+} OpFamilyMember;
+
 
 /*
  * Callback function signatures --- see indexam.sgml for more info.
@@ -74,6 +110,7 @@ typedef bool (*aminsert_function) (Relation indexRelation,
 								   ItemPointer heap_tid,
 								   Relation heapRelation,
 								   IndexUniqueCheck checkUnique,
+								   bool indexUnchanged,
 								   struct IndexInfo *indexInfo);
 
 /* bulk delete */
@@ -114,6 +151,12 @@ typedef char *(*ambuildphasename_function) (int64 phasenum);
 /* validate definition of an opclass for this AM */
 typedef bool (*amvalidate_function) (Oid opclassoid);
 
+/* validate operators and support functions to be added to an opclass/family */
+typedef void (*amadjustmembers_function) (Oid opfamilyoid,
+										  Oid opclassoid,
+										  List *operators,
+										  List *functions);
+
 /* prepare for index scan */
 typedef IndexScanDesc (*ambeginscan_function) (Relation indexRelation,
 											   int nkeys,
@@ -224,6 +267,7 @@ typedef struct IndexAmRoutine
 	amproperty_function amproperty; /* can be NULL */
 	ambuildphasename_function ambuildphasename; /* can be NULL */
 	amvalidate_function amvalidate;
+	amadjustmembers_function amadjustmembers;	/* can be NULL */
 	ambeginscan_function ambeginscan;
 	amrescan_function amrescan;
 	amgettuple_function amgettuple; /* can be NULL */

data/ext/pg_query/include/access/attmap.h

@@ -4,7 +4,7 @@
  *	  Definitions for PostgreSQL attribute mappings
  *
  *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * src/include/access/attmap.h

data/ext/pg_query/include/access/attnum.h

@@ -4,7 +4,7 @@
  *	  POSTGRES attribute number definitions.
  *
  *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * src/include/access/attnum.h
@@ -36,7 +36,7 @@ typedef int16 AttrNumber;
 
 /*
  * AttrNumberIsForUserDefinedAttr
- *		True iff the attribute number corresponds to an user defined attribute.
+ *		True iff the attribute number corresponds to a user defined attribute.
  */
 #define AttrNumberIsForUserDefinedAttr(attributeNumber) \
 	((bool) ((attributeNumber) > 0))

data/ext/pg_query/include/access/clog.h

@@ -3,7 +3,7 @@
  *
  * PostgreSQL transaction-commit-log manager
  *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * src/include/access/clog.h
@@ -12,6 +12,7 @@
 #define CLOG_H
 
 #include "access/xlogreader.h"
+#include "storage/sync.h"
 #include "lib/stringinfo.h"
 
 /*
@@ -45,11 +46,12 @@ extern void CLOGShmemInit(void);
 extern void BootStrapCLOG(void);
 extern void StartupCLOG(void);
 extern void TrimCLOG(void);
-extern void ShutdownCLOG(void);
 extern void CheckPointCLOG(void);
 extern void ExtendCLOG(TransactionId newestXact);
 extern void TruncateCLOG(TransactionId oldestXact, Oid oldestxid_datoid);
 
+extern int	clogsyncfiletag(const FileTag *ftag, char *path);
+
 /* XLOG stuff */
 #define CLOG_ZEROPAGE		0x00
 #define CLOG_TRUNCATE		0x10

data/ext/pg_query/include/access/commit_ts.h

@@ -3,7 +3,7 @@
  *
  * PostgreSQL commit timestamp manager
  *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * src/include/access/commit_ts.h
@@ -14,17 +14,14 @@
 #include "access/xlog.h"
 #include "datatype/timestamp.h"
 #include "replication/origin.h"
-#include "utils/guc.h"
+#include "storage/sync.h"
 
 
 extern PGDLLIMPORT bool track_commit_timestamp;
 
-extern bool check_track_commit_timestamp(bool *newval, void **extra,
-										 GucSource source);
-
 extern void TransactionTreeSetCommitTsData(TransactionId xid, int nsubxids,
 										   TransactionId *subxids, TimestampTz timestamp,
-										   RepOriginId nodeid, bool write_xlog);
+										   RepOriginId nodeid);
 extern bool TransactionIdGetCommitTsData(TransactionId xid,
 										 TimestampTz *ts, RepOriginId *nodeid);
 extern TransactionId GetLatestCommitTsData(TimestampTz *ts,
@@ -37,7 +34,6 @@ extern void BootStrapCommitTs(void);
 extern void StartupCommitTs(void);
 extern void CommitTsParameterChange(bool newvalue, bool oldvalue);
 extern void CompleteCommitTsInitialization(void);
-extern void ShutdownCommitTs(void);
 extern void CheckPointCommitTs(void);
 extern void ExtendCommitTs(TransactionId newestXact);
 extern void TruncateCommitTs(TransactionId oldestXact);
@@ -45,10 +41,11 @@ extern void SetCommitTsLimit(TransactionId oldestXact,
 							 TransactionId newestXact);
 extern void AdvanceOldestCommitTsXid(TransactionId oldestXact);
 
+extern int	committssyncfiletag(const FileTag *ftag, char *path);
+
 /* XLOG stuff */
 #define COMMIT_TS_ZEROPAGE		0x00
 #define COMMIT_TS_TRUNCATE		0x10
-#define COMMIT_TS_SETTS			0x20
 
 typedef struct xl_commit_ts_set
 {
@@ -56,7 +53,7 @@ typedef struct xl_commit_ts_set
 	RepOriginId nodeid;
 	TransactionId mainxid;
 	/* subxact Xids follow */
-} xl_commit_ts_set;
+}			xl_commit_ts_set;
 
 #define SizeOfCommitTsSet	(offsetof(xl_commit_ts_set, mainxid) + \
 							 sizeof(TransactionId))

data/ext/pg_query/include/access/detoast.h

@@ -3,7 +3,7 @@
  * detoast.h
  *	  Access to compressed and external varlena values.
  *
- * Copyright (c) 2000-2020, PostgreSQL Global Development Group
+ * Copyright (c) 2000-2022, PostgreSQL Global Development Group
  *
  * src/include/access/detoast.h
  *
@@ -12,16 +12,6 @@
 #ifndef DETOAST_H
 #define DETOAST_H
 
-/*
- * Testing whether an externally-stored value is compressed now requires
- * comparing extsize (the actual length of the external data) to rawsize
- * (the original uncompressed datum's size).  The latter includes VARHDRSZ
- * overhead, the former doesn't.  We never use compression unless it actually
- * saves space, so we expect either equality or less-than.
- */
-#define VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer) \
-	((toast_pointer).va_extsize < (toast_pointer).va_rawsize - VARHDRSZ)
-
 /*
  * Macro to fetch the possibly-unaligned contents of an EXTERNAL datum
  * into a local "struct varatt_external" toast pointer.  This should be

data/ext/pg_query/include/access/genam.h

@@ -4,7 +4,7 @@
  *	  POSTGRES generalized index access method definitions.
  *
  *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * src/include/access/genam.h
@@ -38,8 +38,8 @@ typedef struct IndexBuildResult
  *
  * num_heap_tuples is accurate only when estimated_count is false;
  * otherwise it's just an estimate (currently, the estimate is the
- * prior value of the relation's pg_class.reltuples field).  It will
- * always just be an estimate during ambulkdelete.
+ * prior value of the relation's pg_class.reltuples field, so it could
+ * even be -1).  It will always just be an estimate during ambulkdelete.
  */
 typedef struct IndexVacuumInfo
 {
@@ -63,20 +63,22 @@ typedef struct IndexVacuumInfo
  * of which this is just the first field; this provides a way for ambulkdelete
  * to communicate additional private data to amvacuumcleanup.
  *
- * Note: pages_removed is the amount by which the index physically shrank,
- * if any (ie the change in its total size on disk).  pages_deleted and
- * pages_free refer to free space within the index file.  Some index AMs
- * may compute num_index_tuples by reference to num_heap_tuples, in which
- * case they should copy the estimated_count field from IndexVacuumInfo.
+ * Note: pages_newly_deleted is the number of pages in the index that were
+ * deleted by the current vacuum operation.  pages_deleted and pages_free
+ * refer to free space within the index file.
+ *
+ * Note: Some index AMs may compute num_index_tuples by reference to
+ * num_heap_tuples, in which case they should copy the estimated_count field
+ * from IndexVacuumInfo.
  */
 typedef struct IndexBulkDeleteResult
 {
 	BlockNumber num_pages;		/* pages remaining in index */
-	BlockNumber pages_removed;	/* # removed during vacuum operation */
 	bool		estimated_count;	/* num_index_tuples is an estimate */
 	double		num_index_tuples;	/* tuples remaining */
 	double		tuples_removed; /* # removed during vacuum operation */
-	BlockNumber pages_deleted;	/* # unused pages in index */
+	BlockNumber pages_newly_deleted;	/* # pages marked deleted by us  */
+	BlockNumber pages_deleted;	/* # pages marked deleted (could be by us) */
 	BlockNumber pages_free;		/* # pages available for reuse */
 } IndexBulkDeleteResult;
 
@@ -143,6 +145,7 @@ extern bool index_insert(Relation indexRelation,
 						 ItemPointer heap_t_ctid,
 						 Relation heapRelation,
 						 IndexUniqueCheck checkUnique,
+						 bool indexUnchanged,
 						 struct IndexInfo *indexInfo);
 
 extern IndexScanDesc index_beginscan(Relation heapRelation,
@@ -174,11 +177,11 @@ extern bool index_getnext_slot(IndexScanDesc scan, ScanDirection direction,
 extern int64 index_getbitmap(IndexScanDesc scan, TIDBitmap *bitmap);
 
 extern IndexBulkDeleteResult *index_bulk_delete(IndexVacuumInfo *info,
-												IndexBulkDeleteResult *stats,
+												IndexBulkDeleteResult *istat,
 												IndexBulkDeleteCallback callback,
 												void *callback_state);
 extern IndexBulkDeleteResult *index_vacuum_cleanup(IndexVacuumInfo *info,
-												   IndexBulkDeleteResult *stats);
+												   IndexBulkDeleteResult *istat);
 extern bool index_can_return(Relation indexRelation, int attno);
 extern RegProcedure index_getprocid(Relation irel, AttrNumber attnum,
 									uint16 procnum);

data/ext/pg_query/include/access/gin.h

@@ -2,7 +2,7 @@
  * gin.h
  *	  Public header file for Generalized Inverted Index access method.
  *
- *	Copyright (c) 2006-2020, PostgreSQL Global Development Group
+ *	Copyright (c) 2006-2022, PostgreSQL Global Development Group
  *
  *	src/include/access/gin.h
  *--------------------------------------------------------------------------
@@ -68,7 +68,7 @@ typedef char GinTernaryValue;
 
 /* GUC parameters */
 extern PGDLLIMPORT int GinFuzzySearchLimit;
-extern int	gin_pending_list_limit;
+extern PGDLLIMPORT int gin_pending_list_limit;
 
 /* ginutil.c */
 extern void ginGetStats(Relation index, GinStatsData *stats);