Collections reference

collection = database.create_collection(
  "DB_COLLECTION",
  namespace="DB_NAMESPACE"),
  check_exists=False)

collection = database.create_collection(
    "vector_test3",
    dimension=5,
    metric=VectorMetric.COSINE,  # or simply "cosine"
    keyspace=DB_KEYSPACE,
    check_exists=False,
)
print(f"* Collection: {collection.full_name}\n")

collection = database.create_collection(
    "vector_test3",
    dimension=5,
    metric=VectorMetric.COSINE,  # or simply "cosine"
    service={"provider": OPEN_AI_PROVIDER, "modelName": MODEL_NAME},
        embedding_api_key=OPENAI_API_KEY,
    keyspace=DB_KEYSPACE,
    check_exists=False,
)
print(f"* Collection: {collection.full_name}\n")

# Create a collection. The default similarity metric is cosine. If you're not
# sure what dimension to set, use whatever dimension vector your embeddings
# model produces.
collection = database.create_collection(
    DB_COLLECTION,
    dimension=5,
    metric=VectorMetric.COSINE,  # or simply "cosine"
    service={"provider": OPEN_AI_PROVIDER, "modelName": MODEL_NAME},
        embedding_api_key=OPENAI_API_KEY,
    keyspace=DB_KEYSPACE,
    check_exists=False,
)
print(f"* Collection: {collection.full_name}\n")

const collection = await db.createCollection(
  'COLLECTION' {
    keyspace: 'KEYSPACE',
    checkExists: false,
  });

  const collection = await db.createCollection<Idea>('vector_test', {
    keyspace: DB_KEYSPACE,
    vector: {
      dimension: 5,
      metric: 'cosine',
    },
    checkExists: false
  });
  console.log(* Created collection ${collection.keyspace}.${collection.collectionName});

  const collection = await db.createCollection<Idea>('vector_test', {
    keyspace: DB_KEYSPACE,
    vector: {
      service: {
        provider: OPEN_AI_PROVIDER,
        modelName: MODEL_NAME
      },
      dimension: 5,
      metric: 'cosine',
    },
    embeddingApiKey: OPENAI_API_KEY,
    checkExists: false
  });
  console.log(* Created collection ${collection.keyspace}.${collection.collectionName});

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

// Get a new Db instance
const db = new DataAPIClient('TOKEN').db('DB_API_ENDPOINT');

// Define the schema for the collection
interface User extends VectorDoc {
  name: string,
  age?: number,
}

(async function () {
  // Create a basic untyped non-vector collection
  const users1 = await db.createCollection('users');
  await users1.insertOne({ name: 'John' });

  // Typed collection with custom options in a non-default keyspace
  const users2 = await db.createCollection<User>('users', {
    keyspace: 'KEYSPACE',
    defaultId: {
      type: 'objectId',
    },
    vector: {
      dimension: 5,
      metric: 'cosine',
    },
  });
  await users2.insertOne({ name: 'John' }, { vector: [.12, .62, .87, .16, .72] });
})();

