database = client.get_database_by_api_endpoint("API_ENDPOINT")

database = client["API_ENDPOINT"]

database = client.get_database_by_api_endpoint(
    "API_ENDPOINT",
    namespace="NAMESPACE",
)

from astrapy import DataAPIClient
client = DataAPIClient("TOKEN")

database = my_client.get_database_by_api_endpoint("01234567-...")
collection = database.create_collection("movies", dimension=512)
collection.insert_one({"title": "The Title"}, vector=...)

const db = client.db('API_ENDPOINT');

const db = client.db('API_ENDPOINT', { namespace: 'NAMESPACE' });

import { DataAPIClient } from '@datastax/astra-db-ts'

const client = new DataAPIClient('TOKEN');

// Connect to a database using a direct endpoint
const db1 = client.db('API_ENDPOINT');

// Overrides default options from the DataAPIClient
const db2 = client.db('API_ENDPOINT', {
  namespace: 'NAMESPACE',
  token: 'WEAKER_TOKEN',
});

// Lets you connect using a database ID and region
const db3 = client.db('DB_ID', 'REGION');

// Use the database
(async function () {
  const collection = db1.collection('movies');
  await collection.insertOne({ title: 'The Italian Job' }, { vector: [...] });
})();

// Given 'client' an instance of 'DataAPIClient'
Database db1 = client.getDatabase(String apiEndpoint);
Database db2 = client.getDatabase(String apiEndpoint, String namespace);
Database db3 = client.getDatabase(UUID databaseId);
Database db4 = client.getDatabase(UUID databaseId, String namespace);
Database db5 = client.getDatabase(UUID databaseId, String namespace, String region);

package com.datastax.astra.client;


import com.dtsx.astra.sdk.db.domain.CloudProviderType;

import java.util.UUID;

public class Connecting {
    public static void main(String[] args) {
        // Preferred Access with DataAPIClient (default options)
        DataAPIClient client = new DataAPIClient("TOKEN");

        // Overriding the default options
        DataAPIClient client1 = new DataAPIClient("TOKEN", DataAPIOptions
                .builder()
                .withHttpConnectTimeout(10)
                .withHttpRequestTimeout(10)
                .build());

        // Access the Database from its endpoint
        Database db1 = client1.getDatabase("API_ENDPOINT");
        Database db2 = client1.getDatabase("API_ENDPOINT", "NAMESPACE");

        // Access the Database from its endpoint
        UUID databaseId = UUID.fromString("f5abf92f-ff66-48a0-bbc2-d240bc25dc1f");
        Database db3 = client.getDatabase(databaseId);
        Database db4 = client.getDatabase(databaseId, "NAMESPACE");
        Database db5 = client.getDatabase(databaseId, "NAMESPACE", "us-east-2");

    }
}

curl -s --location \
--request POST ${ASTRA_DB_API_ENDPOINT}/api/json/v1/${ASTRA_DB_KEYSPACE} \
--header "Token: ${ASTRA_DB_APPLICATION_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json"

astra db describe <database_name>
astra db describe <database_uid>

new_db_admin = admin.create_database(
    "new_database",
    cloud_provider="aws",
    region="ap-south-1",
)

from astrapy import DataAPIClient
client = DataAPIClient("TOKEN")
admin = client.get_admin()
new_db_admin = admin.create_database(
    "new_database",
    cloud_provider="aws",
    region="ap-south-1",
)
new_db = new_db_admin.get_database()
coll = new_db.create_collection("movies", dimension=512)
coll.insert_one({"title": "The Title"}, vector=...)

const newDbAdmin = await admin.createDatabase({
  name: 'new-database',
  region: 'us-east1',
  cloudProvider: 'GCP',
});

import { DataAPIClient } from '@datastax/astra-db-ts'

// Obtain an admin instance
const admin = new DataAPIClient('TOKEN').admin();

(async function () {
  // Create a new database
  const dbAdmin = await admin.createDatabase({
    name: 'my-database',
    region: 'us-east1',
    cloudProvider: 'GCP',
  });

  // Get and use the database
  const db = dbAdmin.db();
  console.log(await db.listCollections());
})();

// Given 'client' an instance of 'DataAPIClient'
AstraDBAdmin admin = client.getAdmin();
DatabaseAdmin dbAdmin1 = admin.createDatabase(String name);
DatabaseAdmin dbAdmin2 = admin.createDatabase(String name, CloudProviderType cloud, String cloudRegion);
DatabaseAdmin dbAdmin3 = admin.createDatabase(String name, CloudProviderType cloud, String cloudRegion, boolean waitActive);

package com.datastax.astra.client.admin;

import com.datastax.astra.client.admin.AstraDBAdmin;
import com.datastax.astra.client.DataAPIClient;
import com.dtsx.astra.sdk.db.domain.CloudProviderType;

import java.util.UUID;

