DuckDB: support LIMIT 10% and TABLESAMPLE without a method

- `LIMIT 10%` and `LIMIT 10 PERCENT` set the new `Limit.percentUnit`.
  Inside a LIMIT, a `%` followed by the end of the clause is the unit,
  not a modulo; `LIMIT 10 % 3` and `LIMIT a % offset` are unchanged.
- TABLESAMPLE takes DuckDB's optional method and reservoir, as USING
  SAMPLE already does: `TABLESAMPLE 10%`, `TABLESAMPLE reservoir(10 ROWS)`.
- A table function keeps and prints its sample clause: `range(10) r
  USING SAMPLE 10%` used to lose it.

Author: guizmaii

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

@@ -32,6 +32,8 @@ public class Limit extends ASTNodeAccessImpl {
      */
     private ExpressionList<Expression> byExpressions;
 
+    private String percentUnit;
+
     public Expression getOffset() {
         return offset;
     }
@@ -72,6 +74,26 @@ public void setLimitNull(boolean b) {
         }
     }
 
+    /**
+     * DuckDB's {@code %} or {@code PERCENT} after the row count, which then is a percentage of the
+     * rows, or {@code null}.
+     */
+    public String getPercentUnit() {
+        return percentUnit;
+    }
+
+    public Limit setPercentUnit(String percentUnit) {
+        this.percentUnit = percentUnit;
+        return this;
+    }
+
+    String percentUnitToString() {
+        if (percentUnit == null) {
+            return "";
+        }
+        return "%".equals(percentUnit) ? "%" : " " + percentUnit;
+    }
+
     @Override
     public String toString() {
         String retVal = " LIMIT ";
@@ -84,7 +106,7 @@ public String toString() {
                 retVal += offset + ", ";
             }
             if (null != rowCount) {
-                retVal += rowCount;
+                retVal += rowCount + percentUnitToString();
             }
         }
 

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

