pg_query 4.2.0 → 4.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f3ea528544d70b22864e56f006dffce6c849d51eedb1de5d8644eb9f4d1b0ad
-  data.tar.gz: 7b2793ea012fcd4dd88a42703da627f6794c6f032ccd39fc9addb2f0bbc40208
+  metadata.gz: 32a51d0f608ebfe0e27991db81924289d86c7f0b9a90ab56a321b9ef5c21794e
+  data.tar.gz: 0d56fc7fd092c3406a40d102f420d637347d45f77203cc4de2f4613a111438dc
 SHA512:
-  metadata.gz: 23d2fae9e57c9c4f8b35856b42748ba8ff061ba5aa92ff4c679ebf5bce562ad7ddafa452183104318f19f09fb089f31108f922c39b057bccbbf028e50412b2fa
-  data.tar.gz: 3c64bf6d9eb662f348296ebc79ba8671a5be8e9053b873a4a7e0be8065229ab89ba0d28d5cea2ed3aea48a7dc2ee6053470adbe45b46bd93e5a2ca2ffb041128
+  metadata.gz: f1adefd8ebb6ab5595bf97f79ca027fb5e3c6cc351fbac310252a1a0f6d13c566c2a09b268ff5c173d0ab968ce7171f6b29dc2c071814b407883d77c315d50ae
+  data.tar.gz: 824faa4086e30b42199491049a16c4e7287a9c5b6146aba89ef353b77cfe6a3452ae4f2f09169b5851ff3b266df71bd02a948141f2e4bd05e02425e09db5b6f1

data/CHANGELOG.md

@@ -4,17 +4,32 @@
 
 * ...
 
-## 4.2.0     2022-02-08
+
+## 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     2022-01-20
+
+## 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))

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,7 +69,12 @@ 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
@@ -92,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"]
 ```
@@ -113,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"]]
 ```
