Work with rows

const table = await db.createTable('TABLE_NAME', {
  definition: {
    columns: {
      VECTOR_COLUMN_NAME: {
        type: 'vector',
        dimension: NUM_DIMENSIONS,
      },
      ...
    },
    ...
  },
});

import com.datastax.astra.client.tables.Table;
import com.datastax.astra.client.tables.definition.TableDefinition;
import com.datastax.astra.client.tables.definition.columns.ColumnDefinitionVector;

int NUM_DIMENSIONS = 3;

TableDefinition tableDefinition = new TableDefinition()
 //...
 .addColumnVector("VECTOR_COLUMN_NAME", new ColumnDefinitionVector()
   .dimension(NUM_DIMENSIONS)
   .metric(COSINE))
 //...
;
Table myTable = database.createTable("TABLE_NAME", tableDefinition);

"columns": {
  "VECTOR_COLUMN_NAME": {
    "type": "vector",
    "dimension": NUM_DIMENSIONS
  }
}

const table = await db.createTable('TABLE_NAME', {
  definition: {
    columns: {
      VECTOR_COLUMN_NAME: {
        type: 'vector',
        dimension: NUM_DIMENSIONS,
        service: {
          provider: 'EMBEDDINGS_PROVIDER_NAME',
          modelName: 'MODEL_NAME',
          authentication: {
            providerKey: 'ASTRA_KMS_API_KEY_NAME',
          },
        },
      },
      ...
    },
    ...
  },
});

VectorServiceOptions vectorServiceOptions = new VectorServiceOptions()
  .provider("EMBEDDINGS_PROVIDER_NAME")
  .modelName("MODEL_NAME")
  .authentication(Map.of("providerKey", "ASTRA_KMS_API_KEY_NAME"));

ColumnDefinitionVector columnDefinition = new ColumnDefinitionVector()
  .dimension(3)
  .metric(COSINE)
  .service(vectorServiceOptions);

TableDefinition tableDefinition = new TableDefinition()
  //...
  .addColumnVector("VECTOR_COLUMN_NAME", columnDefinition);

Table myTable = database.createTable("TABLE_NAME", tableDefinition);

"columns": {
  "COLUMN_NAME": "DATA_TYPE",
  "COLUMN_NAME": "DATA_TYPE",
  "VECTOR_COLUMN_NAME": {
    "type": "vector",
    "dimension": NUM_DIMENSIONS,
    "service": {
      "provider": "EMBEDDINGS_PROVIDER_NAME",
      "modelName": "MODEL_NAME",
      "authentication": {
        "providerKey": "ASTRA_KMS_API_KEY_NAME"
      }
    }
  }
}

# Insert a list of floats sending it as array:
my_table.insert_one({"vector_column": [0.1, -0.2, 0.3], ...})

# Insert a list of floats sending it as binary-encoded:
my_table.insert_one({"vector_column": DataAPIVector([0.1, -0.2, 0.3]), ...})

# Generate the embedding with vectorize
my_table.insert_one({"vector_column": "Text to vectorize", ...})

// Using the explicit class constructor
await table.insertOne({ vectorColumn: new DataAPIVector([0.1, -0.2, 0.3]), ... });

// Using the vector function shorthand
await table.insertOne({ vectorColumn: vector([0.1, -0.2, 0.3]), ... });

export type DataAPIVectorLike = DataAPIVector | number[] | { $binary: string } | Float32Array;

// Creating a DataAPIVector from a Float32Array
const vec = vector(Float32Array.of(.1, -.2, .3));

// Define the table schema manually
interface TableSchema {
  vectorColumn?: number[] | null,
  ...
}
const table = await db.createTable<TableSchema>('TABLE_NAME', { ... });

// Insert as a list of floats
await table.insertOne({ vectorColumn: [0.1, -0.2, 0.3], ... });

// Insert using the vectorize feature
await table.insertOne({ vectorColumn: 'Text to vectorize', ... });

// You can still provide an explicit vector if you want
await table.insertOne({ vectorColumn: vector([0.1, -0.2, 0.3]), ... });

tableGames.insertOne(new Row()
  // primary key of the table
 .addText("match_id", "game2").addInt("round", 1)
 // add a vector
 .addVector("m_vector", new float[] {0.1f, 0.2f, 0.3f}));

DataAPIVector vector
  = new DataAPIVector(new float[] {0.1f, 0.2f, 0.3f});

tableGames.insertOne(new Row()
 // primary key of the table
 .addText("match_id", "game1").addInt("round", 1)
 // add a vector with the DataAPIVector wrapper
 .addVector("m_vector", vector));

// Assuming m_vector is a vector column with vectorize integration
tableGames.insertOne(new Row()
  // primary key of the table
  .addText("match_id", "game2").addInt("round", 1)
  // Add a vector as a string to generate vector embeddings from
  .addVectorize("m_vector", "Query text to vectorize"));

// Even if the column has a vectorize integration
// it is still valid to add embeddings directly
tableGames.insertOne(new Row()
  // We need a primary Key
  .addText("match_id", "game3").addInt("round", 1)
 // add a vector
  .addVector("m_vector", new float[] {0.1f, 0.2f, 0.3f}));

# Insert vector data as an array
"vector_column": [ 0.1, -0.2, 0.3 ]

# Insert vector data with $binary
"vector_column": { "$binary": "PczMzb5MzM0+mZma" }

# Generate an embedding with vectorize
"vector_column": "Text to vectorize"

# Run a vector search with the query vector encoded as array
my_table.find(sort={"vector_column": [0.1, -0.2, 0.3]}, ...)

# Run a vector search with the query vector binary-encoded
my_table.find(sort={"vector_column": DataAPIVector([0.1, -0.2, 0.3])}, ...)

# Run a vector search by generating the query embedding with vectorize:
my_table.find(sort={"vector_column": "Query text to vectorize"}, ...)

// Run a vector search using a DataAPIVector
await table.find({}, { sort: { vectorColumn: vector([0.1, -0.2, 0.3]) } });

// Run a vector search using a plain list of floats
// You must provide your own typing or use an untyped table
await table.find({}, { sort: { vectorColumn: [0.1, -0.2, 0.3] } });

// Run a vector search using vectorize
await table.find({}, { sort: { vectorColumn: 'Query text to vectorize' } });

// Run a vector search using vectorize
const cursor = await table.find({})
  .sort({ vectorColumn: 'Query text to vectorize' })
  .includeSortVector();

// The query vector is returned as a DataAPIVector object
const queryVector = await cursor.getSortVector();

// This example uses TableFindOptions, but you can use any sortable object

// Sort with DataAPIVector
DataAPIVector vector = new DataAPIVector(new float[] {0.1f, 0.2f, 0.3f});
new TableFindOptions()
  .sort(Sort.vector("m_vector", vector));

// Sort with float[]
new TableFindOptions()
  .sort(Sort.vector("m_vector", new float[] {0.1f, 0.2f, 0.3f}));

// Sort with vectorize
new TableFindOptions()
  .sort(Sort.vectorize("m_vector", "Text To Serialize"));

# Provide the query vector as an array
"sort": { "vector_column": [ 0.1, -0.2, 0.3 ] }

# Provide the query vector with $binary
"sort": { "vector_column": { "$binary": "PczMzb5MzM0+mZma" } }

# Generate a query vector with vectorize
"sort": { "vector_column": "Text to vectorize" }