@@ -18,6 +18,8 @@
 
 @SuppressWarnings({"PMD.UncommentedEmptyMethodBody"})
 public class TableFunction extends Function implements FromItem {
+    private SampleClause sampleClause;
+
     private String prefix = null;
     private Alias alias = null;
     private Pivot pivot = null;
@@ -220,12 +222,13 @@ public TableFunction withUnPivot(UnPivot unpivot) {
 
     @Override
     public SampleClause getSampleClause() {
-        return null;
+        return sampleClause;
     }
 
     @Override
-    public FromItem setSampleClause(SampleClause sampleClause) {
-        return null;
+    public TableFunction setSampleClause(SampleClause sampleClause) {
+        this.sampleClause = sampleClause;
+        return this;
     }
 
     public StringBuilder appendTo(StringBuilder builder) {
@@ -263,6 +266,9 @@ public StringBuilder appendTo(StringBuilder builder, Consumer<Expression> expres
                 builder.append(offsetAlias);
             }
         }
+        if (sampleClause != null) {
+            sampleClause.appendTo(builder);
+        }
         return builder;
     }
 

src/main/java/net/sf/jsqlparser/util/deparser/LimitDeparser.java

@@ -40,6 +40,10 @@ public <S> void deParse(Limit limit, S context) {
 
                 if (null != limit.getRowCount()) {
                     limit.getRowCount().accept(expressionVisitor, context);
+                    if (limit.getPercentUnit() != null) {
+                        builder.append("%".equals(limit.getPercentUnit()) ? "%"
+                                : " " + limit.getPercentUnit());
+                    }
                 }
             }
         }

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

@@ -687,6 +687,8 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
             else {
                 // Handle unnamed tokens by image
                 String img = t.image;
+                // DuckDB's LIMIT 10%: the % ends the row count instead of starting a modulo
+                if ("%".equals(img) && limitRowCountDepth > 0 && isLimitPercentEndAt(2)) break;
                 if      ("*".equals(img) || "%".equals(img))                  prec = 6;
                 else if ("+".equals(img) || "-".equals(img) || "&".equals(img)) prec = 5;
                 else break; // not an arithmetic operator
@@ -1531,6 +1533,24 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
     }
 
     /** DuckDB sampling methods, which are ordinary identifiers except for SYSTEM/BERNOULLI. */
+    // depth of LIMIT row counts, where a % before the end of the clause is DuckDB's percent unit
+    private int limitRowCountDepth = 0;
+
+    /** Whether the token at {@code index} ends a LIMIT clause, after DuckDB's LIMIT 10%. */
+    private boolean isLimitPercentEndAt(int index) {
+        switch (getToken(index).kind) {
+            case EOF: case ST_SEMICOLON: case CLOSING_BRACKET:
+            case K_UNION: case K_EXCEPT: case K_INTERSECT: case K_MINUS:
+                return true;
+            case K_OFFSET: case K_FETCH:
+                // not a column named offset: LIMIT a % offset
+                int next = getToken(index + 1).kind;
+                return next != EOF && next != ST_SEMICOLON && next != CLOSING_BRACKET;
+            default:
+                return false;
+        }
+    }
+
     private boolean isSampleMethod(Token token) {
         return token.kind == K_SYSTEM || token.kind == K_BERNOULLI
                 || (token.image != null && "RESERVOIR".equalsIgnoreCase(token.image));
@@ -7146,9 +7166,13 @@ SampleClause SampleClause():
         )
         |
         (
-            // SQL:2016 compliant
+            // SQL:2016 compliant; DuckDB: the method is optional and may be reservoir
             token = <K_TABLESAMPLE> { keyword = token.image; }
-            ( token = <K_SYSTEM> | token = <K_BERNOULLI> ) { method = token.image; }
+            [
+                LOOKAHEAD({ isSampleMethod(getToken(1)) })
+                ( token = <K_SYSTEM> | token = <K_BERNOULLI> | token = <S_IDENTIFIER> )
+                { method = token.image; }
+            ]
         )
         |
         (
@@ -10311,11 +10335,16 @@ Limit LimitWithOffset() #LimitWithOffset:
 }
 {
     <K_LIMIT>
-    (
-        LOOKAHEAD(3) firstExpression = ParenthesedSelect()
-        |
-        firstExpression = Expression()
-    )
+    try {
+        { limitRowCountDepth++; }
+        (
+            LOOKAHEAD(3) firstExpression = ParenthesedSelect()
+            |
+            firstExpression = Expression()
+        )
+    } finally {
+        limitRowCountDepth--;
+    }
     (
         // MySQL: LIMIT offset, row_count
         ","
@@ -10325,10 +10354,15 @@ Limit LimitWithOffset() #LimitWithOffset:
             limit.setRowCount(secondExpression);
         }
         |
-        // PostgreSQL: LIMIT row_count
+        // PostgreSQL: LIMIT row_count; DuckDB: LIMIT 10% or LIMIT 10 PERCENT
         {
             limit.setRowCount(firstExpression);
         }
+        [
+            LOOKAHEAD({ getToken(1).kind == K_PERCENT
+                    || "%".equals(getToken(1).image) && isLimitPercentEndAt(2) })
+            ( "%" { limit.setPercentUnit("%"); } | <K_PERCENT> { limit.setPercentUnit("PERCENT"); } )
+        ]
     )
     {
         linkAST(limit, jjtThis);

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

@@ -865,4 +865,31 @@ void testTableQueryKeepsTableColumnsAndTrailingClauses() throws JSQLParserExcept
         Assertions.assertInstanceOf(net.sf.jsqlparser.statement.piped.FromQuery.class,
                 ((ParenthesedSelect) CCJSqlParserUtil.parse("(FROM t)")).getSelect());
     }
+
+    @Test
+    void testLimitPercent() throws JSQLParserException {
+        for (String sqlStr : new String[] {"SELECT a FROM t LIMIT 10%",
+                "SELECT a FROM t LIMIT 10.5%", "SELECT a FROM t LIMIT 40 PERCENT",
+                "SELECT a FROM t LIMIT 50% OFFSET 2", "SELECT a FROM t LIMIT (SELECT 10)%",
+                "SELECT * FROM (SELECT a FROM t LIMIT 10%) x",
+                // modulo and a column named offset are unchanged
+                "SELECT a FROM t LIMIT 10 % 3", "SELECT a FROM t LIMIT a % offset"}) {
+            TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        }
+        PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse("SELECT a FROM t LIMIT 10%");
+        Assertions.assertEquals("%", select.getLimit().getPercentUnit());
+        Assertions.assertEquals("10", select.getLimit().getRowCount().toString());
+    }
+
+    @Test
+    void testTableSampleWithoutOrWithReservoirMethod() throws JSQLParserException {
+        for (String sqlStr : new String[] {"SELECT a FROM t TABLESAMPLE 10%",
+                "SELECT a FROM t TABLESAMPLE 10 ROWS", "SELECT a FROM t t1 TABLESAMPLE 10 PERCENT",
+                "SELECT a FROM t TABLESAMPLE RESERVOIR (10 ROWS) REPEATABLE (1)",
+                "SELECT a FROM (SELECT 1) TABLESAMPLE 10%",
+                "SELECT a FROM read_csv('x') TABLESAMPLE 10%",
+                "SELECT a FROM range(10) r USING SAMPLE 10%"}) {
+            TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        }
+    }
 }