Merge upstream master and preserve table override lookahead

Signed-off-by: minleejae <mmj9808@gmail.com>

Author: minleejae

src/main/java/net/sf/jsqlparser/statement/alter/AlterExpressionTableOption.java

@@ -9,16 +9,61 @@
  */
 package net.sf.jsqlparser.statement.alter;
 
+import net.sf.jsqlparser.statement.create.table.TableOption;
+
 /**
  * Internal subclass for table-level option operations within ALTER TABLE. Handles ENGINE,
  * ALGORITHM, LOCK, KEY_BLOCK_SIZE, COMMENT, ENCRYPTION, AUTO_INCREMENT (SET_TABLE_OPTION),
  * DISCARD/IMPORT TABLESPACE, DISABLE/ENABLE KEYS.
  */
 public class AlterExpressionTableOption extends AlterExpression {
 
+    private TableOption structuredTableOption;
+
+    public TableOption getStructuredTableOption() {
+        return structuredTableOption;
+    }
+
+    /** Uses the same option model as CREATE TABLE, with legacy getters as live projections. */
+    public void setStructuredTableOption(TableOption option) {
+        structuredTableOption = option;
+        setOperation(AlterOperation.SET_TABLE_OPTION);
+        super.setTableOption(null);
+        super.setUseEqual(false);
+    }
+
+    @Override
+    public String getTableOption() {
+        return structuredTableOption == null ? super.getTableOption()
+                : structuredTableOption.toString();
+    }
+
+    @Override
+    public void setTableOption(String option) {
+        structuredTableOption = null;
+        super.setTableOption(option);
+    }
+
+    @Override
+    public boolean getUseEqual() {
+        return structuredTableOption == null ? super.getUseEqual()
+                : structuredTableOption.isUseEquals();
+    }
+
+    @Override
+    public void setUseEqual(boolean useEqual) {
+        if (structuredTableOption != null) {
+            structuredTableOption.setUseEquals(useEqual);
+        }
+        super.setUseEqual(useEqual);
+    }
+
     @Override
     protected void appendBody(StringBuilder b) {
         switch (getOperation()) {
+            case SET_TABLE_OPTION:
+                b.append(getTableOption());
+                break;
             case COMMENT:
                 b.append("COMMENT ");
                 b.append(getCommentText());

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

@@ -22,8 +22,6 @@ public class CheckConstraint extends NamedConstraint {
 
     private Expression expression;
 
-    private Boolean enforced;
-
     private boolean noInherit;
 
     public CheckConstraint() {
@@ -61,11 +59,19 @@ public CheckConstraint withNoInherit(boolean noInherit) {
     }
 
     public Boolean getEnforced() {
-        return enforced;
+        return getConstraintAttributes() == null ? null : getConstraintAttributes().getEnforced();
     }
 
     public void setEnforced(Boolean enforced) {
-        this.enforced = enforced;
+        ConstraintAttributes attributes = getConstraintAttributes();
+        if (attributes == null) {
+            if (enforced == null) {
+                return;
+            }
+            attributes = new ConstraintAttributes();
+            setConstraintAttributes(attributes);
+        }
+        attributes.setEnforced(enforced);
     }
 
     @Override
@@ -81,9 +87,6 @@ public void appendTo(StringBuilder b, Consumer<Expression> expressionPrinter) {
         if (noInherit) {
             b.append(" NO INHERIT");
         }
-        if (enforced != null) {
-            b.append(enforced ? " ENFORCED" : " NOT ENFORCED");
-        }
         appendConstraintSuffixTo(b);
         appendConstraintAttributesTo(b);
     }

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

@@ -20,6 +20,7 @@ public enum Initially {
     private Boolean deferrable;
     private Initially initially;
     private boolean notValid;
+    private Boolean enforced;
 
     public Boolean getDeferrable() {
         return deferrable;
@@ -45,13 +46,25 @@ public void setNotValid(boolean notValid) {
         this.notValid = notValid;
     }
 
+    /** Null preserves an omitted ENFORCED clause. */
+    public Boolean getEnforced() {
+        return enforced;
+    }
+
+    public void setEnforced(Boolean enforced) {
+        this.enforced = enforced;
+    }
+
     public void appendTo(StringBuilder sql) {
         if (deferrable != null) {
             sql.append(deferrable ? " DEFERRABLE" : " NOT DEFERRABLE");
         }
         if (initially != null) {
             sql.append(" INITIALLY ").append(initially);
         }
+        if (enforced != null) {
+            sql.append(enforced ? " ENFORCED" : " NOT ENFORCED");
+        }
         if (notValid) {
             sql.append(" NOT VALID");
         }

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

@@ -38,6 +38,7 @@ public class CreateTable implements Statement {
     private DuplicateHandling duplicateHandling;
     private Table likeTable;
     private Table cloneTable;
+    private List<Table> inherits;
     private ColDataType ofType;
     private boolean selectParenthesis;
     private boolean useAsKeyword = true;
@@ -347,6 +348,27 @@ public void setPartitionBound(PartitionBound partitionBound) {
         this.partitionBound = partitionBound;
     }
 
+    /** PostgreSQL parent tables, in declaration order; null if INHERITS is absent. */
+    public List<Table> getInherits() {
+        return inherits;
+    }
+
+    public void setInherits(List<Table> inherits) {
+        this.inherits = inherits;
+    }
+
+    public CreateTable withInherits(List<Table> inherits) {
+        setInherits(inherits);
+        return this;
+    }
+
+    /** Shared rendering of the structured parent references. */
+    public void appendInheritanceTo(StringBuilder builder) {
+        if (inherits != null) {
+            builder.append(" INHERITS ").append(PlainSelect.getStringList(inherits, true, true));
+        }
+    }
+
     public boolean isSelectParenthesis() {
         return selectParenthesis;
     }
@@ -369,6 +391,7 @@ public String toString() {
         StringBuilder b = new StringBuilder();
         appendCreateClause(b);
         appendColumnDefinitions(b);
+        appendInheritanceTo(b);
         if (partitionBound != null) {
             b.append(" ").append(partitionBound);
         }

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

@@ -21,7 +21,6 @@
 import net.sf.jsqlparser.statement.ReferentialAction;
 import net.sf.jsqlparser.statement.ReferentialAction.Action;
 import net.sf.jsqlparser.statement.ReferentialAction.Type;
-import net.sf.jsqlparser.statement.select.PlainSelect;
 
 /** The target and actions of a column- or table-level foreign-key reference. */
 public class ForeignKeyReference implements Serializable {
@@ -33,8 +32,35 @@ public enum MatchType {
     private Table table;
     private List<String> referencedColumnNames;
     private MatchType matchType;
+    private boolean usingPeriod;
+    private ConstraintAttributes constraintAttributes;
     private final Set<ReferentialAction> referentialActions = new LinkedHashSet<>(2);
 
+    /**
+     * Attributes of a column REFERENCES clause; table constraints own their attributes on Index.
+     */
+    public ConstraintAttributes getConstraintAttributes() {
+        return constraintAttributes;
+    }
+
+    public void setConstraintAttributes(ConstraintAttributes constraintAttributes) {
+        this.constraintAttributes = constraintAttributes;
+    }
+
+    /** Whether the final explicitly referenced column is prefixed with PERIOD. */
+    public boolean isUsingPeriod() {
+        return usingPeriod;
+    }
+
+    public void setUsingPeriod(boolean usingPeriod) {
+        this.usingPeriod = usingPeriod;
+    }
+
+    public ForeignKeyReference withUsingPeriod(boolean usingPeriod) {
+        setUsingPeriod(usingPeriod);
+        return this;
+    }
+
     public Table getTable() {
         return table;
     }
@@ -124,12 +150,25 @@ public ForeignKeyReference addReferencedColumnNames(
     public String toString() {
         StringBuilder builder = new StringBuilder("REFERENCES ").append(table);
         if (referencedColumnNames != null) {
-            builder.append(PlainSelect.getStringList(referencedColumnNames, true, true));
+            builder.append('(');
+            for (int i = 0; i < referencedColumnNames.size(); i++) {
+                if (i > 0) {
+                    builder.append(", ");
+                }
+                if (usingPeriod && i == referencedColumnNames.size() - 1) {
+                    builder.append("PERIOD ");
+                }
+                builder.append(referencedColumnNames.get(i));
+            }
+            builder.append(')');
         }
         if (matchType != null) {
             builder.append(" MATCH ").append(matchType);
         }
         referentialActions.forEach(builder::append);
+        if (constraintAttributes != null) {
+            constraintAttributes.appendTo(builder);
+        }
         return builder.toString();
     }
 }

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

@@ -417,6 +417,8 @@ public enum NullOrdering {
         private SortOrder sortOrder;
         private NullOrdering nullOrdering;
         private ExclusionOperator exclusionOperator;
+        private boolean withoutOverlaps;
+        private boolean period;
 
         public String getExclusionOperator() {
             return exclusionOperator == null ? null : exclusionOperator.toString();
@@ -466,6 +468,34 @@ public ColumnParams(Expression expression, List<String> params) {
             this.expression = expression;
         }
 
+        /** Marks the final key of a PostgreSQL temporal PRIMARY KEY or UNIQUE constraint. */
+        public boolean isWithoutOverlaps() {
+            return withoutOverlaps;
+        }
+
+        public void setWithoutOverlaps(boolean withoutOverlaps) {
+            this.withoutOverlaps = withoutOverlaps;
+        }
+
+        public ColumnParams withWithoutOverlaps(boolean withoutOverlaps) {
+            setWithoutOverlaps(withoutOverlaps);
+            return this;
+        }
+
+        /** Marks the final referencing column of a temporal foreign key. */
+        public boolean isPeriod() {
+            return period;
+        }
+
+        public void setPeriod(boolean period) {
+            this.period = period;
+        }
+
+        public ColumnParams withPeriod(boolean period) {
+            setPeriod(period);
+            return this;
+        }
+
         public String getColumnName() {
             return expression != null ? expression.toString() : columnName;
         }
@@ -569,6 +599,9 @@ public String toString() {
 
         /** Renders expression keys through the caller's expression printer. */
         public void appendTo(StringBuilder builder, Consumer<Expression> expressionPrinter) {
+            if (period) {
+                builder.append("PERIOD ");
+            }
             if (expression != null) {
                 if (expressionParenthesized) {
                     builder.append('(');
@@ -588,6 +621,9 @@ public void appendTo(StringBuilder builder, Consumer<Expression> expressionPrint
             if (exclusionOperator != null) {
                 builder.append(" WITH ").append(exclusionOperator);
             }
+            if (withoutOverlaps) {
+                builder.append(" WITHOUT OVERLAPS");
+            }
         }
 
         private void appendParams(StringBuilder builder) {

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

@@ -13,15 +13,30 @@
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.schema.Column;
 
-/** PostgreSQL 18 table-level NOT NULL constraint, optionally named and non-inheritable. */
+/** PostgreSQL 18 column- or table-level NOT NULL constraint. */
 public class NotNullConstraint extends NamedConstraint {
     private Column column;
     private boolean noInherit;
+    private boolean columnConstraint;
 
     public NotNullConstraint() {
         setType("NOT NULL");
     }
 
+    /** Whether the target is implicit in the enclosing column definition. */
+    public boolean isColumnConstraint() {
+        return columnConstraint;
+    }
+
+    public void setColumnConstraint(boolean columnConstraint) {
+        this.columnConstraint = columnConstraint;
+    }
+
+    public NotNullConstraint withColumnConstraint(boolean columnConstraint) {
+        setColumnConstraint(columnConstraint);
+        return this;
+    }
+
     public Column getColumn() {
         return column;
     }
@@ -61,12 +76,15 @@ public NotNullConstraint withConstraintAttributes(ConstraintAttributes attribute
 
     @Override
     public void appendTo(StringBuilder sql, Consumer<Expression> expressionPrinter) {
-        if (column == null) {
+        if (!columnConstraint && column == null) {
             throw new IllegalStateException("NOT NULL requires a target column");
         }
         appendConstraintPrefixTo(sql);
-        sql.append("NOT NULL ");
-        expressionPrinter.accept(column);
+        sql.append("NOT NULL");
+        if (!columnConstraint) {
+            sql.append(' ');
+            expressionPrinter.accept(column);
+        }
         if (noInherit) {
             sql.append(" NO INHERIT");
         }

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

@@ -21,7 +21,7 @@
 public class TableOption implements Serializable {
 
     public enum Kind {
-        ENGINE, CHARACTER_SET, COLLATE, COMMENT, AUTO_INCREMENT, STATS_AUTO_RECALC, STATS_PERSISTENT, STATS_SAMPLE_PAGES, UNION, OTHER
+        ENGINE, CHARACTER_SET, COLLATE, COMMENT, AUTO_INCREMENT, STATS_AUTO_RECALC, STATS_PERSISTENT, STATS_SAMPLE_PAGES, UNION, ENCRYPTION, PASSWORD, DATA_DIRECTORY, INDEX_DIRECTORY, OTHER
     }
 
     private Kind kind = Kind.OTHER;

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

@@ -109,6 +109,9 @@ public static void visit(CreateTable table, Consumer<Expression> expressions,
                 }
             });
         }
+        if (table.getInherits() != null) {
+            table.getInherits().forEach(parent -> accept(parent, tables));
+        }
         accept(table.getTrailingLikeTable(), tables);
         accept(table.getPartitionOf(), tables);
         visit(table.getPartitioning(), expressions);

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

@@ -106,6 +106,7 @@ public void deParse(CreateTable createTable) {
             builder.append(")");
         }
 
+        createTable.appendInheritanceTo(builder);
         if (createTable.getPartitionBound() != null) {
             builder.append(' ');
             createTable.getPartitionBound().appendTo(builder,