Merge branch 'master' of github.com:JSQLParser/JSqlParser

Author: manticore-projects

README.md

@@ -147,7 +147,11 @@ and missing syntax gets added on demand — [open an issue](https://github.com/J
 | **DDL** | `CREATE …` · `ALTER …` · `DROP …` |
 | **Oracle vector types** | `VECTOR(*, *)` · `VECTOR(*, FLOAT32)` · `VECTOR(3, *)`, including dense and sparse storage formats |
 | **PostgreSQL ownership** | `DROP OWNED` · `REASSIGN OWNED` |
-| **MySQL table maintenance** | `ANALYZE` · `CHECK` · `OPTIMIZE` · `REPAIR TABLE` |
+| **Two-phase commit** | PostgreSQL `PREPARE TRANSACTION` · `COMMIT PREPARED` · `ROLLBACK PREPARED` · MySQL `XA START`/`END`/`PREPARE`/`COMMIT`/`ROLLBACK`/`RECOVER` |
+| **MySQL table maintenance** | `ANALYZE` · `CHECK` · `CHECKSUM` · `OPTIMIZE` · `REPAIR TABLE` |
+| **PostgreSQL maintenance** | `VACUUM` · `ANALYZE` · `CLUSTER` · `CHECKPOINT` |
+| **MySQL locks** | `LOCK TABLES` · `UNLOCK TABLES` · `LOCK INSTANCE FOR BACKUP` · `UNLOCK INSTANCE` |
+| **PostgreSQL session statements** | `DISCARD` · `LISTEN` · `UNLISTEN` · `SHOW`/`RESET TIME ZONE`/`TRANSACTION ISOLATION LEVEL`/`SESSION AUTHORIZATION` · `COPY` options from before 9.0 |
 | **MySQL account management** | `CREATE`/`ALTER`/`RENAME USER` · `CREATE ROLE` · `SET ROLE` · `SET DEFAULT ROLE` · `SET PASSWORD` |
 | **Tablespaces** | MySQL and PostgreSQL `CREATE TABLESPACE` · `ALTER TABLESPACE` |
 | **PostgreSQL RLS** | `CREATE POLICY` · `ALTER TABLE … ENABLE`/`DISABLE`/`FORCE`/`NO FORCE ROW LEVEL SECURITY` |

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

@@ -17,6 +17,7 @@
 import net.sf.jsqlparser.statement.select.Limit;
 import net.sf.jsqlparser.statement.select.OrderByElement;
 
+import net.sf.jsqlparser.statement.create.table.ColDataType;
 import net.sf.jsqlparser.statement.create.table.ColumnDefinition;
 import net.sf.jsqlparser.statement.select.PlainSelect;
 
@@ -59,6 +60,12 @@ public class Function extends ASTNodeAccessImpl implements Expression {
      */
     private List<KeywordArgument> keywordArguments = null;
 
+    /**
+     * The {@code AS type} cast of the argument, as in MySQL's {@code WEIGHT_STRING(str AS CHAR(3))}
+     * or {@code WEIGHT_STRING(str AS BINARY(4))}.
+     */
+    private ColDataType castType;
+
     /** Column definitions supplied for a record-returning function inside ROWS FROM. */
     public List<ColumnDefinition> getResultColumnDefinitions() {
         return resultColumnDefinitions;
@@ -83,6 +90,31 @@ public Function(String name, Expression... parameters) {
         this.parameters = new ExpressionList<>(parameters);
     }
 
+    /**
+     * Returns the {@code AS type} cast written after the argument, as in MySQL's
+     * {@code WEIGHT_STRING(str AS CHAR(3))}, or {@code null}.
+     */
+    public ColDataType getCastType() {
+        return castType;
+    }
+
+    public void setCastType(ColDataType castType) {
+        this.castType = castType;
+    }
+
+    public Function withCastType(ColDataType castType) {
+        setCastType(castType);
+        return this;
+    }
+
+    /** Appends {@code " AS type"} when the argument has a {@link #getCastType() cast type}. */
+    public StringBuilder appendCastTypeTo(StringBuilder builder) {
+        if (castType != null) {
+            builder.append(" AS ").append(castType);
+        }
+        return builder;
+    }
+
     @Override
     public <T, S> T accept(ExpressionVisitor<T> expressionVisitor, S context) {
         return expressionVisitor.visit(this, context);
@@ -385,6 +417,7 @@ public String toString() {
                 }
 
                 b.append(parameters);
+                appendCastTypeTo(b);
 
                 if (havingClause != null) {
                     havingClause.appendTo(b);

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

@@ -12,15 +12,35 @@
 import java.io.Serializable;
 import java.util.List;
 
+/**
+ * A MySQL index hint after a table reference:
+ * {@code {USE|IGNORE|FORCE} {INDEX|KEY} [FOR {JOIN|ORDER BY|GROUP BY}] (index_list)}.
+ * <p>
+ * A table may carry several hints, see {@code Table.getIndexHints()}. {@code USE INDEX ()} has an
+ * empty index list.
+ */
 public class MySQLIndexHint implements Serializable {
 
     private final String action;
     private final String indexQualifier;
+    private final Scope scope;
     private final List<String> indexNames;
 
     public MySQLIndexHint(String action, String indexQualifier, List<String> indexNames) {
+        this(action, indexQualifier, null, indexNames);
+    }
+
+    /**
+     * @param action {@code USE}, {@code IGNORE} or {@code FORCE}
+     * @param indexQualifier {@code INDEX} or {@code KEY}
+     * @param scope the {@code FOR JOIN|ORDER BY|GROUP BY} scope, or {@code null} for every use
+     * @param indexNames the index names, empty for {@code USE INDEX ()}
+     */
+    public MySQLIndexHint(String action, String indexQualifier, Scope scope,
+            List<String> indexNames) {
         this.action = action;
         this.indexQualifier = indexQualifier;
+        this.scope = scope;
         this.indexNames = indexNames;
     }
 
@@ -32,22 +52,53 @@ public String getIndexQualifier() {
         return indexQualifier;
     }
 
+    /**
+     * Returns the part of the query the hint applies to, or {@code null} when no {@code FOR} clause
+     * was given.
+     */
+    public Scope getScope() {
+        return scope;
+    }
+
     public List<String> getIndexNames() {
         return indexNames;
     }
 
-    @Override
-    public String toString() {
-        // use|ignore|force key|index (index1,...,indexN)
-        StringBuilder buffer = new StringBuilder();
-        buffer.append(" ").append(action).append(" ").append(indexQualifier).append(" (");
+    /** Appends {@code " USE INDEX [FOR scope] (i1,i2)"}, with a leading space. */
+    public StringBuilder appendTo(StringBuilder builder) {
+        // use|ignore|force key|index [for join|order by|group by] (index1,...,indexN)
+        builder.append(" ").append(action).append(" ").append(indexQualifier);
+        if (scope != null) {
+            builder.append(" FOR ").append(scope.getKeywords());
+        }
+        builder.append(" (");
         for (int i = 0; i < indexNames.size(); i++) {
             if (i > 0) {
-                buffer.append(",");
+                builder.append(",");
             }
-            buffer.append(indexNames.get(i));
+            builder.append(indexNames.get(i));
+        }
+        return builder.append(")");
+    }
+
+    @Override
+    public String toString() {
+        return appendTo(new StringBuilder()).toString();
+    }
+
+    /** The {@code FOR} clause of an index hint. */
+    public enum Scope {
+        JOIN("JOIN"), ORDER_BY("ORDER BY"), GROUP_BY("GROUP BY");
+
+        private final String keywords;
+
+        Scope(String keywords) {
+            this.keywords = keywords;
+        }
+
+        /** Returns the keywords after {@code FOR}, for example {@code ORDER BY}. */
+        public String getKeywords() {
+            return keywords;
         }
-        buffer.append(")");
-        return buffer.toString();
     }
 }

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

@@ -71,22 +71,20 @@ public StringBuilder appendTo(StringBuilder builder) {
         return builder;
     }
 
+    /**
+     * The nearest enclosing object in the tree, or null when there is none. A node that carries
+     * only a token range, for an object no grammar rule opens a tree node for, has no parent.
+     */
     public ASTNodeAccess getParent() {
-        Node parent = (Node) node.jjtGetParent();
-        while (parent.jjtGetValue() == null) {
-            parent = (Node) parent.jjtGetParent();
-        }
-
-        return ASTNodeAccess.class.cast(parent.jjtGetValue());
+        return getParent(ASTNodeAccess.class);
     }
 
     public <T extends ASTNodeAccess> T getParent(Class<T> clazz) {
-        Node parent = (Node) node.jjtGetParent();
-        while (parent.jjtGetValue() == null || !clazz.isInstance(parent.jjtGetValue())) {
+        Node parent = node == null ? null : (Node) node.jjtGetParent();
+        while (parent != null && !clazz.isInstance(parent.jjtGetValue())) {
             parent = (Node) parent.jjtGetParent();
         }
-
-        return clazz.cast(parent.jjtGetValue());
+        return parent == null ? null : clazz.cast(parent.jjtGetValue());
     }
 
     @Override

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

@@ -0,0 +1,71 @@
+/*-
+ * #%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;
+
+/**
+ * A node outside the parse tree that records the tokens an object spans. It serves an object no
+ * grammar rule opens a tree node for, or one whose text runs past its tree node. In that second
+ * case it stands in for the tree node, answering its parent, children and id, with the wider range.
+ */
+final class RangeNode extends Node {
+    private final Node treeNode;
+
+    RangeNode(Token first, Token last, Node treeNode) {
+        super(CCJSqlParserTreeConstants.JJTEXPRESSION);
+        this.treeNode = treeNode;
+        jjtSetFirstToken(first);
+        jjtSetLastToken(last);
+    }
+
+    @Override
+    public Node jjtGetParent() {
+        return treeNode == null ? null : treeNode.jjtGetParent();
+    }
+
+    @Override
+    public Node[] jjtGetChildren() {
+        return treeNode == null ? super.jjtGetChildren() : treeNode.jjtGetChildren();
+    }
+
+    @Override
+    public Node jjtGetChild(int i) {
+        return treeNode == null ? super.jjtGetChild(i) : treeNode.jjtGetChild(i);
+    }
+
+    @Override
+    public int jjtGetNumChildren() {
+        return treeNode == null ? super.jjtGetNumChildren() : treeNode.jjtGetNumChildren();
+    }
+
+    @Override
+    public Object childrenAccept(CCJSqlParserVisitor visitor, Object data) {
+        return treeNode == null ? super.childrenAccept(visitor, data)
+                : treeNode.childrenAccept(visitor, data);
+    }
+
+    @Override
+    public int getId() {
+        return treeNode == null ? super.getId() : treeNode.getId();
+    }
+
+    @Override
+    public String toString() {
+        return treeNode == null ? super.toString() : treeNode.toString();
+    }
+
+    @Override
+    public void dump(String prefix) {
+        if (treeNode == null) {
+            super.dump(prefix);
+        } else {
+            treeNode.dump(prefix);
+        }
+    }
+}

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

@@ -48,6 +48,9 @@ public class SimpleCharStream {
     protected boolean trackLineColumn = true;
     protected int totalCharsRead = 0;
     protected int absoluteTokenBegin = 0;
+    // line, column and absolute position of each match begun since the last positionSpecialTokens()
+    private int[] matchBegins = new int[24];
+    private int matchBeginCount = 0;
     int bufsize;
     int available;
     int tokenBegin;
@@ -107,6 +110,38 @@ public final int getAbsoluteTokenBegin() {
         return absoluteTokenBegin;
     }
 
+    /**
+     * Gives the comments in front of {@code token} the positions where their matches began, from
+     * the begins recorded since the last call, and forgets those. Comments come through no token
+     * action, so this is how they get a position. The comments chain backwards from the token while
+     * the begins are recorded forwards, so one backwards pass pairs them.
+     */
+    public final void positionSpecialTokens(Token token) {
+        int i = matchBeginCount - 3;
+        for (Token comment = token.specialToken; comment != null; comment = comment.specialToken) {
+            while (i >= 0 && (matchBegins[i] != comment.beginLine
+                    || matchBegins[i + 1] != comment.beginColumn)) {
+                i -= 3;
+            }
+            if (i < 0) {
+                break;
+            }
+            comment.absoluteBegin = matchBegins[i + 2];
+            comment.absoluteEnd = comment.absoluteBegin + comment.image.length();
+            i -= 3;
+        }
+        matchBeginCount = 0;
+    }
+
+    private void recordMatchBegin() {
+        if (matchBeginCount + 3 > matchBegins.length) {
+            matchBegins = java.util.Arrays.copyOf(matchBegins, matchBegins.length * 2);
+        }
+        matchBegins[matchBeginCount++] = getBeginLine();
+        matchBegins[matchBeginCount++] = getBeginColumn();
+        matchBegins[matchBeginCount++] = absoluteTokenBegin;
+    }
+
     protected void ExpandBuff(boolean wrapAround) {
         final int newSize = bufsize * 2;
         char[] newbuffer = new char[newSize];
@@ -200,6 +235,7 @@ public final char BeginToken() throws java.io.IOException {
         tokenBegin = bufpos;
 
         absoluteTokenBegin = totalCharsRead;
+        recordMatchBegin();
 
         if (c == '#' && featureConfiguration != null
                 && featureConfiguration.getAsBoolean(Feature.allowHashLineComments)) {
@@ -441,6 +477,7 @@ public final void backup(int amount) {
      * Reinitialise.
      */
     public void ReInit(Provider dstream, int startline, int startcolumn, int buffersize) {
+        matchBeginCount = 0;
         inputStream = dstream;
         line = startline;
         column = startcolumn - 1;