// Create a collection
Collection<Document> collectionLyrics =  db.createCollection(collectionName, CollectionOptions.builder()
.build()

// Create collections with vector options
Collection<Document> collectionLyrics =  db.createCollection(collectionName, CollectionOptions.builder()
.vectorDimension(5)
.vectorSimilarity(SimilarityMetric.COSINE)
.build()

// Create a collection with Vector embeddings OPEN AI
Collection<Document> collectionLyrics =  db.createCollection(collectionName, CollectionOptions.builder()
.vectorSimilarity(SimilarityMetric.COSINE)
.vectorDimension(openAiEmbeddingDimension)
.vectorize(openAiProvider, openAiModel)
.build(),
new CommandOptions<>().embeddingAPIKey(openAiKey));

        // Create a collection
        Collection<Document> collectionLyrics =  db.createCollection(collectionName, CollectionOptions.builder()
        .vectorDimension(5)
        .vectorSimilarity(SimilarityMetric.COSINE)
        .build(),
        System.out.println("5/7 - Collection created");
        // Create a collection with Vector embeddings OPEN AI
        Collection<Document> collectionLyrics =  db.createCollection(collectionName, CollectionOptions.builder()
        .vectorSimilarity(SimilarityMetric.COSINE)
        .vectorDimension(openAiEmbeddingDimension)
        .vectorize(openAiProvider, openAiModel)
        .build(),
        new CommandOptions<>().embeddingAPIKey(openAiKey));
        System.out.println("5/7 - Collection created with OpenAI embeddings");

database.list_collections(DB_KEYSPACE)

database.list_collections()

console.log(await db.listCollections());

  console.log(await db.listCollections());

db.listCollections().forEach(System.out::println);

        // List all collections
        db.listCollections().forEach(System.out::println);

database.get_database_admin().list_collection_names()

database.get_database_admin().list_collection_names(keyspace=DB_KEYSPACE)

database.list_collection_names()

const collectionNames = await db.listCollections({ nameOnly: true });

const collectionNames = await db.listCollections({ nameOnly: true, keyspace: DB_KEYSPACE });

(async function () {
  // Gets just names of all collections in db
  const collections = await db.listCollections({ nameOnly: true });

  for (const collectionName of collections) {
    console.log(`Collection '${collectionName}' exists`);
  }
})();

// Given db Database object, list all collections
Stream<String> collection = listCollectionsNames();

package com.datastax.astra.client.database;

import com.datastax.astra.client.DataAPIClient;
import com.datastax.astra.client.collections.definition.CollectionDescriptor;
import com.datastax.astra.client.databases.Database;

import java.util.List;

public class ListCollections {
    public static void main(String[] args) {
        Database db = new DataAPIClient("TOKEN")
                .getDatabase("API_ENDPOINT");

        // Get collection Names
        List<String> collectionNames = db.listCollectionNames();

        // Get Collection information (with options)
        List<CollectionDescriptor> collections = db.listCollections();
        collections.stream().map(CollectionDescriptor::getOptions).forEach(System.out::println);
    }
}

collection = database.get_collection("vector_test")

collection1 = database["vector_test"]
collection2 = database.vector_test

from astrapy import DataAPIClient
client = DataAPIClient("TOKEN")
database = my_client.get_database("DB_API_ENDPOINT")

collection = database.get_collection("my_collection")
collection.count_documents({}, upper_bound=100)  # will print e.g.: 41

const collection = db.collection('DB_COLLECTION');

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

// Get a new Db instance
const db = new DataAPIClient('TOKEN').db('DB_API_ENDPOINT');

// Define the schema for the collection
interface User {
  name: string,
  age?: number,
}

(async function () {
  // Basic untyped collection
  const users1 = db.collection('users');
  await users1.insertOne({ name: 'John' });

  // Typed collection from different keyspace with a specific embedding API key
  const users2 = db.collection<User>('users', {
    keyspace: 'DB_KEYSPACE',
    embeddingApiKey: 'EMBEDDINGS_API_KEY',
  });
  await users2.insertOne({ name: 'John' });
})();

// Given db Database object, list all collections
Collection<Document> collection = db.getCollection("collection_name");

// Gather collection information
CollectionOptions options = collection.getOptions();

package com.datastax.astra.client.database;

import com.datastax.astra.client.DataAPIClient;
import com.datastax.astra.client.collections.Collection;
import com.datastax.astra.client.collections.definition.CollectionDefinition;
import com.datastax.astra.client.collections.definition.documents.Document;
import com.datastax.astra.client.databases.Database;

public class FindCollection {
  public static void main(String[] args) {
    Database db = new DataAPIClient("TOKEN")
            .getDatabase("API_ENDPOINT");

    // Find a collection
    Collection<Document> collection = db.getCollection("collection_vector1");

    // Gather collection information
    CollectionDefinition options = collection.getDefinition();

    // Check if a collection exists
    boolean collectionExists = db.getCollection("collection_vector2").exists();
  }
}

result = db.drop_collection(name_or_collection="vector_collection")

from astrapy import DataAPIClient
client = DataAPIClient("TOKEN")
database = my_client.get_database("DB_API_ENDPOINT")

database.list_collection_names()
# prints: ['a_collection', 'my_v_col', 'another_col']
database.drop_collection("my_v_col")  # {'ok': 1}
database.list_collection_names()
# prints: ['a_collection', 'another_col']

const ok = await db.dropCollection('COLLECTION');

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

// Get a new Db instance
const db = new DataAPIClient('TOKEN').db('DB_API_ENDPOINT');

(async function () {
  // Uses db's default keyspace
  const success1 = await db.dropCollection('users');
  console.log(success1); // true

  // Overrides db's default keyspace
  const success2 = await db.dropCollection('users', {
    keyspace: 'DB_KEYSPACE'
  });
  console.log(success2); // true
})();

// Given db Database object, list all collections
void db.dropCollection("collectionName");

package com.datastax.astra.client.database;

import com.datastax.astra.client.DataAPIClient;
import com.datastax.astra.client.databases.Database;
import com.datastax.astra.client.collections.commands.options.DropCollectionOptions;

public class DropCollection {
  public static void main(String[] args) {
    Database db = new DataAPIClient("TOKEN")
            .getDatabase("API_ENDPOINT");

    // Delete an existing collection
    DropCollectionOptions options = new DropCollectionOptions();
    db.dropCollection("collection_vector2", options);
  }
}