Preserve detached CREATE INDEX option isolation and traversal

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

Author: minleejae

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

@@ -81,6 +81,10 @@ public List<String> getIncludeColumns() {
         return options == null ? null : options.getIncludeColumns();
     }
 
+    /**
+     * Copies the supplied list as {@link Index#setIncludeColumns(List)} does; null clears it.
+     * {@link #getIncludeColumns()} returns the live, mutable list held by the index options.
+     */
     public void setIncludeColumns(List<String> includeColumns) {
         getOrCreateOptions().setIncludeColumns(includeColumns);
     }
@@ -99,6 +103,11 @@ public List<Index.Option> getStorageParameters() {
         return options == null ? null : options.getStorageParameters();
     }
 
+    /**
+     * Copies the list container as {@link Index#setStorageParameters(List)} does, retaining the
+     * option objects; null clears it. {@link #getStorageParameters()} returns the live, mutable
+     * list held by the index options.
+     */
     public void setStorageParameters(List<Index.Option> storageParameters) {
         getOrCreateOptions().setStorageParameters(storageParameters);
     }
@@ -146,13 +155,20 @@ public Index getIndex() {
     /**
      * Replaces the index definition. Options supplied by the new index take precedence; omitted
      * options inherit the current statement options, including those set before an index was
-     * attached. Passing null detaches the definition without discarding its options. Use the option
+     * attached. Passing null detaches the definition without discarding its options. The detached
+     * option lists have independent containers, with their elements retained. Use the option
      * setters with null to clear individual options.
      */
     public void setIndex(Index index) {
         Index previousOptions = getOptions();
         if (index == null) {
-            detachedOptions = previousOptions;
+            if (this.index != null) {
+                detachedOptions = new Index();
+                detachedOptions.setIncludeColumns(previousOptions.getIncludeColumns());
+                detachedOptions.setNullsDistinct(previousOptions.getNullsDistinct());
+                detachedOptions.setStorageParameters(previousOptions.getStorageParameters());
+                detachedOptions.setTableSpace(previousOptions.getTableSpace());
+            }
         } else {
             if (previousOptions != null && previousOptions != index) {
                 if (index.getIncludeColumns() == null) {

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

@@ -43,6 +43,8 @@ public static void visit(CreateIndex createIndex, Consumer<Expression> expressio
         accept(createIndex.getTable(), tables);
         if (createIndex.getIndex() != null) {
             visit(createIndex.getIndex(), expressions, tables);
+        } else {
+            visitOptions(createIndex.getStorageParameters(), expressions);
         }
         accept(createIndex.getWhere(), expressions);
     }

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

@@ -10,6 +10,7 @@
 package net.sf.jsqlparser.statement.create;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertSame;
 
@@ -128,6 +129,63 @@ void replacementOptionsTakePrecedenceAndMissingOptionsSurviveDetachment() throws
                 + "NULLS NOT DISTINCT WITH (fillfactor = 90)", statement);
     }
 
+    @Test
+    void detachedOptionSettersDoNotMutateTheRemovedIndex() throws Exception {
+        CreateIndex statement = parse(SQL);
+        Index removed = statement.getIndex();
+        statement.setIndex(null);
+
+        assertNotSame(removed.getIncludeColumns(), statement.getIncludeColumns());
+        assertNotSame(removed.getStorageParameters(), statement.getStorageParameters());
+        assertSame(removed.getStorageParameters().get(0), statement.getStorageParameters().get(0));
+        List<String> detachedColumns = statement.getIncludeColumns();
+        List<Index.Option> detachedParameters = statement.getStorageParameters();
+        statement.setIndex(null);
+        assertSame(detachedColumns, statement.getIncludeColumns());
+        assertSame(detachedParameters, statement.getStorageParameters());
+        statement.getIncludeColumns().add("extra");
+        assertEquals(List.of("payload", "extra"), statement.getIncludeColumns());
+        assertEquals(List.of("payload"), removed.getIncludeColumns());
+
+        statement.setTableSpace("detached_space");
+        statement.setNullsDistinct(true);
+        statement.setIncludeColumns(List.of("detached_payload"));
+        statement.setStorageParameters(List.of(option(90)));
+        assertEquals("fast_space", removed.getTableSpace());
+        assertEquals(Boolean.FALSE, removed.getNullsDistinct());
+        assertEquals(List.of("payload"), removed.getIncludeColumns());
+        assertEquals("80", removed.getStorageParameters().get(0).getValue().toString());
+
+        removed.setTableSpace("external_space");
+        removed.setNullsDistinct(null);
+        assertEquals("detached_space", statement.getTableSpace());
+        assertEquals(Boolean.TRUE, statement.getNullsDistinct());
+        statement.setIndex(new Index().withType("UNIQUE").withName("reattached")
+                .withColumnsNames(List.of("id")));
+        assertRoundTrip("CREATE UNIQUE INDEX reattached ON t (id) INCLUDE (detached_payload) "
+                + "NULLS DISTINCT WITH (fillfactor = 90) TABLESPACE detached_space", statement);
+    }
+
+    @Test
+    void optionsAreVisitedBeforeAttachmentAndAfterDetachment() throws Exception {
+        for (CreateIndex statement : List.of(new CreateIndex(), parse(SQL))) {
+            statement.setIndex(null);
+            statement.setStorageParameters(List.of(option(80)));
+            List<Long> values = new ArrayList<>();
+            ExpressionVisitorAdapter<Void> expressions = new ExpressionVisitorAdapter<Void>() {
+                @Override
+                public <S> Void visit(LongValue value, S context) {
+                    assertEquals("context", context);
+                    values.add(value.getValue());
+                    return null;
+                }
+            };
+            statement.accept(new StatementVisitorAdapter<>(new SelectVisitorAdapter<>(expressions)),
+                    "context");
+            assertEquals(List.of(80L), values);
+        }
+    }
+
     @Test
     void indexOptionEditsAreVisitedOnceAndCanBeDeparsedThroughCustomVisitors() throws Exception {
         CreateIndex statement = parse(SQL);