Alter a table

Tables with the Data API are currently in public preview. Development is ongoing, and the features and functionality are subject to change. Hyper-Converged Database (HCD), and the use of such, is subject to the DataStax Preview Terms.

Alters a table by doing one of the following:

Adding one or more columns to a table
Dropping one or more columns from a table

You cannot change a column’s type. Instead, you must drop the column and add a new column.

Similarly, you cannot rename a table. Instead, you must drop and re-create the table.

After you add a column, you should index the column if you want to filter or sort on the column. All indexed column names must use snake case, not camel case. For more information, see Create an index and Create a vector index.

Ready to write code? See the examples for this method to get started. If you are new to the Data API, check out the quickstart.

Result

Python
TypeScript
Java
C#
curl

Adds or drops columns.

Returns a Table instance that represents the table after the modification.

Although the Table instance that you used to perform the alteration will still work, it will not reflect the updated typing if you added or dropped columns. To reflect the new typing, use the row_type parameter.

Adds or drops columns.

Returns a promise that resolves to a Table instance that represents the table after the modification.

const newTable = await table.alter<NewSchema>({
    operation: {
      add: {
        columns: {
          venue: 'text',
        },
      },
    },
  });

Adds or drops columns.

Returns a Table<T> instance that represents the table after the schema change.

Adds or drops columns.

Returns a Table instance that represents the table after the schema change.

Although the Table instance that you used to perform the alteration will still work, it will not reflect the updated typing. To reflect the new typing, provide the new type of the table to the Alter or AlterAsync method.

Adds or drops columns.

If the command succeeds, the response indicates the success.

Example response:

{
  "status": {
    "ok": 1
  }
}

Parameters

Python
TypeScript
Java
C#
curl

Use the alter method, which belongs to the astrapy.Table class.

Method signature

alter(
  operation: AlterTableOperation | dict[str, Any],
  *,
  row_type: type[Any] = DefaultRowType,
  table_admin_timeout_ms: int,
  request_timeout_ms: int,
  timeout_ms: int,
) -> Table[NEW_ROW]

Name Type Summary

Name	Type	Summary
`operation`	`AlterTableOperation` \| `dict[str, Any]`	The alter operation to perform. Can be one of the following: An `AlterTableAddColumns` object or a dictionary in the form `{"add": {"columns": COLUMN_DEFINITIONS}}` that specifies the columns to add. Column are defined in the same way as when you create a table. For examples, see Add columns to a table and Add vector columns to a table. An `AlterTableDropColumns` or a dictionary in the form `{"drop": {"columns": [COLUMN_NAMES]}}` that specifies the names of the columns to remove. For an example, see Drop columns from a table.
`row_type`	`type`	Optional. A formal specifier for the type checker. If provided, `row_type` must match the type hint specified in the assignment. For more information, see Typing support.
`table_admin_timeout_ms`	`int`	Optional. A timeout, in milliseconds, for the underlying HTTP request. If not provided, the `Database` setting is used. This parameter is aliased as `request_timeout_ms` and `timeout_ms` for convenience.

operation

AlterTableOperation | dict[str, Any]

The alter operation to perform.

Can be one of the following:

An AlterTableAddColumns object or a dictionary in the form {"add": {"columns": COLUMN_DEFINITIONS}} that specifies the columns to add. Column are defined in the same way as when you create a table.

For examples, see Add columns to a table and Add vector columns to a table.
An AlterTableDropColumns or a dictionary in the form {"drop": {"columns": [COLUMN_NAMES]}} that specifies the names of the columns to remove.

For an example, see Drop columns from a table.

row_type

type

Optional. A formal specifier for the type checker. If provided, row_type must match the type hint specified in the assignment. For more information, see Typing support.

table_admin_timeout_ms

int

Optional. A timeout, in milliseconds, for the underlying HTTP request. If not provided, the Database setting is used. This parameter is aliased as request_timeout_ms and timeout_ms for convenience.

Use the alter method, which belongs to the Table class.

Method signature

async alter(
  options: AlterTableOptions<Schema>
): Table<Schema, PKey>

Name Type Summary

Name	Type	Summary
`operation`	`AlterTableOperations<Schema>`	The alter operation to perform. Can be one of the following: An `{add: AddColumnOperation}` object that specifies the columns to add. Column are defined in the same way as when you create a table. For examples, see Add columns to a table and Add vector columns to a table. A `{drop: DropColumnOperation}` object that specifies the names of the columns to remove. For an example, see Drop columns from a table.
`timeout`	`number` \| `TimeoutDescriptor`	The timeout(s) to apply to HTTP request(s) originating from this method.

