fix(parser): model PostgreSQL CREATE INDEX clauses

Author: minleejae

src/main/java/net/sf/jsqlparser/statement/create/index/CreateIndex.java

@@ -12,9 +12,11 @@
 import static java.util.stream.Collectors.joining;
 
 import java.util.*;
+import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.schema.*;
 import net.sf.jsqlparser.statement.*;
 import net.sf.jsqlparser.statement.create.table.*;
+import net.sf.jsqlparser.statement.select.PlainSelect;
 
 public class CreateIndex implements Statement {
 
@@ -25,6 +27,11 @@ public class CreateIndex implements Statement {
     private boolean usingIfNotExists = false;
     private boolean concurrently;
     private boolean only;
+    private List<String> includeColumns;
+    private Boolean nullsDistinct;
+    private List<Index.Option> storageParameters;
+    private String tableSpace;
+    private Expression where;
 
     public boolean isIndexTypeBeforeOn() {
         return indexTypeBeforeOn;
@@ -59,6 +66,46 @@ public void setOnly(boolean only) {
         this.only = only;
     }
 
+    public List<String> getIncludeColumns() {
+        return includeColumns;
+    }
+
+    public void setIncludeColumns(List<String> includeColumns) {
+        this.includeColumns = includeColumns;
+    }
+
+    public Boolean getNullsDistinct() {
+        return nullsDistinct;
+    }
+
+    public void setNullsDistinct(Boolean nullsDistinct) {
+        this.nullsDistinct = nullsDistinct;
+    }
+
+    public List<Index.Option> getStorageParameters() {
+        return storageParameters;
+    }
+
+    public void setStorageParameters(List<Index.Option> storageParameters) {
+        this.storageParameters = storageParameters;
+    }
+
+    public String getTableSpace() {
+        return tableSpace;
+    }
+
+    public void setTableSpace(String tableSpace) {
+        this.tableSpace = tableSpace;
+    }
+
+    public Expression getWhere() {
+        return where;
+    }
+
+    public void setWhere(Expression where) {
+        this.where = where;
+    }
+
     @Override
     public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
         return statementVisitor.visit(this, context);
@@ -135,6 +182,8 @@ public String toString() {
 
             buffer.append(")");
 
+            appendPostgreSqlTail(buffer);
+
             if (tailParameters != null) {
                 for (String param : tailParameters) {
                     buffer.append(" ").append(param);
@@ -145,6 +194,25 @@ public String toString() {
         return buffer.toString();
     }
 
+    private void appendPostgreSqlTail(StringBuilder buffer) {
+        if (includeColumns != null) {
+            buffer.append(" INCLUDE (").append(String.join(", ", includeColumns)).append(")");
+        }
+        if (nullsDistinct != null) {
+            buffer.append(" NULLS ").append(nullsDistinct ? "DISTINCT" : "NOT DISTINCT");
+        }
+        if (storageParameters != null) {
+            buffer.append(" WITH ")
+                    .append(PlainSelect.getStringList(storageParameters, true, true));
+        }
+        if (tableSpace != null) {
+            buffer.append(" TABLESPACE ").append(tableSpace);
+        }
+        if (where != null) {
+            buffer.append(" WHERE ").append(where);
+        }
+    }
+
     public CreateIndex withTable(Table table) {
         this.setTable(table);
         return this;
@@ -169,4 +237,29 @@ public CreateIndex withOnly(boolean only) {
         setOnly(only);
         return this;
     }
+
+    public CreateIndex withIncludeColumns(List<String> includeColumns) {
+        setIncludeColumns(includeColumns);
+        return this;
+    }
+
+    public CreateIndex withNullsDistinct(Boolean nullsDistinct) {
+        setNullsDistinct(nullsDistinct);
+        return this;
+    }
+
+    public CreateIndex withStorageParameters(List<Index.Option> storageParameters) {
+        setStorageParameters(storageParameters);
+        return this;
+    }
+
+    public CreateIndex withTableSpace(String tableSpace) {
+        setTableSpace(tableSpace);
+        return this;
+    }
+
+    public CreateIndex withWhere(Expression where) {
+        setWhere(where);
+        return this;
+    }
 }

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

@@ -200,9 +200,22 @@ public void setCommentText(String commentText) {
     }
 
     public static class ColumnParams implements Serializable {
+        public enum SortOrder {
+            ASC, DESC
+        }
+
+        public enum NullOrdering {
+            FIRST, LAST
+        }
+
         public final String columnName;
         public final List<String> params;
         private final Expression expression;
+        private String collation;
+        private String operatorClass;
+        private List<Option> operatorClassParameters;
+        private SortOrder sortOrder;
+        private NullOrdering nullOrdering;
 
         public ColumnParams(String columnName) {
             this.columnName = columnName;
@@ -244,10 +257,159 @@ public boolean isExpression() {
             return expression != null;
         }
 
+        public String getCollation() {
+            return collation;
+        }
+
+        public void setCollation(String collation) {
+            this.collation = collation;
+        }
+
+        public String getOperatorClass() {
+            return operatorClass;
+        }
+
+        public void setOperatorClass(String operatorClass) {
+            this.operatorClass = operatorClass;
+        }
+
+        public List<Option> getOperatorClassParameters() {
+            return operatorClassParameters;
+        }
+
+        public void setOperatorClassParameters(List<Option> operatorClassParameters) {
+            this.operatorClassParameters = operatorClassParameters;
+        }
+
+        public SortOrder getSortOrder() {
+            return sortOrder;
+        }
+
+        public void setSortOrder(SortOrder sortOrder) {
+            this.sortOrder = sortOrder;
+        }
+
+        public NullOrdering getNullOrdering() {
+            return nullOrdering;
+        }
+
+        public void setNullOrdering(NullOrdering nullOrdering) {
+            this.nullOrdering = nullOrdering;
+        }
+
+        public ColumnParams withCollation(String collation) {
+            setCollation(collation);
+            return this;
+        }
+
+        public ColumnParams withOperatorClass(String operatorClass) {
+            setOperatorClass(operatorClass);
+            return this;
+        }
+
+        public ColumnParams withOperatorClassParameters(List<Option> operatorClassParameters) {
+            setOperatorClassParameters(operatorClassParameters);
+            return this;
+        }
+
+        public ColumnParams withSortOrder(SortOrder sortOrder) {
+            setSortOrder(sortOrder);
+            return this;
+        }
+
+        public ColumnParams withNullOrdering(NullOrdering nullOrdering) {
+            setNullOrdering(nullOrdering);
+            return this;
+        }
+
+        @Override
+        public String toString() {
+            StringBuilder builder = new StringBuilder(
+                    expression != null ? "(" + expression + ")" : columnName);
+            if (params != null) {
+                builder.append(" ").append(String.join(" ", params));
+            }
+            if (collation != null && !hasParam("COLLATE")) {
+                builder.append(" COLLATE ").append(collation);
+            }
+            if (operatorClass != null && !hasParam(operatorClass)) {
+                builder.append(" ").append(operatorClass);
+                if (operatorClassParameters != null && !operatorClassParameters.isEmpty()) {
+                    builder.append(" ")
+                            .append(PlainSelect.getStringList(
+                                    operatorClassParameters, true, true));
+                }
+            }
+            if (sortOrder != null && !hasParam(sortOrder.name())) {
+                builder.append(" ").append(sortOrder);
+            }
+            if (nullOrdering != null && !hasParam("NULLS")) {
+                builder.append(" NULLS ").append(nullOrdering);
+            }
+            return builder.toString();
+        }
+
+        private boolean hasParam(String expected) {
+            return params != null && params.stream().anyMatch(expected::equalsIgnoreCase);
+        }
+    }
+
+    /** A named PostgreSQL index option with an optional value. */
+    public static class Option implements Serializable {
+        private String name;
+        private Expression value;
+        private boolean useEquals;
+
+        public Option() {}
+
+        public Option(String name, Expression value, boolean useEquals) {
+            this.name = name;
+            this.value = value;
+            this.useEquals = useEquals;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public void setName(String name) {
+            this.name = name;
+        }
+
+        public Expression getValue() {
+            return value;
+        }
+
+        public void setValue(Expression value) {
+            this.value = value;
+        }
+
+        public boolean isUseEquals() {
+            return useEquals;
+        }
+
+        public void setUseEquals(boolean useEquals) {
+            this.useEquals = useEquals;
+        }
+
+        public Option withName(String name) {
+            setName(name);
+            return this;
+        }
+
+        public Option withValue(Expression value) {
+            setValue(value);
+            return this;
+        }
+
+        public Option withUseEquals(boolean useEquals) {
+            setUseEquals(useEquals);
+            return this;
+        }
+
         @Override
         public String toString() {
-            String head = expression != null ? "(" + expression + ")" : columnName;
-            return head + (params != null ? " " + String.join(" ", params) : "");
+            return value == null ? name : name + (useEquals ? " = " : " ") + value;
         }
     }
 }

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

@@ -13,6 +13,7 @@
 
 import net.sf.jsqlparser.statement.create.index.CreateIndex;
 import net.sf.jsqlparser.statement.create.table.Index;
+import net.sf.jsqlparser.statement.select.PlainSelect;
 
 public class CreateIndexDeParser extends AbstractDeParser<CreateIndex> {
 
@@ -66,6 +67,25 @@ public void deParse(CreateIndex createIndex) {
             builder.append(")");
         }
 
+        if (createIndex.getIncludeColumns() != null) {
+            builder.append(" INCLUDE (")
+                    .append(String.join(", ", createIndex.getIncludeColumns())).append(")");
+        }
+        if (createIndex.getNullsDistinct() != null) {
+            builder.append(" NULLS ")
+                    .append(createIndex.getNullsDistinct() ? "DISTINCT" : "NOT DISTINCT");
+        }
+        if (createIndex.getStorageParameters() != null) {
+            builder.append(" WITH ").append(PlainSelect.getStringList(
+                    createIndex.getStorageParameters(), true, true));
+        }
+        if (createIndex.getTableSpace() != null) {
+            builder.append(" TABLESPACE ").append(createIndex.getTableSpace());
+        }
+        if (createIndex.getWhere() != null) {
+            builder.append(" WHERE ").append(createIndex.getWhere());
+        }
+
         if (createIndex.getTailParameters() != null) {
             for (String param : createIndex.getTailParameters()) {
                 builder.append(" ").append(param);