Update rows reference

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

from astrapy.constants import SortMode
from astrapy.info import (
    CreateTableDefinition,
    ColumnType,
)

my_table = database.create_table(
    "games",
    definition=(
        CreateTableDefinition.builder()
        .add_column("match_id", ColumnType.TEXT)
        .add_column("round", ColumnType.TINYINT)
        .add_vector_column("m_vector", dimension=3)
        .add_column("score", ColumnType.INT)
        .add_column("when", ColumnType.TIMESTAMP)
        .add_column("winner", ColumnType.TEXT)
        .add_set_column("fighters", ColumnType.UUID)
        .add_partition_by(["match_id"])
        .add_partition_sort({"round": SortMode.ASCENDING})
        .build()
    ),
)

from astrapy.data_types import (
    DataAPISet,
    DataAPITimestamp,
    DataAPIVector,
)
from astrapy.ids import UUID

insert_result = my_table.insert_many(
    [
        {
            "match_id": "fight4",
            "round": 1,
            "winner": "Victor",
            "score": 18,
            "when": DataAPITimestamp.from_string(
                "2024-11-28T11:30:00Z",
            ),
            "fighters": DataAPISet([
                UUID("0193539a-2770-8c09-a32a-111111111111"),
                UUID('019353e3-00b4-83f9-a127-222222222222'),
            ]),
            "m_vector": DataAPIVector([0.4, -0.6, 0.2]),
        },
        {"match_id": "challenge6", "round": 2, "winner": "Erick"},
    ],
)

from astrapy.data_types import DataAPISet

# Set a new value for a column
my_table.update_one(
    {"match_id": "fight4", "round": 1},
    update={"$set": {"winner": "Winona"}},
)

# Set a new value for a column while unsetting another colum
my_table.update_one(
    {"match_id": "fight4", "round": 1},
    update={"$set": {"winner": None, "score": 24}},
)

# Set a 'set' column to empty
my_table.update_one(
    {"match_id": "fight4", "round": 1},
    update={"$set": {"fighters": DataAPISet()}},
)

# Set a 'set' column to empty using None
my_table.update_one(
    {"match_id": "fight4", "round": 1},
    update={"$set": {"fighters": None}},
)

# Set a 'set' column to empty using a regular (empty) set
my_table.update_one(
    {"match_id": "fight4", "round": 1},
    update={"$set": {"fighters": set()}},
)

# Set a 'set' column to empty using $unset
my_table.update_one(
    {"match_id": "fight4", "round": 1},
    update={"$unset": {"fighters": None}},
)

# A non-existing primary key creates a new row
my_table.update_one(
    {"match_id": "bar_fight", "round": 4},
    update={"$set": {"score": 8, "winner": "Jack"}},
)

# Delete column values for a row (they will now read as None)
my_table.update_one(
    {"match_id": "challenge6", "round": 2},
    update={"$unset": {"winner": None, "score": None}},
)

// No upsert will occur here since only nulls are being set
// (this is equivalent to { $unset: { name: '' } })
await table.updateOne({ key: '123' }, { $set: { name: null } });

// An upsert will occur here since at least one non-null value is being set
await table.updateOne({ key: '123' }, { $set: { name: 'Eleanor', age: null } });

// Upserts row { key: '123', name: 'Michael', age: 3 } into the table
await table.updateOne({ key: '123' }, { $set: { name: 'Michael', age: 3 } });

// Sets row to { key: '123', name: 'Michael', age: null }
await table.updateOne({ key: '123' }, { $set: { age: null } });

// Deletes row from the table as all non-primary keys are set to null
await table.updateOne({ key: '123' }, { $set: { name: null } });

import { CreateTableDefinition, DataAPIClient, InferTablePrimaryKey, InferTableSchema, timestamp, uuid, vector } from '@datastax/astra-db-ts';

// Instantiate the client and connect to the database
const client = new DataAPIClient();
const db = client.db(process.env.CLIENT_DB_URL!, { token: process.env.CLIENT_DB_TOKEN! });

// Create table schema using bespoke Data API table definition syntax, and then infer the type.
// For information about table typing and definitions, see the documentation for createTable.
const TableDefinition = <const>{
  columns: {
    matchId: 'text'
    round: 'tinyint',
    mVector: { type: 'vector', dimension: 3 },
    score: 'int',
    when: 'timestamp',
    winner: 'text',
    fighters: { type: 'set', valueType: 'uuid' },
  },
  primaryKey: {
    partitionBy: ['matchId'],
    partitionSort: { round: 1 },
  },
} satisfies CreateTableDefinition;

type TableSchema = InferTableSchema<typeof TableDefinition>;

(async function () {
  // Create a table with the given TableSchema type if a 'games' table doesn't already exist
  const table = await db.createTable<TableSchema>('games', { definition: TableDefinition, ifNotExists: true });

  // Insert some rows in an unordered fashion.
  await table.insertMany([
    { matchId: 'fight4', round: 1, winner: 'Victor' },
    { matchId: 'fight5', round: 1, winner: 'Adam' },
    { matchId: 'fight5', round: 2, winner: 'Betta' },
    { matchId: 'fight5', round: 3, winner: 'Caio' },
    { matchId: 'fight7', round: 1, winner: 'Joy' },
    { matchId: 'fight7', round: 2, winner: 'Kevin' },
    { matchId: 'fight7', round: 3, winner: 'Lauretta' },
  ]);

// Use updateOne to update individual values in a row.
// updateOne can insert a new row, depending on the specified update operation.

  // Set a new non-null value for a column
  await table.updateOne(
    { matchId: 'fight4', round: 1 },
    { $set: { winner: 'Winona' } },
  );

  // Set a new non-null value for a column
  // and nullify the existing value in another column
  await table.updateOne(
    { matchId: 'fight4', round: 1 },
    { $set: { winner: null, score: 24 } },
  );

  // Set a 'set' type column to empty
  await table.updateOne(
    { matchId: 'fight4', round: 1 },
    { $set: { fighters: new Set() } },
  );

  // Use unset to change a 'set' type column to empty
  await table.updateOne(
    { matchId: 'fight4', round: 1 },
    { $unset: { fighters: '' } },
  );

  // If the given primary key doesn't match any existing row,
  // and you $set at least one non-null value,
  // then updateOne creates a new row with the given primary key and non-null values.
  // All unspecified columns are null.
  await table.updateOne(
    { matchId: 'bar_fight', round: 4 },
    { $set: { score: 8, winner: 'Jack' } },
  );

  // You can use set and unset to change all non-primary key columns to null.
  // You can't change primary key values with updateOne.
  await table.updateOne(
    { matchId: 'challenge6', round: 2 },
    { $unset: { winner: '', score: '' } },
  );

  // Uncomment the following line to drop the table and any related indexes.
  // await table.drop();
})();

{
  "status": {
    "matchedCount": 1,
    "modifiedCount": 1,
    "upsertCount": 0
  }
}