operation

AlterTableOperations<Schema>

The alter operation to perform.

Can be one of the following:

An {add: AddColumnOperation} object that specifies the columns to add. Column are defined in the same way as when you create a table.

For examples, see Add columns to a table and Add vector columns to a table.
A {drop: DropColumnOperation} object that specifies the names of the columns to remove.

For an example, see Drop columns from a table.

timeout

number | TimeoutDescriptor

The timeout(s) to apply to HTTP request(s) originating from this method.

Use the alter method, which belongs to the com.datastax.astra.client.tables.Table class.

Method signature

Table<T> alter(AlterTableOperation operation)

Table<T> alter(
  AlterTableOperation operation,
  AlterTableOptions options
)

<R> Table<R> alter(
  AlterTableOperation operation,
  AlterTableOptions options,
  Class<R> clazz
)

Name Type Summary

Name	Type	Summary
`operation`	`AlterTableOperation`	The alter operation to perform. Can be one of the following: An `AlterTableAddColumns` object that specifies the columns to add. Column are defined in the same way as when you create a table. For examples, see Add columns to a table and Add vector columns to a table. An `AlterTableDropColumns` object that specifies the names of the columns to remove. For an example, see Drop columns from a table.
`options`	`AlterTableOptions`	Optional. The options for this operation, including the timeout.
`rowClass`	`Class<?>`	Optional. A specification of the class of the table’s row object. Default: `Row`, which is close to a `Map` object

operation

AlterTableOperation

The alter operation to perform.

Can be one of the following:

An AlterTableAddColumns object that specifies the columns to add. Column are defined in the same way as when you create a table.

For examples, see Add columns to a table and Add vector columns to a table.
An AlterTableDropColumns object that specifies the names of the columns to remove.

For an example, see Drop columns from a table.

options

AlterTableOptions

Optional. The options for this operation, including the timeout.

rowClass

Class<?>

Optional. A specification of the class of the table’s row object.

Default: Row, which is close to a Map object

Use the AlterAsync method, which belongs to the Table class. You can also use Alter, which is the synchronous version of the method.

Method signature

public Task<Table<T>> AlterAsync(
  IAlterTableOperation operation,
  AlterTableOptions options = null
);

public Task<Table<TRowAfterAlter>> AlterAsync<TRowAfterAlter>(
  IAlterTableOperation operation,
  AlterTableOptions options = null
) where TRowAfterAlter : class;

Name Type Summary

Name	Type	Summary
`operation`	`IAlterTableOperation`	The alter operation to perform. Can be one of the following: An `AlterTableAddColumns` object that specifies non-vector columns to add. For an example, see Add columns to a table. An `AlterTableAddVectorColumns` object that specifies vector columns to add. For an example, see Add vector columns to a table. An `AlterTableDropColumns` object that specifies the names of the columns to remove. For an example, see Drop columns from a table.
`options`	`AlterTableOptions`	Optional. General API options for this operation, including the timeout. For more information and examples, see Customize API interaction.

operation

IAlterTableOperation

The alter operation to perform.

Can be one of the following:

An AlterTableAddColumns object that specifies non-vector columns to add.

For an example, see Add columns to a table.
An AlterTableAddVectorColumns object that specifies vector columns to add.

For an example, see Add vector columns to a table.
An AlterTableDropColumns object that specifies the names of the columns to remove.

For an example, see Drop columns from a table.

options

AlterTableOptions

Optional. General API options for this operation, including the timeout. For more information and examples, see Customize API interaction.

Use the alterTable command.

Command signature

curl -sS -L -X POST "API_ENDPOINT/api/json/v1/KEYSPACE_NAME/TABLE_NAME" \
--header "Token: APPLICATION_TOKEN" \
--header "Content-Type: application/json" \
--data '{
  "alterTable": {
    "operation": {
      "add": {
        "columns": {
          "NEW_COLUMN_NAME": "DATA_TYPE",
          "NEW_COLUMN_NAME": "DATA_TYPE"
        }
      }
    }
  }
}'

curl -sS -L -X POST "API_ENDPOINT/api/json/v1/KEYSPACE_NAME/TABLE_NAME" \
--header "Token: APPLICATION_TOKEN" \
--header "Content-Type: application/json" \
--data '{
  "alterTable": {
    "operation": {
      "drop": {
        "columns": [ "COLUMN_NAME", "COLUMN_NAME" ]
      }
    }
  }
}'

