update createKeyspace

Author: clun

astra-db-java-tools/pom.xml

@@ -7,7 +7,7 @@
     <parent>
         <groupId>com.datastax.astra</groupId>
         <artifactId>astra-db-java-parent</artifactId>
-        <version>2.0.0-PREVIEW1-SNAPSHOT</version>
+        <version>2.0.0-PREVIEW2</version>
     </parent>
 
     <dependencies>

astra-db-java-tools/src/main/java/com/datastax/astra/tool/loader/rag/RagRepository.java

@@ -7,12 +7,13 @@
 import com.datastax.astra.client.core.vectorize.VectorServiceOptions;
 import com.datastax.astra.client.databases.Database;
 import com.datastax.astra.client.databases.DatabaseOptions;
+import com.datastax.astra.client.databases.commands.options.CreateKeyspaceOptions;
 import com.datastax.astra.client.databases.definition.DatabaseInfo;
+import com.datastax.astra.client.databases.definition.keyspaces.KeyspaceDefinition;
 import com.datastax.astra.client.tables.Table;
 import com.datastax.astra.client.tables.commands.options.CreateTableOptions;
 import com.datastax.astra.client.tables.commands.options.CreateVectorIndexOptions;
 import com.datastax.astra.client.tables.definition.rows.Row;
-import com.datastax.astra.internal.utils.Utils;
 import com.datastax.astra.tool.loader.rag.ingestion.RagEmbeddingsModels;
 import com.datastax.astra.tool.loader.rag.ingestion.RagIngestionConfig;
 import com.datastax.astra.tool.loader.rag.ingestion.RagIngestionJob;
@@ -24,6 +25,8 @@
 import java.util.Optional;
 import java.util.UUID;
 
