fix: preserve unbounded partition markers during expression rewrites

Author: minleejae

src/main/java/net/sf/jsqlparser/statement/create/table/PartitionBound.java

@@ -12,6 +12,7 @@
 import java.io.Serializable;
 import java.util.function.Consumer;
 import net.sf.jsqlparser.expression.Expression;
+import net.sf.jsqlparser.schema.Column;
 import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 
 /** A PostgreSQL declarative-partition bound. */
@@ -123,9 +124,9 @@ public void appendTo(StringBuilder sql, Consumer<Expression> expressionPrinter)
         switch (type) {
             case RANGE:
                 sql.append("FOR VALUES FROM (");
-                expressionPrinter.accept(fromExpressions);
+                appendRangeValues(sql, fromExpressions, expressionPrinter);
                 sql.append(") TO (");
-                expressionPrinter.accept(toExpressions);
+                appendRangeValues(sql, toExpressions, expressionPrinter);
                 sql.append(')');
                 break;
             case LIST:
@@ -147,4 +148,68 @@ public void appendTo(StringBuilder sql, Consumer<Expression> expressionPrinter)
                 break;
         }
     }
+
+    /** Visits active bound expressions, excluding the MINVALUE/MAXVALUE range markers. */
+    public void visitExpressions(Consumer<Expression> expressions) {
+        if (type == null) {
+            return;
+        }
+        switch (type) {
+            case RANGE:
+                visitRangeValues(fromExpressions, expressions);
+                visitRangeValues(toExpressions, expressions);
+                break;
+            case LIST:
+                if (inExpressions != null) {
+                    expressions.accept(inExpressions);
+                }
+                break;
+            case HASH:
+                if (modulus != null) {
+                    expressions.accept(modulus);
+                }
+                if (remainder != null) {
+                    expressions.accept(remainder);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    private static void visitRangeValues(ExpressionList<Expression> values,
+            Consumer<Expression> expressions) {
+        if (values != null) {
+            values.stream().filter(value -> !isRangeMarker(value)).forEach(expressions);
+        }
+    }
+
+    private static void appendRangeValues(StringBuilder sql, ExpressionList<Expression> values,
+            Consumer<Expression> expressions) {
+        if (values == null) {
+            sql.append("null");
+            return;
+        }
+        for (int i = 0; i < values.size(); i++) {
+            if (i > 0) {
+                sql.append(", ");
+            }
+            Expression value = values.get(i);
+            if (isRangeMarker(value)) {
+                sql.append(value);
+            } else {
+                expressions.accept(value);
+            }
+        }
+    }
+
+    private static boolean isRangeMarker(Expression expression) {
+        if (!(expression instanceof Column)) {
+            return false;
+        }
+        Column column = (Column) expression;
+        return column.getTable() == null && ("MINVALUE".equalsIgnoreCase(column.getColumnName())
+                || "MAXVALUE".equalsIgnoreCase(column.getColumnName()));
+    }
+
 }

src/main/java/net/sf/jsqlparser/util/TableDefinitionTraversal.java

@@ -116,23 +116,8 @@ public static void visit(TablePartitioning partitioning, Consumer<Expression> ex
 
     /** Visits expressions belonging to the selected PostgreSQL bound type. */
     public static void visit(PartitionBound bound, Consumer<Expression> expressions) {
-        if (bound == null || bound.getType() == null) {
-            return;
-        }
-        switch (bound.getType()) {
-            case RANGE:
-                accept(bound.getFromExpressions(), expressions);
-                accept(bound.getToExpressions(), expressions);
-                break;
-            case LIST:
-                accept(bound.getInExpressions(), expressions);
-                break;
-            case HASH:
-                accept(bound.getModulus(), expressions);
-                accept(bound.getRemainder(), expressions);
-                break;
-            default:
-                break;
+        if (bound != null) {
+            bound.visitExpressions(expressions);
         }
     }
 

src/test/java/net/sf/jsqlparser/statement/create/PartitionTraversalTest.java

@@ -71,11 +71,29 @@ public <S> Void visit(LongValue value, S context) {
         assertThat(visited).containsExactly("id", "id", "1", "0", "10");
     }
 
+    @Test
+    void rangeMarkersAreNotVisitedAsColumnReferences() throws JSQLParserException {
+        List<String> columns = new ArrayList<>();
+        ExpressionVisitorAdapter<Void> expressions = new ExpressionVisitorAdapter<Void>() {
+            @Override
+            public <S> Void visit(Column column, S context) {
+                columns.add(column.getColumnName());
+                return null;
+            }
+        };
+        CCJSqlParserUtil.parse("ALTER TABLE parent ATTACH PARTITION child "
+                + "FOR VALUES FROM (MINVALUE) TO (MAXVALUE)")
+                .accept(new StatementVisitorAdapter<>(new SelectVisitorAdapter<>(expressions)),
+                        null);
+        assertThat(columns).isEmpty();
+    }
+
     @ParameterizedTest
     @ValueSource(strings = {
             "CREATE TABLE t (id INT) PARTITION BY HASH (id + 1) PARTITIONS 2",
             "ALTER TABLE t PARTITION BY RANGE COLUMNS (id)",
             "CREATE TABLE child PARTITION OF parent FOR VALUES FROM (0) TO (10)",
+            "CREATE TABLE child PARTITION OF parent FOR VALUES FROM (MINVALUE) TO (MAXVALUE)",
             "ALTER TABLE parent ATTACH PARTITION child FOR VALUES IN (1, 2)",
             "ALTER TABLE parent ATTACH PARTITION child FOR VALUES WITH (MODULUS 4, REMAINDER 1)",
             "ALTER TABLE parent ATTACH PARTITION child DEFAULT"