Name Type Summary

Name	Type	Summary
`operation`	`object`	The alter operation to perform. Can be one of the following: An object in the form `{"add": {"columns": COLUMN_DEFINITIONS}}` that specifies the columns to add. Column are defined in the same way as when you create a table. For examples, see Add columns to a table and Add vector columns to a table. An object in the form `{"drop": {"columns": [COLUMN_NAMES]}}` that specifies the names of the columns to remove. For an example, see Drop columns from a table.

operation

object

The alter operation to perform.

Can be one of the following:

An object in the form {"add": {"columns": COLUMN_DEFINITIONS}} that specifies the columns to add. Column are defined in the same way as when you create a table.

For examples, see Add columns to a table and Add vector columns to a table.
An object in the form {"drop": {"columns": [COLUMN_NAMES]}} that specifies the names of the columns to remove.

For an example, see Drop columns from a table.

Examples

The following examples demonstrate how to alter a table.

Add columns to a table

When you add columns, the columns are defined in the same way as they are when you create a table.

After you add a column, you should index the column if you want to filter or sort on the column. For more information, see Create an index and Create a vector index.

Python
TypeScript
Java
C#
curl

The following example uses untyped documents or rows, but you can define a client-side type for your collection to help statically catch errors. For examples, see Typing support.

from astrapy import DataAPIClient
from astrapy.authentication import UsernamePasswordTokenProvider
from astrapy.constants import Environment
from astrapy.info import (
    AlterTableAddColumns,
    ColumnType,
    TableScalarColumnTypeDescriptor,
)

# Get an existing table
client = DataAPIClient(environment=Environment.HCD)
database = client.get_database(
    "API_ENDPOINT",
    token=UsernamePasswordTokenProvider("USERNAME", "PASSWORD"),
)
table = database.get_table("TABLE_NAME", keyspace="KEYSPACE_NAME")

# Add columns
table.alter(
    AlterTableAddColumns(
        columns={
            "is_summer_reading": TableScalarColumnTypeDescriptor(
                column_type=ColumnType.BOOLEAN,
            ),
            "library_branch": TableScalarColumnTypeDescriptor(
                column_type=ColumnType.TEXT,
            ),
        },
    ),
)

import {
  DataAPIClient,
  UsernamePasswordTokenProvider,
} from "@datastax/astra-db-ts";

// Get an existing table
const client = new DataAPIClient({ environment: "hcd" });
const database = client.db("API_ENDPOINT", {
  token: new UsernamePasswordTokenProvider("USERNAME", "PASSWORD"),
});
const table = database.table("TABLE_NAME", {
  keyspace: "KEYSPACE_NAME",
});

// Add columns
(async function () {
  await table.alter({
    operation: {
      add: {
        columns: {
          is_summer_reading: "boolean",
          library_branch: "text",
        },
      },
    },
  });
})();

import com.datastax.astra.client.DataAPIClients;
import com.datastax.astra.client.tables.Table;
import com.datastax.astra.client.tables.commands.AlterTableAddColumns;
import com.datastax.astra.client.tables.definition.rows.Row;

public class Example {

  public static void main(String[] args) {
    // Get an existing table
    Table<Row> table =
        DataAPIClients.clientHCD("USERNAME", "PASSWORD")
            .getDatabase("API_ENDPOINT", "KEYSPACE_NAME")
            .getTable("TABLE_NAME");

    // Add columns
    AlterTableAddColumns alterOperation =
        new AlterTableAddColumns()
            .addColumnBoolean("is_summer_reading")
            .addColumnText("library_branch");
    table.alter(alterOperation);
  }
}

Typed
Untyped

You can manually define a client-side type for your table to help statically catch errors. For more information and examples, see Custom typing for tables.

using DataStax.AstraDB.DataApi;
using DataStax.AstraDB.DataApi.Core;
using DataStax.AstraDB.DataApi.Tables;

namespace Examples;

public class ExampleRowBeforeAlter
{
  [ColumnPrimaryKey(1)]
  [ColumnName("title")]
  public string Title { get; set; } = null!;

  [ColumnPrimaryKey(2)]
  [ColumnName("author")]
  public string Author { get; set; } = null!;
}

public class ExampleRowAfterAlter : ExampleRowBeforeAlter
{
  [ColumnName("is_summer_reading")]
  public bool? IsSummerReading { get; set; }

  [ColumnName("library_branch")]
  public string? LibraryBranch { get; set; }
}