+import static com.datastax.astra.internal.utils.Assert.notNull;
+
 @Slf4j
 public class RagRepository {
 
@@ -53,7 +56,9 @@ public Database getOrCreateDatabase(UUID tenantId) {
                 log.info("Database {} does not exists and will be created.", tenantId.toString());
                 DatabaseAdmin dbAdmin = astraDBAdmin
                         .createDatabase(tenantId.toString(), cloudProvider, cloudRegion);
-                dbAdmin.createKeyspace(keyspace, true);
+                dbAdmin.createKeyspace(
+                        new KeyspaceDefinition().name(keyspace),
+                        new CreateKeyspaceOptions().updateDBKeyspace(true));
                 return dbAdmin.getDatabase(keyspace);
             }
             log.info("Database {} already exists.", tenantId);
@@ -128,8 +133,7 @@ public Table<RagStore> getTableRagStore(UUID tenantId, RagIngestionConfig config
     }
 
     public Table<RagStore> getTableRagStore(Database db, String provider, String model, int dimension, VectorServiceOptions options) {
-        Utils.hasLength(provider);
-        Utils.hasLength(model);
+        notNull(provider, "provider");
         String tableName = RagStore.getTableName(provider, model);
         db.useKeyspace(keyspace);
 

astra-db-java/src/main/java/com/datastax/astra/client/admin/AdminOptions.java

@@ -58,7 +58,7 @@ public class AdminOptions extends BaseOptions<AdminOptions> {
      * Serializer for the collections.
      * Defaults to {@link DatabaseSerializer}.
      */
-    private static final DataAPISerializer DEFAULT_SERIALIZER = new DatabaseSerializer();
+    public static final DataAPISerializer DEFAULT_SERIALIZER = new DatabaseSerializer();
 
     /**
      * Serializer for the collections.

astra-db-java/src/main/java/com/datastax/astra/client/admin/AstraDBDatabaseAdmin.java

@@ -23,13 +23,17 @@
 import com.datastax.astra.client.DataAPIDestination;
 import com.datastax.astra.client.core.options.BaseOptions;
 import com.datastax.astra.client.core.options.DataAPIClientOptions;
+import com.datastax.astra.client.databases.commands.options.CreateKeyspaceOptions;
+import com.datastax.astra.client.databases.commands.options.DropKeyspaceOptions;
 import com.datastax.astra.client.databases.commands.results.FindEmbeddingProvidersResult;
 import com.datastax.astra.client.databases.DatabaseOptions;
 import com.datastax.astra.client.databases.commands.results.FindRerankingProvidersResult;
+import com.datastax.astra.client.databases.definition.keyspaces.KeyspaceDefinition;
 import com.datastax.astra.internal.api.AstraApiEndpoint;
 import com.datastax.astra.internal.command.AbstractCommandRunner;
 import com.datastax.astra.internal.utils.Assert;
 import com.dtsx.astra.sdk.db.AstraDBOpsClient;
+import com.dtsx.astra.sdk.db.DbKeyspacesClient;
 import com.dtsx.astra.sdk.db.domain.Database;
 import com.dtsx.astra.sdk.db.exception.DatabaseNotFoundException;
 import com.dtsx.astra.sdk.utils.AstraEnvironment;
@@ -203,26 +207,36 @@ public FindRerankingProvidersResult findRerankingProviders() {
 
     /** {@inheritDoc} */
     @Override
-    public void createKeyspace(String keyspace, boolean updateDBKeyspace) {
-        log.debug("createKeyspace");
-        devopsDbClient.database(databaseId.toString()).keyspaces().create(keyspace);
+    public void createKeyspace(String keyspace) {
+        createKeyspace(
+                new KeyspaceDefinition().name(keyspace),
+                new CreateKeyspaceOptions().ifNotExists(true));
+    }
+
+    @Override
+    public void createKeyspace(KeyspaceDefinition keyspace, CreateKeyspaceOptions options) {
+        String keyspaceName  = keyspace.getName();
+        DbKeyspacesClient ks = devopsDbClient.database(databaseId.toString()).keyspaces();
+        if (!ks.exist(keyspaceName) && options.isIfNotExists()) {
+            ks.create(keyspaceName);
+        }
     }
 
     /** {@inheritDoc} */
     @Override
     public void dropKeyspace(String keyspace) {
         log.debug("dropKeyspace");
-        try {
-            devopsDbClient.database(databaseId.toString()).keyspaces().delete(keyspace);
-        } catch(NullPointerException e) {
-            // Left blank to parse output from a delete
-        }
+        dropKeyspace(keyspace, new DropKeyspaceOptions().ifExists(true));
     }
 
+    /** {@inheritDoc} */
     @Override
-    public void dropKeyspace(String keyspace, BaseOptions<?> options) {
+    public void dropKeyspace(String keyspace, DropKeyspaceOptions options) {
         log.warn("CommandOptions are not supported for dropKeyspace in Astra MODE");
-        dropKeyspace(keyspace);
+        DbKeyspacesClient ks = devopsDbClient.database(databaseId.toString()).keyspaces();
+        if (ks.exist(keyspace) && options.isIfExists()) {
+            ks.delete(keyspace);
+        }
     }
 
     /** {@inheritDoc} */

astra-db-java/src/main/java/com/datastax/astra/client/admin/DataAPIDatabaseAdmin.java

@@ -20,20 +20,21 @@
  * #L%
  */
 
-import com.datastax.astra.client.core.options.BaseOptions;
 import com.datastax.astra.client.core.commands.Command;
 import com.datastax.astra.client.core.commands.CommandType;
 import com.datastax.astra.client.core.rerank.RerankProvider;
-import com.datastax.astra.client.databases.commands.results.FindEmbeddingProvidersResult;
 import com.datastax.astra.client.core.vectorize.EmbeddingProvider;
 import com.datastax.astra.client.databases.Database;
+import com.datastax.astra.client.databases.commands.options.CreateKeyspaceOptions;
+import com.datastax.astra.client.databases.commands.options.DropKeyspaceOptions;
+import com.datastax.astra.client.databases.commands.results.FindEmbeddingProvidersResult;
 import com.datastax.astra.client.databases.commands.results.FindRerankingProvidersResult;
+import com.datastax.astra.client.databases.definition.keyspaces.KeyspaceDefinition;
 import com.datastax.astra.client.databases.definition.keyspaces.KeyspaceOptions;
 import com.datastax.astra.internal.api.DataAPIResponse;
 import com.datastax.astra.internal.command.AbstractCommandRunner;
 import com.datastax.astra.internal.serdes.DataAPISerializer;
 import com.datastax.astra.internal.serdes.collections.DocumentSerializer;
-import com.datastax.astra.internal.utils.Assert;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 
@@ -139,14 +140,23 @@ public Database getDatabase(String keyspace, String userToken) {
                 .keyspace(keyspace));
     }
 
-    /** {@inheritDoc} */
     @Override
-    public void createKeyspace(String keyspace, boolean updateDBKeyspace) {
-        Assert.hasLength(keyspace, ARG_KEYSPACE);
-        createKeyspace(keyspace, KeyspaceOptions.simpleStrategy(1));
-        if (updateDBKeyspace) {
-            db.useKeyspace(keyspace);
+    public void createKeyspace(KeyspaceDefinition keyspace, CreateKeyspaceOptions options) {
+        notNull(keyspace, ARG_KEYSPACE);
+        hasLength(keyspace.getName(), ARG_KEYSPACE);
+        Command createKeyspace = Command
+                .create("createKeyspace")
+                .append("name", keyspace.getName());
+        if (keyspace.getReplication() != null) {
+            KeyspaceOptions keyspaceOptions = new KeyspaceOptions();
+            keyspaceOptions.setReplication(keyspace.getReplication());
+            createKeyspace.withOptions(keyspaceOptions);
+        }
+        runCommand(createKeyspace);
+        if (options != null && options.isUpdateDBKeyspace()) {
+            db.useKeyspace(keyspace.getName());
         }
+        log.info("Keyspace  '" + green("{}") + "' has been created", keyspace.getName());
     }
 
     /**
@@ -169,7 +179,7 @@ public void createKeyspace(String keyspace, KeyspaceOptions options) {
     }
 
     @Override
-    public void dropKeyspace(String keyspace, BaseOptions<?> options) {
+    public void dropKeyspace(String keyspace, DropKeyspaceOptions options) {
         hasLength(keyspace, ARG_KEYSPACE);
         Command dropNamespace = Command
                 .create("dropKeyspace")

astra-db-java/src/main/java/com/datastax/astra/client/admin/DatabaseAdmin.java

@@ -25,8 +25,12 @@
 import com.datastax.astra.client.databases.Database;
 import com.datastax.astra.client.core.commands.CommandRunner;
 import com.datastax.astra.client.core.vectorize.EmbeddingProvider;
+import com.datastax.astra.client.databases.commands.options.CreateKeyspaceOptions;
+import com.datastax.astra.client.databases.commands.options.DropKeyspaceOptions;
 import com.datastax.astra.client.databases.commands.results.FindEmbeddingProvidersResult;
 import com.datastax.astra.client.databases.commands.results.FindRerankingProvidersResult;
+import com.datastax.astra.client.databases.definition.keyspaces.KeyspaceDefinition;
+import com.datastax.astra.client.databases.definition.keyspaces.KeyspaceInformation;
 import com.datastax.astra.internal.utils.Assert;
 
 import java.util.Set;
@@ -240,7 +244,28 @@ default void dropKeyspace(String keyspace) {
      *                  keyspace does not exist, ensuring consistent behavior.
      * @param options The options to use for the operation.
      */
-    void dropKeyspace(String keyspace, BaseOptions<?> options);
+    void dropKeyspace(String keyspace, DropKeyspaceOptions options);
+
+    /**
+     * Asynchronously drops (deletes) the specified keyspace from the database. This operation is idempotent, meaning
+     * it will not produce an error if the keyspace does not exist. Performing this operation asynchronously ensures
+     * that the calling thread remains responsive, and can be particularly useful for applications that require high
+     * availability and cannot afford to block on potentially long-running operations. Just like its synchronous counterpart,
+     * this method should be used with caution as dropping a keyspace will remove all associated data, collections,
+     * or tables, and this action is irreversible.
+     *
+     * This example illustrates the non-blocking nature of dropping a keyspace. It demonstrates the method's utility in
+     * maintaining application responsiveness, even when performing potentially long-running database operations.
+     *
+     * @param keyspace The name of the keyspace to be dropped. This is the target keyspace that will be deleted.
+     *                  The asynchronous nature of this method means that it will execute without blocking the calling
+     *                  thread, regardless of whether the keyspace exists or not, ensuring a consistent and responsive
+     *                  application behavior.
+     * @param options The options to use for the operation to drop the keyspace like a timeout or if exists.
+     */
+    default void dropKeyspaceAsync(String keyspace, DropKeyspaceOptions options) {
+        CompletableFuture.runAsync(() -> dropKeyspace(keyspace, options));
+    }
 
     /**
      * Asynchronously drops (deletes) the specified keyspace from the database. This operation is idempotent, meaning
@@ -263,25 +288,35 @@ default void dropKeyspaceAsync(String keyspace) {
     }
 
     /**
-     * Create a Keyspace providing a name.
+     * Syntax Sugar, retro compatible.
      *
      * @param keyspace
-     *      current keyspace.
-     * @param updateDBKeyspace
-     *      if the keyspace should be updated in the database.
-     */
-    void createKeyspace(String keyspace, boolean updateDBKeyspace);
+     *      current namespace.
+     **/
+    default void createKeyspace(String keyspace) {
+        createKeyspace(new KeyspaceDefinition().name(keyspace), new CreateKeyspaceOptions());
+    }
 
     /**
      * Syntax Sugar, retro compatible.
      *
      * @param keyspace
      *      current namespace.
      **/
-    default void createKeyspace(String keyspace) {
-        createKeyspace(keyspace, false);
+    default void createKeyspace(KeyspaceDefinition keyspace) {
+        createKeyspace(keyspace, new CreateKeyspaceOptions());
     }
 
+    /**
+     * Create a Keyspace providing a name.
+     *
+     * @param keyspace
+     *      keyspace definition
+     * @param options
+     *      options to create the keyspace
+     */
+    void createKeyspace(KeyspaceDefinition keyspace, CreateKeyspaceOptions options);
+
     /**
      * Create a keyspace providing a name.
      *

astra-db-java/src/main/java/com/datastax/astra/client/databases/commands/options/CreateKeyspaceOptions.java

@@ -0,0 +1,77 @@
+package com.datastax.astra.client.databases.commands.options;
+
+/*-
+ * #%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%
+ */
+
+import com.datastax.astra.client.admin.AdminOptions;
+import com.datastax.astra.client.core.commands.CommandType;
+import com.datastax.astra.client.core.options.BaseOptions;
+import com.datastax.astra.client.core.options.DataAPIClientOptions;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import static com.datastax.astra.client.tables.Table.DEFAULT_TABLE_SERIALIZER;
+
+/**
+ * Set of options used when creating a table
+ */
+@Setter
+@Accessors(fluent = true, chain = true)
+public class CreateKeyspaceOptions extends BaseOptions<CreateKeyspaceOptions> {
+
+    /** Improve syntax. */
+    public static final CreateKeyspaceOptions IF_NOT_EXISTS = new CreateKeyspaceOptions().ifNotExists(true);
+
+    /**
+     * Condition to upsert the table.
+     */
+    boolean ifNotExists = true;
+
+    /**
+     * Change the keyspace in the database.
+     */
+    boolean updateDBKeyspace = false;
+
+    /**
+     * Default constructor
+     */
+    public CreateKeyspaceOptions() {
+        super(null, CommandType.DATABASE_ADMIN, AdminOptions.DEFAULT_SERIALIZER, null);
+    }
+
+    /**
+     * Gets ifNotExists
+     *
+     * @return value of ifNotExists
+     */
+    public boolean isIfNotExists() {
+        return ifNotExists;
+    }
+
+    /**
+     * Gets updateDBKeyspace
+     *
+     * @return value of updateDBKeyspace
+     */
+    public boolean isUpdateDBKeyspace() {
+        return updateDBKeyspace;
+    }
+}