public class CreateDatabase {
  public static void main(String[] args) {
    AstraDBAdmin astraDBAdmin = new DataAPIClient("TOKEN").getAdmin();

    // Choose a cloud provider (GCP, AZURE, AWS) and a region
    CloudProviderType cloudProvider = CloudProviderType.GCP;
    String cloudRegion = "us-east1";

    // Create a database
    DatabaseAdmin admin = astraDBAdmin.createDatabase("DATABASE_NAME", cloudProvider, cloudRegion);
  }
}

astra db create <db_name> \
   --region <region>
   --cloud <cloud>  \
   -k <keyspace> \
   --if-not-exist
   --async

db_info = admin.database_info("01234567-...")

from astrapy import DataAPIClient
client = DataAPIClient("TOKEN")
admin = client.get_admin()

db_details = admin.database_info("01234567-...")
db_details.id
# '01234567-...'
db_details.status
# 'ACTIVE'
db_details.info.region
# 'eu-west-1'

// Given 'admin' an instance of 'AstraDBAdmin'
DatabaseInfo info = admin.getDatabaseInfo(UUID id);

package com.datastax.astra.client.admin;

import com.datastax.astra.client.admin.AstraDBAdmin;
import com.datastax.astra.client.DataAPIClient;
import com.datastax.astra.client.model.DatabaseInfo;

import java.util.UUID;

public class GetDatabaseInformation {
  public static void main(String[] args) {

    AstraDBAdmin astraDBAdmin = new DataAPIClient("TOKEN").getAdmin();

    // Check if a database exists
    boolean exists1 = astraDBAdmin.databaseExists("database_name");
    boolean exists2 = astraDBAdmin.databaseExists(UUID.fromString("<database_id>"));

    // Find a database by name (names may not be unique)
    DatabaseInfo databaseInformation = astraDBAdmin
            .getDatabaseInfo(UUID.fromString("<database_id>"));
    System.out.println("Name=" + databaseInformation.getName());
  }
}

astra db describe <database_name>
astra db describe <database_id>

all_databases = admin.list_databases()

from astrapy import DataAPIClient
client = DataAPIClient("TOKEN")
admin = client.get_admin()

database_cursor = admin.list_databases()
database_list = list(database_cursor)
len(database_list)
# 3
database_list[2].id
# '01234567-...'
database_list[2].status
# 'ACTIVE'
database_list[2].info.region
# 'eu-west-1'

const dbs = await admin.listDatabases();

import { DataAPIClient } from '@datastax/astra-db-ts'

const admin = new DataAPIClient('TOKEN').admin();

(async function () {
  const activeDbs = await admin.listDatabases({ include: 'ACTIVE' });

  for (const db of activeDbs) {
    console.log(`Database ${db.name} is active`);
  }
})();

// Given 'admin' an instance of 'AstraDBAdmin'
String<String> nameList = admin.listDatabaseNames();
String<DatabaseInfo> infoList = admin.listDatabases();

package com.datastax.astra.client.admin;

import com.datastax.astra.client.DataAPIClient;
import com.datastax.astra.client.model.DatabaseInfo;

public class ListDatabases {
    public static void main(String[] args) {
        
        // Initialization of admin (astra only)
        AstraDBAdmin astraDBAdmin = new DataAPIClient("TOKEN").getAdmin();

        // Display all database information
        astraDBAdmin.listDatabases().stream()
                .map(DatabaseInfo::getId)
                .forEach(System.out::println);

        // Display all database names
        astraDBAdmin.listDatabaseNames();
    }
}

astra db list

admin.drop_database("01234567-...")

from astrapy import DataAPIClient
client = DataAPIClient("TOKEN")
admin = client.get_admin()

database_list_pre = list(admin.list_databases())
len(database_list_pre)
# 3
admin.drop_database("01234567-...")
# {'ok': 1}
database_list_post = list(admin.list_databases())
len(database_list_post)
# 2

await admin.dropDatabase('DB_ID');

import { DataAPIClient } from '@datastax/astra-db-ts'

const admin = new DataAPIClient('TOKEN').admin();

(async function () {
  await admin.dropDatabase('DB_ID');
})();

boolean AstraDBAdmin.deleteDatabase(String name);
boolean AstraDBAdmin.deleteDatabase(UUID id);

package com.datastax.astra.client.admin;

import com.datastax.astra.client.admin.AstraDBAdmin;
import com.datastax.astra.client.DataAPIClient;

import java.util.UUID;

public class DropDatabase {
  public static void main(String[] args) {
    AstraDBAdmin astraDBAdmin = new DataAPIClient("TOKEN").getAdmin();

    // Delete an existing database
    astraDBAdmin.dropDatabase("<database_name>");

    // Delete an existing database by ID
    astraDBAdmin.dropDatabase(UUID.fromString("<database_id>"));

  }
}

astra db delete <db_name>
astra db delete <db_id>