@@ -130,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"
 ```
@@ -140,7 +139,7 @@ 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>]>,
@@ -177,20 +176,15 @@ First, some of the tree nodes are frozen. You can replace them, but you cannot m
 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.
 
-## Differences from Upstream PostgreSQL
-
-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.
-
 ## 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:
 
@@ -214,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
 
@@ -228,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 = '15-4.2.0'.freeze
-LIB_PG_QUERY_SHA256SUM = '573b7b0d3b04702ec9e541e0a504632de17bd90b948c5658e72c1cf9dfc3a05d'.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/pg_query_deparse.c

@@ -11,7 +11,6 @@
 #include "common/keywords.h"
 #include "common/kwlookup.h"
 #include "lib/stringinfo.h"
-#include "limits.h"
 #include "nodes/nodes.h"
 #include "nodes/parsenodes.h"
 #include "nodes/pg_list.h"
@@ -32,6 +31,7 @@ typedef enum DeparseNodeContext {
 	DEPARSE_NODE_CONTEXT_XMLNAMESPACES,
 	DEPARSE_NODE_CONTEXT_CREATE_TYPE,
 	DEPARSE_NODE_CONTEXT_ALTER_TYPE,
+	DEPARSE_NODE_CONTEXT_SET_STATEMENT,
 	// Identifier vs constant context
 	DEPARSE_NODE_CONTEXT_IDENTIFIER,
 	DEPARSE_NODE_CONTEXT_CONSTANT
@@ -160,8 +160,9 @@ static void deparseRangeSubselect(StringInfo str, RangeSubselect *range_subselec
 static void deparseRangeFunction(StringInfo str, RangeFunction *range_func);
 static void deparseAArrayExpr(StringInfo str, A_ArrayExpr * array_expr);
 static void deparseRowExpr(StringInfo str, RowExpr *row_expr);
-static void deparseTypeCast(StringInfo str, TypeCast *type_cast);
+static void deparseTypeCast(StringInfo str, TypeCast *type_cast, DeparseNodeContext context);
 static void deparseTypeName(StringInfo str, TypeName *type_name);
+static void deparseIntervalTypmods(StringInfo str, TypeName *type_name);
 static void deparseNullTest(StringInfo str, NullTest *null_test);
 static void deparseCaseExpr(StringInfo str, CaseExpr *case_expr);
 static void deparseCaseWhen(StringInfo str, CaseWhen *case_when);
@@ -260,7 +261,7 @@ static void deparseExpr(StringInfo str, Node *node)
 			deparseXmlExpr(str, castNode(XmlExpr, node));
 			break;
 		case T_TypeCast:
-			deparseTypeCast(str, castNode(TypeCast, node));
+			deparseTypeCast(str, castNode(TypeCast, node), DEPARSE_NODE_CONTEXT_NONE);
 			break;
 		case T_A_Const:
 			deparseAConst(str, castNode(A_Const, node));
@@ -341,7 +342,7 @@ static void deparseCExpr(StringInfo str, Node *node)
 			deparseAConst(str, castNode(A_Const, node));
 			break;
 		case T_TypeCast:
-			deparseTypeCast(str, castNode(TypeCast, node));
+			deparseTypeCast(str, castNode(TypeCast, node), DEPARSE_NODE_CONTEXT_NONE);
 			break;
 		case T_A_Expr:
 			appendStringInfoChar(str, '(');
@@ -1334,6 +1335,10 @@ static void deparseVarList(StringInfo str, List *l)
 			else
 				Assert(false);
 		}
+		else if (IsA(lfirst(lc), TypeCast))
+		{
+			deparseTypeCast(str, castNode(TypeCast, lfirst(lc)), DEPARSE_NODE_CONTEXT_SET_STATEMENT);
+		}
 		else
 		{
 			Assert(false);
@@ -1779,7 +1784,7 @@ static void deparseFuncExprWindowless(StringInfo str, Node* node)
 			deparseSQLValueFunction(str, castNode(SQLValueFunction, node));
 			break;
 		case T_TypeCast:
-			deparseTypeCast(str, castNode(TypeCast, node));
+			deparseTypeCast(str, castNode(TypeCast, node), DEPARSE_NODE_CONTEXT_NONE);
 			break;
 		case T_CoalesceExpr:
 			deparseCoalesceExpr(str, castNode(CoalesceExpr, node));
@@ -3534,7 +3539,7 @@ static void deparseRowExpr(StringInfo str, RowExpr *row_expr)
 	appendStringInfoChar(str, ')');
 }
 
-static void deparseTypeCast(StringInfo str, TypeCast *type_cast)
+static void deparseTypeCast(StringInfo str, TypeCast *type_cast, DeparseNodeContext context)
 {
 	bool need_parens = false;
 
@@ -3582,6 +3587,13 @@ static void deparseTypeCast(StringInfo str, TypeCast *type_cast)
 					return;
 				}
 			}
+			else if (strcmp(typename, "interval") == 0 && context == DEPARSE_NODE_CONTEXT_SET_STATEMENT && IsA(&a_const->val, String))
+			{
+				appendStringInfoString(str, "interval ");
+				deparseAConst(str, a_const);
+				deparseIntervalTypmods(str, type_cast->typeName);
+				return;
+			}
 		}
 
 		// Ensure negative values have wrapping parentheses
@@ -3706,70 +3718,9 @@ static void deparseTypeName(StringInfo str, TypeName *type_name)
 		}
 		else if (strcmp(name, "interval") == 0 && list_length(type_name->typmods) >= 1)
 		{
-			Assert(IsA(linitial(type_name->typmods), A_Const));
-			Assert(IsA(&castNode(A_Const, linitial(type_name->typmods))->val, Integer));
-
-			int fields = intVal(&castNode(A_Const, linitial(type_name->typmods))->val);
-
 			appendStringInfoString(str, "interval");
+			deparseIntervalTypmods(str, type_name);
 
-			// This logic is based on intervaltypmodout in timestamp.c
-			switch (fields)
-			{
-				case INTERVAL_MASK(YEAR):
-					appendStringInfoString(str, " year");
-					break;
-				case INTERVAL_MASK(MONTH):
-					appendStringInfoString(str, " month");
-					break;
-				case INTERVAL_MASK(DAY):
-					appendStringInfoString(str, " day");
-					break;
-				case INTERVAL_MASK(HOUR):
-					appendStringInfoString(str, " hour");
-					break;
-				case INTERVAL_MASK(MINUTE):
-					appendStringInfoString(str, " minute");
-					break;
-				case INTERVAL_MASK(SECOND):
-					appendStringInfoString(str, " second");
-					break;
-				case INTERVAL_MASK(YEAR) | INTERVAL_MASK(MONTH):
-					appendStringInfoString(str, " year to month");
-					break;
-				case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR):
-					appendStringInfoString(str, " day to hour");
-					break;
-				case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE):
-					appendStringInfoString(str, " day to minute");
-					break;
-				case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
-					appendStringInfoString(str, " day to second");
-					break;
-				case INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE):
-					appendStringInfoString(str, " hour to minute");
-					break;
-				case INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
-					appendStringInfoString(str, " hour to second");
-					break;
-				case INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
-					appendStringInfoString(str, " minute to second");
-					break;
-				case INTERVAL_FULL_RANGE:
-					// Nothing
-					break;
-				default:
-					Assert(false);
-					break;
-			}
-
-			if (list_length(type_name->typmods) == 2)
-			{
-				int precision = intVal(&castNode(A_Const, lsecond(type_name->typmods))->val);
-				if (precision != INTERVAL_FULL_PRECISION)
-					appendStringInfo(str, "(%d)", precision);
-			}
-			
 			skip_typmods = true;
 		}
 		else
@@ -3815,6 +3766,79 @@ static void deparseTypeName(StringInfo str, TypeName *type_name)
 		appendStringInfoString(str, "%type");
 }
 
+// Handle typemods for Interval types separately
+// so that they can be applied appropriately for different contexts.
+// For example, when using `SET` a query like `INTERVAL 'x' hour TO minute`
+// the `INTERVAL` keyword is specified first.
+// In all other contexts, intervals use the `'x'::interval` style.
+static void deparseIntervalTypmods(StringInfo str, TypeName *type_name)
+{
+	const char *name = strVal(lsecond(type_name->names));
+	Assert(strcmp(name, "interval") == 0);
+	Assert(list_length(type_name->typmods) >= 1);
+	Assert(IsA(linitial(type_name->typmods), A_Const));
+	Assert(IsA(&castNode(A_Const, linitial(type_name->typmods))->val, Integer));
+
+	int fields = intVal(&castNode(A_Const, linitial(type_name->typmods))->val);
+
+	// This logic is based on intervaltypmodout in timestamp.c
+	switch (fields)
+	{
+		case INTERVAL_MASK(YEAR):
+			appendStringInfoString(str, " year");
+			break;
+		case INTERVAL_MASK(MONTH):
+			appendStringInfoString(str, " month");
+			break;
+		case INTERVAL_MASK(DAY):
+			appendStringInfoString(str, " day");
+			break;
+		case INTERVAL_MASK(HOUR):
+			appendStringInfoString(str, " hour");
+			break;
+		case INTERVAL_MASK(MINUTE):
+			appendStringInfoString(str, " minute");
+			break;
+		case INTERVAL_MASK(SECOND):
+			appendStringInfoString(str, " second");
+			break;
+		case INTERVAL_MASK(YEAR) | INTERVAL_MASK(MONTH):
+			appendStringInfoString(str, " year to month");
+			break;
+		case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR):
+			appendStringInfoString(str, " day to hour");
+			break;
+		case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE):
+			appendStringInfoString(str, " day to minute");
+			break;
+		case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
+			appendStringInfoString(str, " day to second");
+			break;
+		case INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE):
+			appendStringInfoString(str, " hour to minute");
+			break;
+		case INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
+			appendStringInfoString(str, " hour to second");
+			break;
+		case INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
+			appendStringInfoString(str, " minute to second");
+			break;
+		case INTERVAL_FULL_RANGE:
+			// Nothing
+			break;
+		default:
+			Assert(false);
+			break;
+	}
+
+	if (list_length(type_name->typmods) == 2)
+	{
+		int precision = intVal(&castNode(A_Const, lsecond(type_name->typmods))->val);
+		if (precision != INTERVAL_FULL_PRECISION)
+			appendStringInfo(str, "(%d)", precision);
+	}
+}
+
 static void deparseNullTest(StringInfo str, NullTest *null_test)
 {
 	// argisrow is always false in raw parser output
@@ -6899,6 +6923,22 @@ static void deparseTransactionStmt(StringInfo str, TransactionStmt *transaction_
 	removeTrailingSpace(str);
 }
 
+// Determine if we hit SET TIME ZONE INTERVAL, that has special syntax not
+// supported for other SET statements
+static bool isSetTimeZoneInterval(VariableSetStmt* stmt)
+{
+	if (!(strcmp(stmt->name, "timezone") == 0 &&
+		  list_length(stmt->args) == 1 &&
+		  IsA(linitial(stmt->args), TypeCast)))
+		return false;
+
+	TypeName* typeName = castNode(TypeCast, linitial(stmt->args))->typeName;
+
+	return (list_length(typeName->names) == 2 &&
+		strcmp(strVal(linitial(typeName->names)), "pg_catalog") == 0 &&
+		strcmp(strVal(llast(typeName->names)), "interval") == 0);
+}
+
 static void deparseVariableSetStmt(StringInfo str, VariableSetStmt* variable_set_stmt)
 {
 	ListCell *lc;
@@ -6909,9 +6949,17 @@ static void deparseVariableSetStmt(StringInfo str, VariableSetStmt* variable_set
 			appendStringInfoString(str, "SET ");
 			if (variable_set_stmt->is_local)
 				appendStringInfoString(str, "LOCAL ");
-			deparseVarName(str, variable_set_stmt->name);
-			appendStringInfoString(str, " TO ");
-			deparseVarList(str, variable_set_stmt->args);
+			if (isSetTimeZoneInterval(variable_set_stmt))
+			{
+				appendStringInfoString(str, "TIME ZONE ");
+				deparseVarList(str, variable_set_stmt->args);
+			}
+			else
+			{
+				deparseVarName(str, variable_set_stmt->name);
+				appendStringInfoString(str, " TO ");
+				deparseVarList(str, variable_set_stmt->args);
+			}
 			break;
 		case VAR_SET_DEFAULT: /* SET var TO DEFAULT */
 			appendStringInfoString(str, "SET ");
@@ -7938,7 +7986,7 @@ static void deparseIndexStmt(StringInfo str, IndexStmt *index_stmt)
 
 	if (index_stmt->idxname != NULL)
 	{
-		appendStringInfoString(str, index_stmt->idxname);
+		appendStringInfoString(str, quote_identifier(index_stmt->idxname));
 		appendStringInfoChar(str, ' ');
 	}
 

data/lib/pg_query/parse.rb

@@ -139,6 +139,10 @@ module PgQuery
               @cte_names.concat(cte_names)
               statements.concat(cte_statements)
             end
+
+            if statement.select_stmt.into_clause
+              from_clause_items << { item: PgQuery::Node.new(range_var: statement.select_stmt.into_clause.rel), type: :ddl }
+            end
           # The following statements modify the contents of a table
           when :insert_stmt, :update_stmt, :delete_stmt
             value = statement.public_send(statement.node)
@@ -171,7 +175,12 @@ module PgQuery
             statements << statement.copy_stmt.query
           # The following statement types are DDL (changing table structure)
           when :alter_table_stmt
-            from_clause_items << { item: PgQuery::Node.new(range_var: statement.alter_table_stmt.relation), type: :ddl }
+            case statement.alter_table_stmt.objtype
+            when :OBJECT_INDEX # Index # rubocop:disable Lint/EmptyWhen
+              # ignore `ALTER INDEX index_name`
+            else
+              from_clause_items << { item: PgQuery::Node.new(range_var: statement.alter_table_stmt.relation), type: :ddl }
+            end
           when :create_stmt
             from_clause_items << { item: PgQuery::Node.new(range_var: statement.create_stmt.relation), type: :ddl }
           when :create_table_as_stmt

data/lib/pg_query/version.rb

@@ -1,3 +1,3 @@
 module PgQuery
-  VERSION = '4.2.0'.freeze
+  VERSION = '4.2.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_query
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.2.1
 platform: ruby
 authors:
 - Lukas Fittl
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-16 00:00:00.000000000 Z
+date: 2023-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.19.2
+        version: 3.22.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.19.2
+        version: 3.22.3
 description: Parses SQL queries using a copy of the PostgreSQL server query parser
 email: lukas@fittl.com
 executables: []
@@ -576,7 +576,7 @@ homepage: https://github.com/pganalyze/pg_query
 licenses:
 - BSD-3-Clause
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--main"
 - README.md
@@ -596,7 +596,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: PostgreSQL query parsing and normalization library
 test_files: []