feat: add structured MATCH_RECOGNIZE support

Author: minleejae

src/main/java/net/sf/jsqlparser/expression/ExpressionVisitor.java

@@ -510,6 +510,14 @@ default void visit(ExtractExpression extractExpression) {
         this.visit(extractExpression, null);
     }
 
+    default <S> T visit(RowPatternFunction function, S context) {
+        return function.getFunction().accept(this, context);
+    }
+
+    default void visit(RowPatternFunction function) {
+        visit(function, null);
+    }
+
     <S> T visit(IntervalExpression intervalExpression, S context);
 
     default void visit(IntervalExpression intervalExpression) {

src/main/java/net/sf/jsqlparser/expression/RowPatternFunction.java

@@ -0,0 +1,63 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2026 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.expression;
+
+import java.util.function.Consumer;
+import net.sf.jsqlparser.parser.ASTNodeAccessImpl;
+
+/** An explicit RUNNING or FINAL evaluation mode on a row-pattern function. */
+public class RowPatternFunction extends ASTNodeAccessImpl implements Expression {
+    public enum EvaluationMode {
+        RUNNING, FINAL
+    }
+
+    private EvaluationMode evaluationMode;
+    private Function function;
+
+    public RowPatternFunction(EvaluationMode evaluationMode, Function function) {
+        this.evaluationMode = evaluationMode;
+        this.function = function;
+    }
+
+    public EvaluationMode getEvaluationMode() {
+        return evaluationMode;
+    }
+
+    public RowPatternFunction setEvaluationMode(EvaluationMode mode) {
+        evaluationMode = mode;
+        return this;
+    }
+
+    public Function getFunction() {
+        return function;
+    }
+
+    public RowPatternFunction setFunction(Function function) {
+        this.function = function;
+        return this;
+    }
+
+    @Override
+    public <T, S> T accept(ExpressionVisitor<T> visitor, S context) {
+        return visitor.visit(this, context);
+    }
+
+    public StringBuilder appendTo(StringBuilder builder, Consumer<Expression> expressions) {
+        builder.append(evaluationMode).append(' ');
+        expressions.accept(function);
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        return appendTo(builder, expression -> builder.append(expression)).toString();
+    }
+}

src/main/java/net/sf/jsqlparser/expression/StructType.java

@@ -16,6 +16,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Consumer;
 
 /*
  * STRUCT<T>
@@ -113,6 +114,11 @@ public StructType add(Expression expression, String aliasName) {
     }
 
     public StringBuilder appendTo(StringBuilder builder) {
+        return appendTo(builder, expression -> builder.append(expression));
+    }
+
+    /** Renders current argument expressions through the caller's visitor. */
+    public StringBuilder appendTo(StringBuilder builder, Consumer<Expression> expressions) {
         if (dialect != Dialect.DUCKDB && keyword != null) {
             builder.append(keyword);
         }
@@ -148,7 +154,7 @@ public StringBuilder appendTo(StringBuilder builder) {
                     }
                     builder.append(e.getAlias().getName());
                     builder.append(":");
-                    builder.append(e.getExpression());
+                    expressions.accept(e.getExpression());
                 }
                 builder.append(" }");
             } else {
@@ -158,7 +164,10 @@ public StringBuilder appendTo(StringBuilder builder) {
                     if (0 < i++) {
                         builder.append(",");
                     }
-                    e.appendTo(builder);
+                    expressions.accept(e.getExpression());
+                    if (e.getAlias() != null) {
+                        builder.append(e.getAlias());
+                    }
                 }
 
                 builder.append(")");

src/main/java/net/sf/jsqlparser/parser/RowPatternTokenContext.java

@@ -0,0 +1,83 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2026 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.parser;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * Recognizes the BigQuery PATTERN lexical region even during JavaCC lookahead. The required initial
+ * ORDER BY (or optional PARTITION BY) distinguishes a clause from an ordinary function named
+ * MATCH_RECOGNIZE. Quoted tokens never change this state.
+ */
+final class RowPatternTokenContext implements CCJSqlParserConstants {
+    private final Deque<Frame> frames = new ArrayDeque<>();
+    private int depth;
+    private boolean pendingClause;
+
+    private static final class Frame {
+        private final int depth;
+        private int phase;
+        private int patternDepth = -1;
+        private boolean pendingPattern;
+        private boolean patternComplete;
+
+        private Frame(int depth) {
+            this.depth = depth;
+        }
+    }
+
+    boolean isIdle() {
+        return frames.isEmpty() && !pendingClause;
+    }
+
+    boolean isInPattern() {
+        return !frames.isEmpty() && frames.peek().patternDepth >= 0;
+    }
+
+    void accept(Token token) {
+        if (token.kind == OPENING_BRACKET) {
+            depth++;
+            if (pendingClause) {
+                frames.push(new Frame(depth));
+                pendingClause = false;
+                return;
+            }
+            if (!frames.isEmpty() && frames.peek().pendingPattern) {
+                frames.peek().patternDepth = depth;
+                frames.peek().pendingPattern = false;
+            }
+        } else if (token.kind == CLOSING_BRACKET) {
+            if (!frames.isEmpty()) {
+                Frame frame = frames.peek();
+                if (frame.patternDepth == depth) {
+                    frame.patternDepth = -1;
+                    frame.patternComplete = true;
+                }
+                if (frame.depth == depth) {
+                    frames.pop();
+                }
+            }
+            depth--;
+        } else if (!frames.isEmpty() && depth == frames.peek().depth) {
+            Frame frame = frames.peek();
+            if (frame.phase == 0) {
+                frame.phase = token.kind == K_ORDER || token.kind == K_PARTITION ? 1 : -1;
+            } else if (frame.phase == 1) {
+                frame.phase = token.kind == K_BY ? 2 : -1;
+            } else if (frame.phase == 2 && !frame.patternComplete) {
+                frame.pendingPattern = token.kind == S_IDENTIFIER
+                        && "PATTERN".equalsIgnoreCase(token.image);
+            }
+        }
+        pendingClause = token.kind == S_IDENTIFIER
+                && "MATCH_RECOGNIZE".equalsIgnoreCase(token.image);
+    }
+}

src/main/java/net/sf/jsqlparser/parser/feature/Feature.java

@@ -71,6 +71,10 @@ public enum Feature {
      * "SELECT"
      */
     select,
+    /** Structured FROM row pattern recognition. */
+    matchRecognize,
+    /** BigQuery longest-match option. */
+    matchRecognizeOptions,
     /**
      * "GROUP BY"
      */

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

@@ -42,6 +42,18 @@ default <S> T visitJoins(Collection<Join> joins, S context) {
         return null;
     }
 
+    /**
+     * Existing visitors continue through the input relation; adapters also visit clause
+     * expressions.
+     */
+    default <S> T visit(MatchRecognize matchRecognize, S context) {
+        return matchRecognize.getInput().accept(this, context);
+    }
+
+    default void visit(MatchRecognize matchRecognize) {
+        visit(matchRecognize, null);
+    }
+
     <S> T visit(Table tableName, S context);
 
     default void visit(Table tableName) {

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

@@ -85,19 +85,34 @@ public <S> T visitJoins(Collection<Join> joins, S context) {
         return null;
     }
 
+    @Override
+    public <S> T visit(MatchRecognize matchRecognize, S context) {
+        matchRecognize.getInput().accept(this, context);
+        matchRecognize
+                .forEachExpression(expression -> expression.accept(expressionVisitor, context));
+        PivotVisitorAdapter<T> pivots = new PivotVisitorAdapter<>(expressionVisitor);
+        if (matchRecognize.getPivot() != null) {
+            matchRecognize.getPivot().accept(pivots, context);
+        }
+        if (matchRecognize.getUnPivot() != null) {
+            matchRecognize.getUnPivot().accept(pivots, context);
+        }
+        return null;
+    }
+
     @Override
     public <S> T visit(Table table, S context) {
         return null;
     }
 
     @Override
     public <S> T visit(ParenthesedSelect select, S context) {
-        return select.getPlainSelect().accept(selectVisitor, context);
+        return select.getSelect().accept(selectVisitor, context);
     }
 
     @Override
     public <S> T visit(LateralSubSelect lateralSubSelect, S context) {
-        return lateralSubSelect.getPlainSelect().accept(selectVisitor, context);
+        return lateralSubSelect.getSelect().accept(selectVisitor, context);
     }
 
     @Override
@@ -108,7 +123,9 @@ public <S> T visit(TableFunction tableFunction, S context) {
 
     @Override
     public <S> T visit(ParenthesedFromItem fromItem, S context) {
-        return fromItem.getFromItem().accept(this, context);
+        T result = fromItem.getFromItem().accept(this, context);
+        visitJoins(fromItem.getJoins(), context);
+        return result;
     }
 
     @Override