public class Program
{
  static async Task Main()
  {
    // Get an existing table
    var client = new DataAPIClient(
      new CommandOptions() { Destination = DataAPIDestination.HCD }
    );

    var database = client.GetDatabase(
      "API_ENDPOINT",
      DataAPIClient.UsernamePasswordTokenProvider(
        "USERNAME",
        "PASSWORD"
      ),
      "KEYSPACE_NAME"
    );

    var table = database.GetTable<ExampleRowBeforeAlter>(
      "TABLE_NAME"
    );

    // Add columns
    var newColumns = new Dictionary<string, AlterTableColumnDefinition>
    {
      ["is_summer_reading"] = new AlterTableColumnDefinition
      {
        Type = "boolean",
      },
      ["library_branch"] = new AlterTableColumnDefinition
      {
        Type = "text",
      },
    };

    var alteredTable = await table.AlterAsync<ExampleRowAfterAlter>(
      new AlterTableAddColumns(newColumns)
    );
  }
}

If you don’t pass a type parameter, the collection or table remains untyped. This is a more flexible but less type-safe option.

using DataStax.AstraDB.DataApi;
using DataStax.AstraDB.DataApi.Core;
using DataStax.AstraDB.DataApi.Tables;

namespace Examples;

public class Program
{
  static async Task Main()
  {
    // Get an existing table
    var client = new DataAPIClient(
      new CommandOptions() { Destination = DataAPIDestination.HCD }
    );

    var database = client.GetDatabase(
      "API_ENDPOINT",
      DataAPIClient.UsernamePasswordTokenProvider(
        "USERNAME",
        "PASSWORD"
      ),
      "KEYSPACE_NAME"
    );

    var table = database.GetTable("TABLE_NAME");

    // Add columns
    var newColumns = new Dictionary<string, AlterTableColumnDefinition>
    {
      ["is_summer_reading"] = new AlterTableColumnDefinition
      {
        Type = "boolean",
      },
      ["library_branch"] = new AlterTableColumnDefinition
      {
        Type = "text",
      },
    };

    await table.AlterAsync(new AlterTableAddColumns(newColumns));
  }
}

curl -sS -L -X POST "API_ENDPOINT/v1/KEYSPACE_NAME/TABLE_NAME" \
  --header "Token: APPLICATION_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
  "alterTable": {
    "operation": {
      "add": {
        "columns": {
          "is_summer_reading": "boolean",
          "library_branch": "text"
        }
      }
    }
  }
}'

Add vector columns to a table

After you add a vector column, you should index the column if you want run vector searches on the column. For more information, Create a vector index.

Python
TypeScript
Java
C#
curl

The following example uses untyped documents or rows, but you can define a client-side type for your collection to help statically catch errors. For examples, see Typing support.

from astrapy import DataAPIClient
from astrapy.authentication import UsernamePasswordTokenProvider
from astrapy.constants import Environment
from astrapy.info import (
    AlterTableAddColumns,
    TableVectorColumnTypeDescriptor,
)

# Get an existing table
client = DataAPIClient(environment=Environment.HCD)
database = client.get_database(
    "API_ENDPOINT",
    token=UsernamePasswordTokenProvider("USERNAME", "PASSWORD"),
)
table = database.get_table("TABLE_NAME", keyspace="KEYSPACE_NAME")

# Add a vector column
table.alter(
    AlterTableAddColumns(
        columns={
            "example_vector": TableVectorColumnTypeDescriptor(
                dimension=1024,
            ),
        },
    )
)

import {
  DataAPIClient,
  UsernamePasswordTokenProvider,
} from "@datastax/astra-db-ts";

// Get an existing table
const client = new DataAPIClient({ environment: "hcd" });
const database = client.db("API_ENDPOINT", {
  token: new UsernamePasswordTokenProvider("USERNAME", "PASSWORD"),
});
const table = database.table("TABLE_NAME", {
  keyspace: "KEYSPACE_NAME",
});

// Add a vector column
(async function () {
  await table.alter({
    operation: {
      add: {
        columns: {
          example_vector: { type: "vector", dimension: 1024 },
        },
      },
    },
  });
})();

import com.datastax.astra.client.DataAPIClients;
import com.datastax.astra.client.tables.Table;
import com.datastax.astra.client.tables.commands.AlterTableAddColumns;
import com.datastax.astra.client.tables.definition.columns.TableColumnDefinitionVector;
import com.datastax.astra.client.tables.definition.rows.Row;

