Merge upstream master and resolve CREATE TABLE grammar conflict

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

Author: minleejae

src/main/java/net/sf/jsqlparser/schema/Sequence.java

@@ -187,7 +187,7 @@ public Sequence addParameters(Collection<? extends Parameter> parameters) {
      * The available parameters to a sequence
      */
     public enum ParameterType {
-        INCREMENT_BY, INCREMENT, START_WITH, START, RESTART_WITH, MAXVALUE, NOMAXVALUE, MINVALUE, NOMINVALUE, CYCLE, NOCYCLE, CACHE, NOCACHE, ORDER, NOORDER, KEEP, NOKEEP, SESSION, GLOBAL, NO_MINVALUE, NO_MAXVALUE, NO_CYCLE;
+        INCREMENT_BY, INCREMENT, START_WITH, START, RESTART_WITH, MAXVALUE, NOMAXVALUE, MINVALUE, NOMINVALUE, CYCLE, NOCYCLE, CACHE, NOCACHE, ORDER, NOORDER, KEEP, NOKEEP, SESSION, GLOBAL, NO_MINVALUE, NO_MAXVALUE, NO_CYCLE, SEQUENCE_NAME;
 
         public static ParameterType from(String type) {
             return Enum.valueOf(ParameterType.class, type.toUpperCase(Locale.ROOT));
@@ -201,6 +201,7 @@ public static class Parameter implements java.io.Serializable {
 
         private final ParameterType option;
         private Long value;
+        private Sequence sequenceName;
 
         public Parameter(ParameterType option) {
             this.option = option;
@@ -214,6 +215,20 @@ public ParameterType getOption() {
             return option;
         }
 
+        /** The sequence named by an identity declaration's SEQUENCE NAME option. */
+        public Sequence getSequenceName() {
+            return sequenceName;
+        }
+
+        public void setSequenceName(Sequence sequenceName) {
+            this.sequenceName = sequenceName;
+        }
+
+        public Parameter withSequenceName(Sequence sequenceName) {
+            setSequenceName(sequenceName);
+            return this;
+        }
+
         @Override
         public String toString() {
             return formatParameter();
@@ -225,6 +240,8 @@ public void setValue(Long value) {
 
         public String formatParameter() {
             switch (option) {
+                case SEQUENCE_NAME:
+                    return "SEQUENCE NAME " + sequenceName.getFullyQualifiedName();
                 case INCREMENT_BY:
                     return prefix("INCREMENT BY");
                 case INCREMENT:

src/main/java/net/sf/jsqlparser/statement/ReferentialAction.java

@@ -11,11 +11,15 @@
 
 import java.io.Serializable;
 import java.util.Locale;
+import java.util.List;
+import java.util.Objects;
+import net.sf.jsqlparser.statement.select.PlainSelect;
 
 public class ReferentialAction implements Serializable {
 
     private Type type;
     private Action action;
+    private List<String> columnNames;
 
     public ReferentialAction() {
         // default constructor
@@ -52,6 +56,20 @@ public ReferentialAction withAction(Action action) {
         return this;
     }
 
+    /** Columns affected by PostgreSQL ON DELETE SET NULL or SET DEFAULT; null means all columns. */
+    public List<String> getColumnNames() {
+        return columnNames;
+    }
+
+    public void setColumnNames(List<String> columnNames) {
+        this.columnNames = columnNames;
+    }
+
+    public ReferentialAction withColumnNames(List<String> columnNames) {
+        setColumnNames(columnNames);
+        return this;
+    }
+
     @Override
     public int hashCode() {
         final int prime = 31;
@@ -64,7 +82,9 @@ public int hashCode() {
     @Override
     public String toString() {
         return " ON " + getType().name() + " " +
-                getAction().getAction();
+                getAction().getAction()
+                + (columnNames == null ? ""
+                        : " " + PlainSelect.getStringList(columnNames, true, true));
     }
 
     @Override
@@ -79,12 +99,8 @@ public boolean equals(Object obj) {
             return false;
         }
         ReferentialAction other = (ReferentialAction) obj;
-        // if (action != other.action) {
-        // return false;
-        // }
-        // if (type != other.type) {
-        // return false;
-        return action == other.action && type == other.type;
+        return action == other.action && type == other.type
+                && Objects.equals(columnNames, other.columnNames);
     }
 
     public enum Type {

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

@@ -35,12 +35,14 @@ public class CreateTable implements Statement {
     private List<Index> indexes;
     private List<TableElement> tableElements;
     private Select select;
+    private DuplicateHandling duplicateHandling;
     private Table likeTable;
     private Table cloneTable;
     private List<Table> inherits;
     private ColDataType ofType;
     private boolean selectParenthesis;
     private boolean useAsKeyword = true;
+    private Boolean withData;
     private boolean ifNotExists = false;
     private boolean orReplace = false;
     private TablePartitioning partitioning;
@@ -51,6 +53,19 @@ public class CreateTable implements Statement {
 
     private SpannerInterleaveIn interleaveIn = null;
 
+    public enum DuplicateHandling {
+        IGNORE, REPLACE
+    }
+
+    /** MySQL's duplicate-key handling when creating a table from a query; null if omitted. */
+    public DuplicateHandling getDuplicateHandling() {
+        return duplicateHandling;
+    }
+
+    public void setDuplicateHandling(DuplicateHandling duplicateHandling) {
+        this.duplicateHandling = duplicateHandling;
+    }
+
     @Override
     public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
         return statementVisitor.visit(this, context);
@@ -205,9 +220,21 @@ public void setUseAsKeyword(boolean useAsKeyword) {
         this.useAsKeyword = useAsKeyword;
     }
 
+    /** Returns null for omission, true for WITH DATA, and false for WITH NO DATA. */
+    public Boolean getWithData() {
+        return withData;
+    }
+
+    public void setWithData(Boolean withData) {
+        this.withData = withData;
+    }
+
     public StringBuilder appendSelectTo(StringBuilder builder,
             java.util.function.Consumer<Select> selectRenderer) {
         if (select != null) {
+            if (duplicateHandling != null) {
+                builder.append(' ').append(duplicateHandling);
+            }
             builder.append(useAsKeyword ? " AS " : " ");
             if (selectParenthesis) {
                 builder.append("(");
@@ -216,6 +243,9 @@ public StringBuilder appendSelectTo(StringBuilder builder,
             if (selectParenthesis) {
                 builder.append(")");
             }
+            if (withData != null) {
+                builder.append(withData ? " WITH DATA" : " WITH NO DATA");
+            }
         }
         return builder;
     }

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

@@ -1440,6 +1440,11 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         return isKeywordAhead("MATCH_RECOGNIZE") && getToken(2).kind == OPENING_BRACKET;
     }
 
+    private boolean isCreateTableQueryPrefix() {
+        int kind = getToken(1).kind;
+        return kind == K_AS || kind == K_TABLE || kind == K_IGNORE || kind == K_REPLACE;
+    }
+
     private boolean isRowPatternPrimaryAhead() {
         Token next = getToken(1);
         return next.kind == OPENING_BRACKET || next.kind == OP_CARET
@@ -14143,8 +14148,7 @@ ColumnOption ColumnDefinitionOption(): {
         LOOKAHEAD(<K_PRIMARY> <K_KEY>) <K_PRIMARY> <K_KEY>
         { option = ColumnOption.constraint(new NamedConstraint().withType("PRIMARY KEY")); }
         |
-        LOOKAHEAD([ <K_CONSTRAINT> RelObjectName() ] <K_CHECK>,
-                { Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) })
+        LOOKAHEAD([ <K_CONSTRAINT> RelObjectName() ] <K_CHECK>)
         [ <K_CONSTRAINT> constraintName=RelObjectName() ]
         constraint=CheckConstraintSpec(constraintName)
         { option = ColumnOption.constraint(constraint); }
@@ -14217,7 +14221,9 @@ IdentityDefinition IdentityDefinition():
     Token token;
     IdentityDefinition.GenerationMode mode;
     IdentityDefinition identity;
-    List<Sequence.Parameter> parameters;
+    List<Sequence.Parameter> parameters = new ArrayList<Sequence.Parameter>();
+    Sequence.Parameter parameter;
+    Sequence sequenceName;
 }
 {
     token=<S_IDENTIFIER> {
@@ -14226,8 +14232,18 @@ IdentityDefinition IdentityDefinition():
     ( <K_ALWAYS> { mode = IdentityDefinition.GenerationMode.ALWAYS; }
         | <K_BY> <K_DEFAULT> { mode = IdentityDefinition.GenerationMode.BY_DEFAULT; } )
     <K_AS> <K_IDENTITY> { identity = new IdentityDefinition(mode); }
-    [ LOOKAHEAD(2) "(" parameters=SequenceParameters() ")" {
-        requireDdlSyntax(!parameters.isEmpty(), "Expected an identity sequence parameter");
+    [ LOOKAHEAD(1) "("
+        (
+            (
+                LOOKAHEAD(<K_SEQUENCE> <K_NAME>)
+                <K_SEQUENCE> <K_NAME> sequenceName=Sequence()
+                { parameter = new Sequence.Parameter(Sequence.ParameterType.SEQUENCE_NAME)
+                        .withSequenceName(sequenceName); }
+                | parameter=SequenceParameter()
+            )
+            { parameters.add(parameter); }
+        )+
+        ")" {
         identity.setParameters(parameters);
     } ]
     { return identity; }
@@ -14970,6 +14986,7 @@ CreateTable CreateTable(boolean isUsingOrReplace):
     ColDataType ofType = null;
     Table parent;
     List<Table> parents = new ArrayList<Table>();
+    boolean withData;
 }
 {
     { createTable.setOrReplace(isUsingOrReplace);}
@@ -15026,9 +15043,14 @@ CreateTable CreateTable(boolean isUsingOrReplace):
     [ rowMovement = RowMovement() { createTable.setRowMovement(rowMovement); }]
     [ LOOKAHEAD(2)
         { createTable.setUseAsKeyword(false); }
+        [ ( tk=<K_IGNORE> | tk=<K_REPLACE> )
+            { createTable.setDuplicateHandling(CreateTable.DuplicateHandling.valueOf(
+                    tk.image.toUpperCase(Locale.ROOT))); } ]
         [ <K_AS> { createTable.setUseAsKeyword(true); } ]
         ( LOOKAHEAD(<K_TABLE>) select=TableStatement() | select=Select() )
         { createTable.setSelect(select, false); }
+        [ LOOKAHEAD(2) <K_WITH> withData=DataPopulation()
+            { createTable.setWithData(withData); } ]
     ]
     [
     <K_LIKE> ( LOOKAHEAD("(" Table() ")") "(" likeTable=Table() { createTable.setLikeTable(likeTable, true); } ")"
@@ -15087,10 +15109,10 @@ ColumnDefinition CreateTableColumnDefinition(boolean typed):
 void CreateTableOptions(List<TableOption> options):
 { TableOption option; }
 {
-    [ LOOKAHEAD(2, { getToken(1).kind != K_AS && getToken(1).kind != K_TABLE
+    [ LOOKAHEAD(2, { !isCreateTableQueryPrefix()
             && !(getToken(1).kind == K_PARTITION && getToken(2).kind == K_BY) })
         option=CreateTableOption() { options.add(option); }
-        ( LOOKAHEAD(2, { getToken(1).kind != K_AS && getToken(1).kind != K_TABLE
+        ( LOOKAHEAD(2, { !isCreateTableQueryPrefix()
                 && !(getToken(1).kind == K_PARTITION && getToken(2).kind == K_BY)
                 && !(getToken(1).kind == K_COMMA
                     && "INTERLEAVE".equalsIgnoreCase(getToken(2).image)) })
@@ -15619,7 +15641,7 @@ CreateView CreateView(boolean isUsingOrReplace):
     List<Index.Option> storageParameters = null;
     List<ViewOption> viewOptions = new ArrayList<ViewOption>();
     ViewOption viewOption = null;
-    boolean withData = true;
+    boolean withData;
 }
 {
     { createView.setOrReplace(isUsingOrReplace);}
@@ -15674,7 +15696,7 @@ CreateView CreateView(boolean isUsingOrReplace):
                 }
             }
             |
-            [ <K_NO> { withData = false; } ] <K_DATA> { createView.setWithData(withData); }
+            withData=DataPopulation() { createView.setWithData(withData); }
         )
     ]
     { createView.validateOptions(); return createView; }
@@ -15692,6 +15714,14 @@ ViewOption PostgreSqlViewOption():
     { return new ViewOption(name, value, useEquals); }
 }
 
+/** Shared WITH [NO] DATA tail for table and materialized-view query sources. */
+boolean DataPopulation():
+{ boolean withData = true; }
+{
+    [ <K_NO> { withData = false; } ] <K_DATA>
+    { return withData; }
+}
+
 List<String> CreateViewTailComment():
 {
     Token tk = null;
@@ -15739,21 +15769,32 @@ ReferentialAction.Action Action():
  * Shared between CREATE TABLE FK and ALTER TABLE FK definitions.
  */
 void ReferentialActions(ForeignKeyReference reference):
+{}
 {
-    Token tk;
-    ReferentialAction.Action action = null;
+    [ LOOKAHEAD(2) ReferentialActionSpec(reference) ]
+    [ LOOKAHEAD(2) ReferentialActionSpec(reference) ]
 }
+
+void ReferentialActionSpec(ForeignKeyReference reference):
 {
-    [ LOOKAHEAD(2) (
-        <K_ON>
-        ( tk=<K_DELETE> | tk=<K_UPDATE> ) action = Action()
-        { reference.setReferentialAction(ReferentialAction.Type.from(tk.image), action); }
-    )]
-    [ LOOKAHEAD(2) (
-        <K_ON>
-        ( tk=<K_DELETE> | tk=<K_UPDATE> ) action = Action()
-        { reference.setReferentialAction(ReferentialAction.Type.from(tk.image), action); }
-    )]
+    Token token;
+    ReferentialAction.Type type;
+    ReferentialAction.Action action;
+    List<String> columnNames = null;
+}
+{
+    <K_ON> ( token=<K_DELETE> | token=<K_UPDATE> )
+    { type = ReferentialAction.Type.from(token.image); }
+    action=Action()
+    [ LOOKAHEAD({ type == ReferentialAction.Type.DELETE
+            && (action == ReferentialAction.Action.SET_NULL
+                || action == ReferentialAction.Action.SET_DEFAULT)
+            && "(".equals(getToken(1).image) })
+        columnNames=ColumnsNamesList() ]
+    {
+        reference.setReferentialAction(type, action);
+        reference.getReferentialAction(type).setColumnNames(columnNames);
+    }
 }
 
 ForeignKeyReference ForeignKeyReferenceSpec():
@@ -16614,7 +16655,7 @@ TablePartitioning CreateTablePartitioning():
     ]
     [ LOOKAHEAD(2) partitionDefinitions=PartitionDefinitions()
         { partitioning.setPartitionDefinitions(partitionDefinitions); } ]
-    ( LOOKAHEAD(2, { getToken(1).kind != K_AS })
+    ( LOOKAHEAD(2, { !isCreateTableQueryPrefix() })
         parameter=CreateParameter() { partitionOptions.addAll(parameter); } )*
     {
         if (!partitionOptions.isEmpty()) {