Support BigQuery UNNEST ... WITH OFFSET after the alias

BigQuery writes UNNEST(array) [AS alias] WITH OFFSET [AS offsetAlias],
where WITH OFFSET follows the table alias and carries an alias of its
own. The pre-existing pre-alias form (WITH ORDINALITY|OFFSET AS t(a, b))
is untouched.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EqinwHBKuAtPEmtXr3b5P2

Author: hayssams

src/main/java/net/sf/jsqlparser/statement/select/TableFunction.java

@@ -24,6 +24,8 @@ public class TableFunction extends Function implements FromItem {
     private Function function;
     private ParenthesedExpressionList<Function> rowsFromFunctions;
     private String withClause = null;
+    private boolean withOffset = false;
+    private Alias offsetAlias = null;
 
     public TableFunction(Function function) {
         this.function = function;
@@ -121,6 +123,37 @@ public TableFunction setPrefix(String prefix) {
         return this;
     }
 
+    /**
+     * BigQuery's {@code UNNEST(array) [AS alias] WITH OFFSET [AS offsetAlias]}, where the
+     * {@code WITH OFFSET} clause follows the table alias and carries an alias of its own.
+     */
+    public boolean isWithOffset() {
+        return withOffset;
+    }
+
+    public void setWithOffset(boolean withOffset) {
+        this.withOffset = withOffset;
+    }
+
+    public TableFunction withWithOffset(boolean withOffset) {
+        setWithOffset(withOffset);
+        return this;
+    }
+
+    public Alias getOffsetAlias() {
+        return offsetAlias;
+    }
+
+    public void setOffsetAlias(Alias offsetAlias) {
+        this.offsetAlias = offsetAlias;
+        this.withOffset = true;
+    }
+
+    public TableFunction withOffsetAlias(Alias offsetAlias) {
+        setOffsetAlias(offsetAlias);
+        return this;
+    }
+
     public String getWithClause() {
         return withClause;
     }
@@ -211,6 +244,13 @@ public StringBuilder appendTo(StringBuilder builder) {
         if (alias != null) {
             builder.append(alias);
         }
+
+        if (withOffset) {
+            builder.append(" WITH OFFSET");
+            if (offsetAlias != null) {
+                builder.append(offsetAlias);
+            }
+        }
         return builder;
     }
 

src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt

@@ -7642,6 +7642,13 @@ FromItem FromItem() #FromItem:
     )
 
     [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() { fromItem.setAlias(alias); } ]
+    [
+        // BigQuery: UNNEST(array) AS alias WITH OFFSET AS offsetAlias
+        LOOKAHEAD(2, { fromItem instanceof TableFunction })
+        <K_WITH> <K_OFFSET> { ((TableFunction) fromItem).setWithOffset(true); }
+        [ LOOKAHEAD({ isAliasAhead() }) alias=Alias()
+            { ((TableFunction) fromItem).setOffsetAlias(alias); } ]
+    ]
     [
         LOOKAHEAD(2, {fromItem instanceof Table }) timeTravelStr = TimeTravelAfterAlias()
         { ((Table) fromItem).setTimeTravelStrAfterAlias(timeTravelStr); }

src/test/java/net/sf/jsqlparser/statement/select/BigQueryTest.java

@@ -133,4 +133,31 @@ void testOffsetClauseStillParses() throws JSQLParserException {
         String sqlStr = "SELECT a FROM t LIMIT 10 OFFSET 5";
         TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
     }
+
+    @Test
+    void testUnnestWithOffsetAfterAlias() throws JSQLParserException {
+        String sqlStr = "SELECT x, pos FROM UNNEST([1, 2, 3]) AS x WITH OFFSET AS pos";
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        TableFunction unnest = (TableFunction) select.getFromItem();
+
+        Assertions.assertTrue(unnest.isWithOffset());
+        Assertions.assertEquals("x", unnest.getAlias().getName());
+        Assertions.assertEquals("pos", unnest.getOffsetAlias().getName());
+    }
+
+    @Test
+    void testUnnestWithOffsetWithoutOffsetAlias() throws JSQLParserException {
+        String sqlStr = "SELECT * FROM t, UNNEST(t.arr) AS c WITH OFFSET";
+        TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+    }
+
+    @Test
+    void testUnnestWithOrdinalityAliasStillBindsToTableFunction() throws JSQLParserException {
+        String sqlStr = "SELECT * FROM UNNEST(ARRAY[1, 2, 3]) WITH ORDINALITY AS t (a, b)";
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        TableFunction unnest = (TableFunction) select.getFromItem();
+
+        Assertions.assertFalse(unnest.isWithOffset());
+        Assertions.assertEquals("t", unnest.getAlias().getName());
+    }
 }