public class Example {

  public static void main(String[] args) {
    // Get an existing table
    Table<Row> table =
        DataAPIClients.clientHCD("USERNAME", "PASSWORD")
            .getDatabase("API_ENDPOINT", "KEYSPACE_NAME")
            .getTable("TABLE_NAME");

    // Add a vector column
    AlterTableAddColumns alterOperation =
        new AlterTableAddColumns()
            .addColumnVector("example_vector", new TableColumnDefinitionVector().dimension(1024));
    table.alter(alterOperation);
  }
}

Typed
Untyped

You can manually define a client-side type for your table to help statically catch errors. For more information and examples, see Custom typing for tables.

using DataStax.AstraDB.DataApi;
using DataStax.AstraDB.DataApi.Core;
using DataStax.AstraDB.DataApi.Tables;

namespace Examples;

public abstract class ExampleRowBeforeAlter
{
  [ColumnPrimaryKey(1)]
  [ColumnName("title")]
  public string Title { get; set; } = null!;

  [ColumnPrimaryKey(2)]
  [ColumnName("author")]
  public string Author { get; set; } = null!;
}

public class ExampleRowAfterAlter : ExampleRowBeforeAlter
{
  [ColumnName("example_vector")]
  public float[]? ExampleVector { get; set; }
}

public class Program
{
  static async Task Main()
  {
    // Get an existing table
    var client = new DataAPIClient(
      new CommandOptions() { Destination = DataAPIDestination.HCD }
    );

    var database = client.GetDatabase(
      "API_ENDPOINT",
      DataAPIClient.UsernamePasswordTokenProvider(
        "USERNAME",
        "PASSWORD"
      ),
      "KEYSPACE_NAME"
    );

    var table = database.GetTable<ExampleRowBeforeAlter>(
      "TABLE_NAME"
    );

    // Add a vector column
    var newColumns = new Dictionary<
      string,
      AlterTableVectorColumnDefinition
    >
    {
      ["example_vector"] = new AlterTableVectorColumnDefinition
      {
        VectorDimension = 1024,
      },
    };

    var alteredTable = await table.AlterAsync<ExampleRowAfterAlter>(
      new AlterTableAddVectorColumns(newColumns)
    );
  }
}

If you don’t pass a type parameter, the collection or table remains untyped. This is a more flexible but less type-safe option.

using DataStax.AstraDB.DataApi;
using DataStax.AstraDB.DataApi.Core;
using DataStax.AstraDB.DataApi.Tables;

namespace Examples;

public class Program
{
  static async Task Main()
  {
    // Get an existing table
    var client = new DataAPIClient(
      new CommandOptions() { Destination = DataAPIDestination.HCD }
    );

    var database = client.GetDatabase(
      "API_ENDPOINT",
      DataAPIClient.UsernamePasswordTokenProvider(
        "USERNAME",
        "PASSWORD"
      ),
      "KEYSPACE_NAME"
    );

    var table = database.GetTable("TABLE_NAME");

    // Add a vector column
    var newColumns = new Dictionary<
      string,
      AlterTableVectorColumnDefinition
    >
    {
      ["example_vector"] = new AlterTableVectorColumnDefinition
      {
        VectorDimension = 1024,
      },
    };

    await table.AlterAsync(new AlterTableAddVectorColumns(newColumns));
  }
}

curl -sS -L -X POST "API_ENDPOINT/v1/KEYSPACE_NAME/TABLE_NAME" \
  --header "Token: APPLICATION_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
  "alterTable": {
    "operation": {
      "add": {
        "columns": {
          "example_vector": {
            "type": "vector",
            "dimension": 1024
          }
        }
      }
    }
  }
}'

Drop columns from a table

Dropping columns produces tombstones. Excessive tombstones can impact query performance.

Python
TypeScript
Java
C#
curl

The following example uses untyped documents or rows, but you can define a client-side type for your collection to help statically catch errors. For examples, see Typing support.

from astrapy import DataAPIClient
from astrapy.authentication import UsernamePasswordTokenProvider
from astrapy.constants import Environment
from astrapy.info import AlterTableDropColumns

# Get an existing table
client = DataAPIClient(environment=Environment.HCD)
database = client.get_database(
    "API_ENDPOINT",
    token=UsernamePasswordTokenProvider("USERNAME", "PASSWORD"),
)
table = database.get_table("TABLE_NAME", keyspace="KEYSPACE_NAME")

# Drop columns
table.alter(
    AlterTableDropColumns(
        columns=["is_summer_reading", "library_branch"],
    ),
)

