Support dialect-specific CREATE INDEX definitions

src/main/java/net/sf/jsqlparser/parser/AbstractJSqlParser.java

@@ -46,7 +46,7 @@ public enum Dialect {
                                                         AdjacentStringLiterals.WHITESPACE,
                                                         Feature.allowDoubleQuotedStrings,
                                                         Feature.allowBackslashEscapeCharacter), SNOWFLAKE(
-                                                                Feature.allowBackslashEscapeCharacter), INFORMIX;
+                                                                Feature.allowBackslashEscapeCharacter), INFORMIX, SPANNER;
 
         private final Set<Feature> lexerFeatures;
         private final AdjacentStringLiterals adjacentStringLiterals;

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

@@ -334,7 +334,9 @@ public <S> T visit(Truncate truncate, S context) {
 
     @Override
     public <S> T visit(CreateIndex createIndex, S context) {
-
+        TableDefinitionTraversal.visit(createIndex,
+                expression -> expression.accept(expressionVisitor, context),
+                table -> table.accept(fromItemVisitor, context));
         return null;
     }
 

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

@@ -9,14 +9,12 @@
  */
 package net.sf.jsqlparser.statement.create.index;
 
-import static java.util.stream.Collectors.joining;
-
 import java.util.*;
+import java.util.function.Consumer;
 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 {
 
@@ -27,6 +25,7 @@ public class CreateIndex implements Statement {
     private boolean usingIfNotExists = false;
     private boolean concurrently;
     private boolean only;
+    private boolean nullFiltered;
     private List<String> includeColumns;
     private Boolean nullsDistinct;
     private List<Index.Option> storageParameters;
@@ -66,6 +65,20 @@ public void setOnly(boolean only) {
         this.only = only;
     }
 
+    /** Whether this Spanner index omits rows with null key values. */
+    public boolean isNullFiltered() {
+        return nullFiltered;
+    }
+
+    public void setNullFiltered(boolean nullFiltered) {
+        this.nullFiltered = nullFiltered;
+    }
+
+    public CreateIndex withNullFiltered(boolean nullFiltered) {
+        setNullFiltered(nullFiltered);
+        return this;
+    }
+
     public List<String> getIncludeColumns() {
         return includeColumns;
     }
@@ -142,10 +155,15 @@ public String toString() {
 
     /** Shared rendering for the statement model and CreateIndexDeParser. */
     public StringBuilder appendTo(StringBuilder buffer) {
+        return appendTo(buffer, expression -> buffer.append(expression));
+    }
+
+    /** Shares rendering while allowing visitors to transform key and option expressions. */
+    public StringBuilder appendTo(StringBuilder buffer, Consumer<Expression> expressionPrinter) {
         appendIndexHeader(buffer);
         appendIndexTarget(buffer);
-        appendIndexColumns(buffer);
-        appendPostgreSqlTail(buffer);
+        appendIndexColumns(buffer, expressionPrinter);
+        appendPostgreSqlTail(buffer, expressionPrinter);
         if (tailParameters != null) {
             for (String param : tailParameters) {
                 buffer.append(" ").append(param);
@@ -159,6 +177,12 @@ private void appendIndexHeader(StringBuilder buffer) {
         if (index.getType() != null) {
             buffer.append(index.getType()).append(" ");
         }
+        if (index.getClustering() != null) {
+            buffer.append(index.getClustering()).append(" ");
+        }
+        if (nullFiltered) {
+            buffer.append("NULL_FILTERED ");
+        }
         buffer.append("INDEX ");
         if (concurrently) {
             buffer.append("CONCURRENTLY ");
@@ -185,32 +209,38 @@ private void appendIndexTarget(StringBuilder buffer) {
         }
     }
 
-    private void appendIndexColumns(StringBuilder buffer) {
-        if (index.getColumnsNames() != null) {
+    private void appendIndexColumns(StringBuilder buffer, Consumer<Expression> expressionPrinter) {
+        if (index.getColumns() != null) {
             buffer.append(" (");
-            buffer.append(index.getColumns().stream()
-                    .map(Index.ColumnParams::toString)
-                    .collect(joining(", ")));
+            for (Iterator<Index.ColumnParams> columns = index.getColumns().iterator(); columns
+                    .hasNext();) {
+                columns.next().appendTo(buffer, expressionPrinter);
+                if (columns.hasNext()) {
+                    buffer.append(", ");
+                }
+            }
             buffer.append(")");
         }
     }
 
-    private void appendPostgreSqlTail(StringBuilder buffer) {
+    private void appendPostgreSqlTail(StringBuilder buffer,
+            Consumer<Expression> expressionPrinter) {
         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));
+            buffer.append(" WITH ");
+            Index.Option.appendListTo(buffer, storageParameters, expressionPrinter);
         }
         if (tableSpace != null) {
             buffer.append(" TABLESPACE ").append(tableSpace);
         }
         if (where != null) {
-            buffer.append(" WHERE ").append(where);
+            buffer.append(" WHERE ");
+            expressionPrinter.accept(where);
         }
     }
 

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

@@ -511,7 +511,7 @@ public void appendTo(StringBuilder builder, Consumer<Expression> expressionPrint
             }
             appendParams(builder);
             appendCollation(builder);
-            appendOperatorClass(builder);
+            appendOperatorClass(builder, expressionPrinter);
             appendSortOrder(builder);
             appendNullOrdering(builder);
             if (exclusionOperator != null) {
@@ -531,13 +531,13 @@ private void appendCollation(StringBuilder builder) {
             }
         }
 
-        private void appendOperatorClass(StringBuilder builder) {
+        private void appendOperatorClass(StringBuilder builder,
+                Consumer<Expression> expressionPrinter) {
             if (operatorClass != null && !hasParam(operatorClass)) {
                 builder.append(" ").append(operatorClass);
                 if (operatorClassParameters != null && !operatorClassParameters.isEmpty()) {
-                    builder.append(" ")
-                            .append(PlainSelect.getStringList(
-                                    operatorClassParameters, true, true));
+                    builder.append(" ");
+                    Option.appendListTo(builder, operatorClassParameters, expressionPrinter);
                 }
             }
         }
@@ -559,7 +559,7 @@ private boolean hasParam(String expected) {
         }
     }
 
-    /** A named PostgreSQL index option with an optional value. */
+    /** A named index option with an optional value. */
     public static class Option implements Serializable {
         private String name;
         private Expression value;
@@ -614,7 +614,33 @@ public Option withUseEquals(boolean useEquals) {
 
         @Override
         public String toString() {
-            return value == null ? name : name + (useEquals ? " = " : " ") + value;
+            if (value == null) {
+                return name;
+            }
+            StringBuilder builder = new StringBuilder();
+            return appendTo(builder, expression -> builder.append(expression)).toString();
+        }
+
+        public StringBuilder appendTo(StringBuilder builder,
+                Consumer<Expression> expressionPrinter) {
+            builder.append(name);
+            if (value != null) {
+                builder.append(useEquals ? " = " : " ");
+                expressionPrinter.accept(value);
+            }
+            return builder;
+        }
+
+        public static StringBuilder appendListTo(StringBuilder builder, List<Option> options,
+                Consumer<Expression> expressionPrinter) {
+            builder.append('(');
+            for (int i = 0; i < options.size(); i++) {
+                if (i > 0) {
+                    builder.append(", ");
+                }
+                options.get(i).appendTo(builder, expressionPrinter);
+            }
+            return builder.append(')');
         }
     }
 }

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

@@ -15,6 +15,7 @@
 import net.sf.jsqlparser.schema.Table;
 import net.sf.jsqlparser.statement.LikeClause;
 import net.sf.jsqlparser.statement.alter.AlterExpression;
+import net.sf.jsqlparser.statement.create.index.CreateIndex;
 import net.sf.jsqlparser.statement.create.table.CheckConstraint;
 import net.sf.jsqlparser.statement.create.table.ColumnDefinition;
 import net.sf.jsqlparser.statement.create.table.ColumnOption;
@@ -29,6 +30,16 @@
 public final class TableDefinitionTraversal {
     private TableDefinitionTraversal() {}
 
+    public static void visit(CreateIndex createIndex, Consumer<Expression> expressions,
+            Consumer<Table> tables) {
+        accept(createIndex.getTable(), tables);
+        if (createIndex.getIndex() != null) {
+            visit(createIndex.getIndex(), expressions, tables);
+        }
+        visitOptions(createIndex.getStorageParameters(), expressions);
+        accept(createIndex.getWhere(), expressions);
+    }
+
     public static void visit(CreateTable table, Consumer<Expression> expressions,
             Consumer<Table> tables) {
         if (table.getTableElements() != null) {

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

@@ -1552,7 +1552,9 @@ public void visit(Truncate truncate) {
 
     @Override
     public <S> Void visit(CreateIndex createIndex, S context) {
-        throwUnsupported(createIndex);
+        TableDefinitionTraversal.visit(createIndex,
+                expression -> expression.accept(this, context),
+                table -> visit(table, context));
         return null;
     }
 

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

@@ -9,16 +9,28 @@
  */
 package net.sf.jsqlparser.util.deparser;
 
+import net.sf.jsqlparser.expression.ExpressionVisitor;
 import net.sf.jsqlparser.statement.create.index.CreateIndex;
 
 public class CreateIndexDeParser extends AbstractDeParser<CreateIndex> {
+    private final ExpressionVisitor<StringBuilder> expressionVisitor;
 
     public CreateIndexDeParser(StringBuilder buffer) {
+        this(buffer, null);
+    }
+
+    public CreateIndexDeParser(StringBuilder buffer,
+            ExpressionVisitor<StringBuilder> expressionVisitor) {
         super(buffer);
+        this.expressionVisitor = expressionVisitor;
     }
 
     @Override
     public void deParse(CreateIndex createIndex) {
-        createIndex.appendTo(builder);
+        if (expressionVisitor == null) {
+            createIndex.appendTo(builder);
+        } else {
+            createIndex.appendTo(builder, expression -> expression.accept(expressionVisitor, null));
+        }
     }
 }

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

@@ -141,7 +141,8 @@ public StatementDeParser(ExpressionDeParser expressionDeParser, SelectDeParser s
 
     @Override
     public <S> StringBuilder visit(CreateIndex createIndex, S context) {
-        CreateIndexDeParser createIndexDeParser = new CreateIndexDeParser(builder);
+        CreateIndexDeParser createIndexDeParser =
+                new CreateIndexDeParser(builder, expressionDeParser);
         createIndexDeParser.deParse(createIndex);
         return builder;
     }

src/main/java/net/sf/jsqlparser/util/validation/validator/CreateIndexValidator.java

@@ -14,6 +14,7 @@
 import net.sf.jsqlparser.parser.feature.Feature;
 import net.sf.jsqlparser.statement.create.index.CreateIndex;
 import net.sf.jsqlparser.statement.create.table.Index;
+import net.sf.jsqlparser.util.TableDefinitionTraversal;
 import net.sf.jsqlparser.util.validation.ValidationCapability;
 import net.sf.jsqlparser.util.validation.metadata.NamedObject;
 
@@ -38,6 +39,9 @@ public void validate(CreateIndex createIndex) {
                         NamedObject.table);
             }
         }
+        TableDefinitionTraversal.visit(createIndex, this::validateOptionalExpression, table -> {
+            // Table and index names are validated above for each capability.
+        });
     }
 
 }