Allow operations from the on other keyspace

datastax · clun · Apr 4, 2025 · Nov 21, 2024 · Nov 30, 2024 · Nov 30, 2024
commit b6206e61f624a76c1063cbfd9cd74260aeeee633
diff --git a/astra-db-java/src/main/java/com/datastax/astra/client/databases/Database.java b/astra-db-java/src/main/java/com/datastax/astra/client/databases/Database.java
@@ -4,7 +4,7 @@
  * #%L
  * Data API Java Client
  * --
- * Copyright (C) 2024 DataStax
+ * Copyright (C) 2024 DataStaxcc
  * --
  * Licensed under the Apache License, Version 2.0
  * You may not use this file except in compliance with the License.
@@ -1165,9 +1165,8 @@ public <T> Table<T> getTable(Class<T> rowClass) {
      * @param <T>             the type of the row objects that the table will hold
      * @param tableName       the name of the table to be created; must not be null or empty
      * @param tableDefinition the schema definition of the table; must not be null
-     * @param creatTableOptions additional options for creating the table; optional, can be null
+     * @param createTableOptions additional options for creating the table; optional, can be null
      * @param rowClass        the class representing the row type; must not be null
-     * @param tableOptions    runtime options for interacting with the table; must not be null
      * @return the created table object
      * @throws IllegalArgumentException if any mandatory argument is null or invalid
      *
@@ -1189,31 +1188,48 @@ public <T> Table<T> getTable(Class<T> rowClass) {
      * CreateTableOptions createTableOptions =
      *      new CreateTableOptions().timeout(Duration.ofMillis(1000));
      *
-     * // Optional to override spawn options
-     * TableOptions tableOptions =
-     *      new TableOptions().timeout(Duration.ofMillis(1000));
-     *
      * Table<Row> tableSimple2 = db.createTable("TABLE_SIMPLE", tableDefinition,
-     *  Row.class, createTableOptions,  tableOptions);
+     *  Row.class, createTableOptions);
      * }
      * </pre>
      */
     public <T> Table<T> createTable(String tableName,
                                     TableDefinition tableDefinition,
                                     Class<T> rowClass,
-                                    CreateTableOptions creatTableOptions,
-                                    TableOptions tableOptions) {
+                                    CreateTableOptions createTableOptions) {
         hasLength(tableName, "tableName");
         notNull(tableDefinition, "tableDefinition");
         notNull(rowClass, "rowClass");
+
+        // We are on a different keyspace, create the table on that keyspace
+        if (createTableOptions != null && Utils.hasLength(createTableOptions.getKeyspace())) {
+            String otherKeyspace = createTableOptions.getKeyspace();
+            createTableOptions.keyspace(null);
+            return new Database(
+                    this.rootEndpoint,
+                    this.options.clone().keyspace(otherKeyspace))
+                    .createTable(tableName, tableDefinition, rowClass, createTableOptions);
+        }
+
         Command createTable = Command
                 .create("createTable")
                 .append("name", tableName)
                 .append("definition", tableDefinition);
-        if (creatTableOptions != null) {
-            createTable.append("options", creatTableOptions);
+        if (createTableOptions != null) {
+            createTable.append("options", createTableOptions);
+        }
+        runCommand(createTable, createTableOptions);
+
+        // Spawning a Table inheriting the current database options and the table options
+        TableOptions tableOptions = defaultTableOptions();
+        if (createTableOptions != null) {
+            if (createTableOptions.getDataAPIClientOptions() != null) {
+                tableOptions.dataAPIClientOptions(createTableOptions.getDataAPIClientOptions());
+            }
+            if (createTableOptions.getToken() != null) {
+                tableOptions.token(createTableOptions.getToken());
+            }
         }
-        runCommand(createTable, tableOptions);
         return getTable(tableName, rowClass, tableOptions);
     }
 
@@ -1227,44 +1243,30 @@ public <T> Table<T> createTable(String tableName,
      * @return the created table object
      */
     public <T> Table<T> createTable(String tableName, TableDefinition tableDefinition, Class<T> rowClass) {
-        return createTable(tableName, tableDefinition, rowClass, new CreateTableOptions(), defaultTableOptions());
+        return createTable(tableName, tableDefinition, rowClass, null);
     }
 
     /**
-     * Creates a table with a default row type of {@code Row}.
+     * Creates a table using default options and runtime configurations.
      *
      * @param tableName       the name of the table to be created; must not be null or empty
      * @param tableDefinition the schema definition of the table; must not be null
-     * @return the created table object with rows of type {@code Row}
-     */
-    public Table<Row> createTable(String tableName, TableDefinition tableDefinition) {
-        return createTable(tableName, tableDefinition, Row.class);
-    }
-
-    /**
-     * Creates a table using the specified row class and runtime configurations.
-     *
-     * @param <T>             the type of the row objects that the table will hold
-     * @param tableName       the name of the table to be created; must not be null or empty
-     * @param rowClass        the class representing the row type; must not be null
-     * @param tableDefinition the schema definition of the table; must not be null
-     * @param createTableOptions additional options for creating the table; optional, can be null
+     * @param options         the option to initialize the class.
      * @return the created table object
      */
-    public <T> Table<T> createTable(String tableName, TableDefinition tableDefinition, Class<T> rowClass, CreateTableOptions createTableOptions) {
-        return createTable(tableName, tableDefinition, rowClass, createTableOptions, defaultTableOptions());
+    public Table<Row> createTable(String tableName, TableDefinition tableDefinition, CreateTableOptions options) {
+        return createTable(tableName, tableDefinition, Row.class, options);
     }
 
     /**
-     * Creates a table using the specified row class and runtime configurations.
+     * Creates a table with a default row type of {@code Row}.
      *
      * @param tableName       the name of the table to be created; must not be null or empty
-     * @param createTableOptions additional options for creating the table; optional, can be null
      * @param tableDefinition the schema definition of the table; must not be null
-     * @return the created table object
+     * @return the created table object with rows of type {@code Row}
      */
-    public Table<Row> createTable(String tableName, TableDefinition tableDefinition, CreateTableOptions createTableOptions) {
-        return createTable(tableName, tableDefinition, Row.class, createTableOptions);
+    public Table<Row> createTable(String tableName, TableDefinition tableDefinition) {
+        return createTable(tableName, tableDefinition, Row.class);
     }
 
     /**
@@ -1287,7 +1289,7 @@ public <T> Table<T> createTable(Class<T> rowClass) {
      * @return the created table object
      */
     public <T> Table<T> createTable(Class<T> rowClass, CreateTableOptions createTableOptions) {
-        return createTable(getTableName(rowClass), rowClass, createTableOptions, defaultTableOptions());
+        return createTable(getTableName(rowClass), rowClass, createTableOptions);
     }
 
     /**
@@ -1296,22 +1298,41 @@ public <T> Table<T> createTable(Class<T> rowClass, CreateTableOptions createTabl
      * @param <T>             the type of the row objects that the table will hold
      * @param rowClass        the class representing the row type; must not be null
      * @param tableName       the name of the table to be created; must not be null or empty
-     * @param tableOptions    runtime options for interacting with the table; must not be null
-     * @param createTableOptions additional options for creating the table; optional, can be null
      * @return the created table object
      */
     public <T> Table<T> createTable(String tableName,
         Class<T> rowClass,
-        CreateTableOptions createTableOptions,
-        TableOptions tableOptions) {
+        CreateTableOptions createTableOptions) {
         hasLength(tableName, "tableName");
         notNull(rowClass, "rowClass");
-        // FIX ME INVESTIGATING TO CREATE A TABLE DEFINITION OBJECT
+
+        // We are on a different keyspace, create the table on that keyspace
+        if (createTableOptions != null && Utils.hasLength(createTableOptions.getKeyspace())) {
+            String otherKeyspace = createTableOptions.getKeyspace();
+            createTableOptions.keyspace(null);
+            return new Database(
+                    this.rootEndpoint,
+                    this.options.clone().keyspace(otherKeyspace))
+                    .createTable(tableName, rowClass, createTableOptions);
+        }
+
+        // Building from the command
         Command createTable = new Command("createTable", createTableCommand(tableName, rowClass));
         if (createTableOptions != null) {
             createTable.append("options", createTableOptions);
         }
         runCommand(createTable, createTableOptions);
+
+        // Getting ready for a table
+        TableOptions tableOptions = defaultTableOptions();
+        if (createTableOptions != null) {
+            if (createTableOptions.getDataAPIClientOptions() != null) {
+                tableOptions.dataAPIClientOptions(createTableOptions.getDataAPIClientOptions());
+            }
+            if (createTableOptions.getToken() != null) {
+                tableOptions.token(createTableOptions.getToken());
+            }
+        }
         return getTable(tableName, rowClass, tableOptions);
     }
 
@@ -1391,13 +1412,25 @@ public void dropTable(String tableName) {
      */
     public void dropTable(String tableName, DropTableOptions dropTableOptions) {
         hasLength(tableName, "tableName");
-        Command dropTableCmd = Command
-                .create("dropTable")
-                .append("name", tableName);
-        if (dropTableOptions != null) {
-            dropTableCmd.withOptions(dropTableOptions);
+
+        // We are on a different keyspace, drop the table on a different keyspace
+        if (dropTableOptions != null && Utils.hasLength(dropTableOptions.getKeyspace())) {
+            String otherKeyspace = dropTableOptions.getKeyspace();
+            dropTableOptions.keyspace(null);
+            new Database(
+                    this.rootEndpoint,
+                    this.options.clone().keyspace(otherKeyspace))
+                    .dropTable(tableName, dropTableOptions);
+        } else {
+            // Command on current keyspace
+            Command dropTableCmd = Command
+                    .create("dropTable")
+                    .append("name", tableName);
+            if (dropTableOptions != null) {
+                dropTableCmd.withOptions(dropTableOptions);
+            }
+            runCommand(dropTableCmd, dropTableOptions);
         }
-        runCommand(dropTableCmd, dropTableOptions);
     }
     // ------------------------------------------
     // ----   Drop Indexes                    ---
@@ -1422,13 +1455,26 @@ public void dropTableIndex(String indexName) {
      *      flag to drop index
      */
     public void dropTableIndex(String indexName, DropTableIndexOptions dropIndexOptions) {
-        Command dropIndexCommand = Command
-                .create("dropIndex")
-                .append("name", indexName);
-        if (dropIndexOptions != null) {
-            dropIndexCommand.withOptions(dropIndexOptions);
+        Assert.hasLength(indexName, "indexName");
+
+        // We are on a different keyspace, drop the table on a different keyspace
+        if (dropIndexOptions != null && Utils.hasLength(dropIndexOptions.getKeyspace())) {
+            String otherKeyspace = dropIndexOptions.getKeyspace();
+            dropIndexOptions.keyspace(null);
+            new Database(
+                    this.rootEndpoint,
+                    this.options.clone().keyspace(otherKeyspace))
+                    .dropTableIndex(indexName, dropIndexOptions);
+        } else {
+            // Command on current keyspace
+            Command dropIndexCommand = Command
+                    .create("dropIndex")
+                    .append("name", indexName);
+            if (dropIndexOptions != null) {
+                dropIndexCommand.withOptions(dropIndexOptions);
+            }
+            runCommand(dropIndexCommand, dropIndexOptions);
         }
-        runCommand(dropIndexCommand, dropIndexOptions);
     }
 
     // ------------------------------------------

diff --git a/...a/src/main/java/com/datastax/astra/client/tables/commands/options/CreateTableOptions.java b/...a/src/main/java/com/datastax/astra/client/tables/commands/options/CreateTableOptions.java
@@ -22,6 +22,7 @@
 
 import com.datastax.astra.client.core.options.BaseOptions;
 import com.datastax.astra.client.core.commands.CommandType;
+import com.datastax.astra.client.core.options.DataAPIClientOptions;
 import lombok.Setter;
 import lombok.experimental.Accessors;
 
@@ -37,6 +38,11 @@ public class CreateTableOptions extends BaseOptions<CreateTableOptions> {
     /** Improve syntax. */
     public static final CreateTableOptions IF_NOT_EXISTS = new CreateTableOptions().ifNotExists(true);
 
+    /**
+     * The keyspace to use for the database.
+     */
+    String keyspace = DataAPIClientOptions.DEFAULT_KEYSPACE;
+
     /**
      * Condition to upsert the table.
      */
@@ -56,4 +62,13 @@ public boolean isIfNotExists() {
         return ifNotExists;
     }
 
+    /**
+     * Gets keyspace
+     *
+     * @return value of keyspace
+     */
+    public String getKeyspace() {
+        return keyspace;
+    }
+
 }
diff --git a/...rc/main/java/com/datastax/astra/client/tables/commands/options/DropTableIndexOptions.java b/...rc/main/java/com/datastax/astra/client/tables/commands/options/DropTableIndexOptions.java
@@ -21,6 +21,7 @@
  */
 
 import com.datastax.astra.client.core.options.BaseOptions;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.Setter;
 import lombok.experimental.Accessors;
 
@@ -29,7 +30,7 @@
 
 @Setter
 @Accessors(fluent = true, chain = true)
-public class DropTableIndexOptions extends BaseOptions<DropTableOptions> {
+public class DropTableIndexOptions extends BaseOptions<DropTableIndexOptions> {
 
     /** Improve syntax. */
     public static final DropTableIndexOptions IF_EXISTS = new DropTableIndexOptions().ifExists(true);
@@ -39,6 +40,11 @@ public class DropTableIndexOptions extends BaseOptions<DropTableOptions> {
      */
     boolean ifExists = true;
 
+    /**
+     * Keyspace where to execute this command
+     */
+    private String keyspace;
+
     public DropTableIndexOptions() {
         super(null, TABLE_ADMIN, DEFAULT_TABLE_SERIALIZER, null);
     }
@@ -53,4 +59,13 @@ public boolean isIfExists() {
         return ifExists;
     }
 
+    /**
+     * Gets keyspace
+     *
+     * @return value of keyspace
+     */
+    @JsonIgnore
+    public String getKeyspace() {
+        return keyspace;
+    }
 }
diff --git a/...ava/src/main/java/com/datastax/astra/client/tables/commands/options/DropTableOptions.java b/...ava/src/main/java/com/datastax/astra/client/tables/commands/options/DropTableOptions.java
@@ -21,6 +21,7 @@
  */
 
 import com.datastax.astra.client.core.options.BaseOptions;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.Setter;
 import lombok.experimental.Accessors;
 
@@ -34,6 +35,8 @@ public class DropTableOptions extends BaseOptions<DropTableOptions> {
     /** Improve syntax. */
     public static final DropTableOptions IF_EXISTS = new DropTableOptions().ifExists(true);
 
+    private String keyspace;
+
     /**
      * Condition to upsert the table.
      */
@@ -53,6 +56,13 @@ public boolean isIfExists() {
         return ifExists;
     }
 
-
-
+    /**
+     * Gets keyspace
+     *
+     * @return value of keyspace
+     */
+    @JsonIgnore
+    public String getKeyspace() {
+        return keyspace;
+    }
 }
diff --git a/...va/src/main/java/com/datastax/astra/client/tables/commands/options/ListTablesOptions.java b/...va/src/main/java/com/datastax/astra/client/tables/commands/options/ListTablesOptions.java
@@ -37,7 +37,6 @@ public class ListTablesOptions extends BaseOptions<ListTablesOptions> {
      */
     String keyspace = DataAPIClientOptions.DEFAULT_KEYSPACE;
 
-
     public ListTablesOptions() {
         super(null, TABLE_ADMIN, new RowSerializer(), null);
     }

diff --git a/astra-db-java/src/main/java/com/datastax/astra/internal/utils/Utils.java b/astra-db-java/src/main/java/com/datastax/astra/internal/utils/Utils.java
@@ -1,5 +1,25 @@
 package com.datastax.astra.internal.utils;
 
+/*-
+ * #%L
+ * Data API Java Client
+ * --
+ * Copyright (C) 2024 DataStax
+ * --
+ * Licensed under the Apache License, Version 2.0
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+
 /**
  * Utility class for internal usage
  */
-Original file line number
+Diff line change
@@ Expand Up @@
          */
         String keyspace = DataAPIClientOptions.DEFAULT_KEYSPACE;
         public ListTablesOptions() {
             super(null, TABLE_ADMIN, new RowSerializer(), null);
         }
@@ Expand Down @@