import {
  DataAPIClient,
  UsernamePasswordTokenProvider,
} from "@datastax/astra-db-ts";

// Get an existing table
const client = new DataAPIClient({ environment: "hcd" });
const database = client.db("API_ENDPOINT", {
  token: new UsernamePasswordTokenProvider("USERNAME", "PASSWORD"),
});
const table = database.table("TABLE_NAME", {
  keyspace: "KEYSPACE_NAME",
});

// Drop columns
(async function () {
  await table.alter({
    operation: {
      drop: {
        columns: ["is_summer_reading", "library_branch"],
      },
    },
  });
})();

import com.datastax.astra.client.DataAPIClients;
import com.datastax.astra.client.tables.Table;
import com.datastax.astra.client.tables.commands.AlterTableDropColumns;
import com.datastax.astra.client.tables.definition.rows.Row;

public class Example {

  public static void main(String[] args) {
    // Get an existing table
    Table<Row> table =
        DataAPIClients.clientHCD("USERNAME", "PASSWORD")
            .getDatabase("API_ENDPOINT", "KEYSPACE_NAME")
            .getTable("TABLE_NAME");

    // Drop columns
    AlterTableDropColumns alterOperation =
        new AlterTableDropColumns("is_summer_reading", "library_branch");
    table.alter(alterOperation);
  }
}

Typed
Untyped

You can manually define a client-side type for your table to help statically catch errors. For more information and examples, see Custom typing for tables.

using DataStax.AstraDB.DataApi;
using DataStax.AstraDB.DataApi.Core;
using DataStax.AstraDB.DataApi.Tables;

namespace Examples;

public class ExampleRowAfterAlter
{
  [ColumnPrimaryKey(1)]
  [ColumnName("title")]
  public string Title { get; set; } = null!;

  [ColumnPrimaryKey(2)]
  [ColumnName("author")]
  public string Author { get; set; } = null!;
}

public class ExampleRowBeforeAlter : ExampleRowAfterAlter
{
  [ColumnName("is_summer_reading")]
  public bool? IsSummerReading { get; set; }

  [ColumnName("library_branch")]
  public string[]? LibraryBranch { get; set; }
}

public class Program
{
  static async Task Main()
  {
    // Get an existing table
    var client = new DataAPIClient(
      new CommandOptions() { Destination = DataAPIDestination.HCD }
    );

    var database = client.GetDatabase(
      "API_ENDPOINT",
      DataAPIClient.UsernamePasswordTokenProvider(
        "USERNAME",
        "PASSWORD"
      ),
      "KEYSPACE_NAME"
    );

    var table = database.GetTable<ExampleRowBeforeAlter>(
      "TABLE_NAME"
    );

    // Drop columns
    var alteredTable = await table.AlterAsync<ExampleRowAfterAlter>(
      new AlterTableDropColumns(
        new[] { "is_summer_reading", "library_branch" }
      )
    );
  }
}

If you don’t pass a type parameter, the collection or table remains untyped. This is a more flexible but less type-safe option.

using DataStax.AstraDB.DataApi;
using DataStax.AstraDB.DataApi.Core;
using DataStax.AstraDB.DataApi.Tables;

namespace Examples;

public class Program
{
  static async Task Main()
  {
    // Get an existing table
    var client = new DataAPIClient(
      new CommandOptions() { Destination = DataAPIDestination.HCD }
    );

    var database = client.GetDatabase(
      "API_ENDPOINT",
      DataAPIClient.UsernamePasswordTokenProvider(
        "USERNAME",
        "PASSWORD"
      ),
      "KEYSPACE_NAME"
    );

    var table = database.GetTable("TABLE_NAME");

    // Drop columns
    await table.AlterAsync(
      new AlterTableDropColumns(
        new[] { "is_summer_reading", "library_branch" }
      )
    );
  }
}

curl -sS -L -X POST "API_ENDPOINT/v1/KEYSPACE_NAME/TABLE_NAME" \
  --header "Token: APPLICATION_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
  "alterTable": {
    "operation": {
      "drop": {
        "columns": ["is_summer_reading", "library_branch"]
      }
    }
  }
}'

Client reference

Python
TypeScript
Java
C#
curl

For more information, see the client reference.

Client reference documentation is not applicable for HTTP.

Alter a table

Result

Parameters

Examples

Add columns to a table

Add vector columns to a table

Drop columns from a table

Client reference

Was this helpful?

Give Feedback