Si utiliza los límites de la tabla de Oracle NoSQL Database Cloud Service, puede modificarlos mediante borneo.TableRequest.set_table_limits(). Si la tabla está configurada con capacidad aprovisionada, los límites se pueden definir como se muestra en el siguiente ejemplo:

from borneo import TableLimits, TableRequest
# in this path the table name is required, as there is no DDL statement 
request = TableRequest().set_table_name('users')
request.set_table_limits(TableLimits(40, 10, 5))
result = handle.table_request(request)
# table_request is asynchronous, so wait for the operation to complete, 
# wait for 40 seconds, polling every 3 seconds 
result.wait_for_completion(handle, 40000, 3000)

También puede utilizar el SDK de Python de Oracle NoSQL Database para modificar una tabla y cambiar el modelo de capacidad a una configuración de capacidad bajo demanda. También puede elegir cambiar la capacidad de almacenamiento.

from borneo import TableLimits, TableRequest
# in this path the table name is required, as there is no DDL statement
request = TableRequest().set_table_name('users')
request.set_table_limits(TableLimits(10))
result = handle.table_request(request)
# table_request is asynchronous, so wait for the operation to complete,
# wait for 40 seconds, polling every 3 seconds
result.wait_for_completion(handle, 40000, 3000)

Puede cambiar el valor de TTL de una tabla como se muestra a continuación.

/* Alter the users table to modify the TTL value to 4 days. 
* When modifying the table schema or other table state you cannot also 
* modify the table limits. These must be independent operations. 
*/
TableRequest statement = "ALTER TABLE users " + "USING TTL 4 days";
request = TableRequest().set_statement(statement)
# assume that a handle has been created, as handle, make the request 
#wait for 60 seconds, polling every 1 seconds
result = handle.do_table_request(request, 60000, 1000) 
result.wait_for_completion(handle, 60000, 1000)

Especifique la sentencia DDL y otra información en TableRequest y ejecute la solicitud mediante la función nosqldb.DoTableRequest() o nosqldb.DoTableRequestAndWait().

req:=&nosqldb.TableRequest{
    Statement: "ALTER TABLE users (ADD age INTEGER)",
}
res, err:=client.DoTableRequestAndWait(req, 5*time.Second, time.Second)

Los límites de las tablas de Oracle NoSQL Database Cloud Service se pueden modificar mediante TableRequest.TableLimits. Si la tabla está configurada con capacidad aprovisionada, los límites se pueden definir como se muestra en el siguiente ejemplo.

req := &nosqldb.TableRequest{
    TableName: "users",
    TableLimits: &nosqldb.TableLimits{
        ReadUnits: 100,
        WriteUnits: 100,
        StorageGB: 5,
    },
}
res, err := client.DoTableRequestAndWait(req, 5*time.Second, time.Second)

También puede utilizar el SDK de Go de Oracle NoSQL Database para modificar una tabla y cambiar el modelo de capacidad a una configuración de capacidad bajo demanda. También puede elegir cambiar la capacidad de almacenamiento.

req := &nosqldb.TableRequest{ TableName: "users",
TableLimits: &nosqldb.TableLimits{StorageGB: 10}}
res, err := client.DoTableRequestAndWait(req, 5*time.Second, time.Second)

Utilice NoSQLClient#tableDDL para modificar una tabla emitiendo una sentencia DDL en esta tabla. Los límites de tabla se pueden modificar mediante el método setTableLimits. Toma el nombre de la tabla y el nuevo TableLimits como argumentos y devuelve Promise of TableResult. Si la tabla está configurada con capacidad aprovisionada, los límites se pueden definir como se muestra en el siguiente ejemplo.

const NoSQLClient = require('oracle-nosqldb').NoSQLClient;
const TableState = require('oracle-nosqldb').TableState;
const client = new NoSQLClient('config.json');

async function modifyUsersTableLimits() {
    const tableName = 'users';
    try {
        let result = await client.setTableLimits(tableName, {
            readUnits: 40,
            writeUnits: 10,
            storageGB: 5
        });
        // Wait for the operation completion using specified timeout and
        // specified polling interval (delay)
        await client.forCompletion(result, TableState.ACTIVE, {
            timeout: 30000,
            delay: 2000
        });
        console.log('Table limits modified');
    } catch(error) {
        //handle errors
    }
}

También puede utilizar el SDK de Oracle NoSQL Database Node.js para modificar una tabla y cambiar el modelo de capacidad a una configuración de capacidad bajo demanda. También puede elegir cambiar la capacidad de almacenamiento.

const NoSQLClient = require('oracle-nosqldb').NoSQLClient;
const TableState = require('oracle-nosqldb').TableState;
const client = new NoSQLClient('config.json');
async function modifyUsersTableLimits() {
const tableName = 'users';
  try {
     let result = await client.setTableLimits(tableName, {storageGB: 10 });
     // Wait for the operation completion using specified timeout and polling interval (delay)
     await client.forCompletion(result, TableState.ACTIVE, { timeout: 30000, delay: 2000 });
     console.log('Table limits modified');
  } 
  catch(error) { //handle errors } 
}

Puede cambiar el valor de TTL de una tabla como se muestra a continuación.

/* Alter the users table to modify the TTL value to 4 days. 
*/
const statement = 'ALTER TABLE users ' + 'USING TTL 4 days';
let result = await client.tableDDL(statement, complete: true });
console.log('Table users altered');

Los límites de tabla se pueden modificar mediante los métodos SetTableLimitsAsync o SetTableLimitsWithCompletionAsync. Toman el nombre de la tabla y el nuevo TableLimits como parámetros y devuelven Task<TableResult>. Si la tabla está configurada con capacidad aprovisionada, los límites se pueden definir como se muestra en el siguiente ejemplo.

var client = new NoSQLClient("config.json");
var tableName = "users";
try {
    var result = await client.SetTableLimitsWithCompletionAsync(
       tableName, new TableLimits(40, 10, 5));
    // Expected output: Table state is Active.
    Console.WriteLine("Table state is {0}.", result.TableState);
    Console.WriteLine("Table limits have been changed");
}
catch(Exception ex) {
    // handle exceptions
}

También puede utilizar Oracle NoSQL Database. NET SDK para modificar una tabla y cambiar el modelo de capacidad a una configuración de capacidad bajo demanda. También puede elegir cambiar la capacidad de almacenamiento.

var client = new NoSQLClient("config.json");
var tableName = "users";
try {
   var result = await client.SetTableLimitsWithCompletionAsync( tableName, new TableLimits(10));
   // Expected output: Table state is Active.
   Console.WriteLine("Table state is {0}.", result.TableState);
   Console.WriteLine("Table limits have been changed");
}
catch(Exception ex) { // handle exceptions }

Puede cambiar el valor de TTL de una tabla como se muestra a continuación.

/* Alter the users table to modify the TTL value to 4 days. 
*/
var statement = "ALTER TABLE users " + "USING TTL 4 days";
var result = await client.ExecuteTableDDLAsync(statement);
await result.WaitForCompletionAsync(); 
Console.WriteLine("Table users altered."); 

Para modificar una tabla, puede utilizar el método NosqlTemplate.runTableRequest(). Para obtener más información, consulte SDK for Spring Data API Reference.

Las filas únicas se suprimen mediante borneo.DeleteRequest con un valor de clave primaria como se muestra a continuación.

from borneo import DeleteRequest
# DeleteRequest requires table name and primary key
request = DeleteRequest().set_table_name('users') 
request.set_key({'id': 1})
# perform the operation
result = handle.delete(request)
if result.get_success():
# success -- the row was deleted
# if the row didn't exist or was not deleted for any other reason, False is returned

Las filas únicas se suprimen mediante nosqldb.DeleteRequest con un valor de clave primaria:

key := &types.MapValue{}
key.Put("id", 1)
req := &nosqldb.DeleteRequest{
    TableName: "users",
    Key: key,
}
res, err := client.Delete(req)

Los métodos delete y deleteIfVersion devuelven Promesa de DeleteResult, que es un objeto JavaScript sin formato, que contiene el estado correcto de la operación.

const NoSQLClient = require('oracle-nosqldb').NoSQLClient;
const client = new NoSQLClient('config.json');

async function deleteRowsFromUsersTable() {
    const tableName = 'users';
    try {
        let result = await client.put(tableName, { id: 1, name: 'John' });

        // Unconditional delete, should succeed
        result = await client.delete(tableName, { id: 1 });
        // Expected output: delete succeeded
        console.log('delete ' + result.success ? 'succeeded' : 'failed');

        // Delete with non-existent primary key, will fail
        result = await client.delete(tableName, { id: 2 });
        // Expected output: delete failed
        console.log('delete ' + result.success ? 'succeeded' : 'failed');

        // Re-insert the row
        result = await client.put(tableName, { id: 1, name: 'John' });
        let version = result.version;

        // Will succeed because the version matches existing row
        result = await client.deleteIfVersion(tableName, { id: 1 }, version);
        // Expected output: deleteIfVersion succeeded
        console.log('deleteIfVersion ' + result.success ?
            'succeeded' : 'failed');

        // Re-insert the row
        result = await client.put(tableName, { id: 1, name: 'John' });

        // Will fail because the last put has changed the row version, so
        // the old version no longer matches.  The result will also contain
        // existing row and its version because we specified returnExisting in
        // the opt argument.
        result = await client.deleteIfVersion(tableName, { id: 1 }, version,
            { returnExisting: true });
        // Expected output: deleteIfVersion failed
        console.log('deleteIfVersion ' + result.success ?
            'succeeded' : 'failed');
        // Expected output: { id: 1, name: 'John' }
        console.log(result.existingRow);
    } catch(error) {
        //handle errors
    }
}

Para suprimir una fila, utilice el método DeleteAsync. Transfiera el nombre de la tabla y la clave primaria de la fila que desea suprimir. Este método toma el valor de clave primaria como MapValue. Los nombres de campo deben ser los mismos que los nombres de columna de clave primaria de tabla. También puede transferir opciones como DeleteOptions. Además, puede condicionar la operación de supresión especificando en un RowVersion de la fila devuelta anteriormente por GetAsync o PutAsync. Utilice el método DeleteIfVersionAsync que toma la versión de fila para que coincida. También puede utilizar el método DeleteAsync y transferir la versión como propiedad MatchVersion de DeleteOptions.

var client = new NoSQLClient("config.json");
var tableName = "users";
try
{
    var row = new MapValue
    {
        ["id"] = 1,
        ["name"] = "John"
    };

    var putResult = await client.PutAsync(tableName, row);
    Console.WriteLine("Put {0}.",
       putResult.Success ? "succeeded" : "failed");

    var primaryKey = new MapValue
    {
        ["id"] = 1
    };
    // Unconditional delete, should succeed.
    var deleteResult = await client.DeleteAsync(tableName, primaryKey);
    // Expected output: Delete succeeded.
    Console.WriteLine("Delete {0}.",
        deleteResult.Success ? "succeeded" : "failed");
    // Delete with non-existent primary key, should fail.
    var deleteResult = await client.DeleteAsync(tableName,
        new MapValue
        {
            ["id"] = 200
        });
    // Expected output: Delete failed.
    Console.WriteLine("Delete {0}.",
        deleteResult.Success ? "succeeded" : "failed");
    // Re-insert the row and get the new row version.
    putResult = await client.PutAsync(tableName, row);
    var version = putResult.Version;
    // Delete should succeed because the version matches existing
    // row.
    deleteResult = await client.DeleteIfVersionAsync(tableName,
        primaryKey, version);
    // Expected output: DeleteIfVersion succeeded.
    Console.WriteLine("DeleteIfVersion {0}.",
        deleteResult.Success ? "succeeded" : "failed");
    // Re-insert the row
    putResult = await client.PutAsync(tableName, row);
    // This delete should fail because the last put operation has
    // changed the row version, so the old version no longer matches.
    // The result will also contain existing row and its version because
    // we specified ReturnExisting in DeleteOptions.
    deleteResult = await client.DeleteIfVersionAsync(tableName,
        primaryKey, version);
    // Expected output: DeleteIfVersion failed.
    Console.WriteLine("DeleteIfVersion {0}.",
        deleteResult.Success ? "succeeded" : "failed");
    // Expected output: { "id": 1, "name": "John" }
    Console.WriteLine(result.existingRow);
}
catch(Exception ex) {
    // handle exceptions
}

Tenga en cuenta que la propiedad Success del resultado solo indica si se ha encontrado la fila que se va a suprimir y para la supresión condicional, si la versión proporcionada coincide. Si la operación de supresión falla por cualquier otro motivo, se devolverá una excepción. Puede suprimir varias filas que tengan la misma clave de partición horizontal en una única operación atómica mediante el método DeleteRangeAsync. Este método suprime el juego de filas basado en la clave primaria parcial (que debe incluir una clave de partición horizontal) y FieldRange opcional que especifica un rango de valores de uno de los otros campos de clave primaria (no incluidos en la clave parcial).

Utilice uno de estos métodos para suprimir las filas de las tablas: NosqlRepository deleteById(), delete(), deleteAll(Iterable<? extends T> entities), deleteAll() o con NosqlTemplate delete(), deleteAll(), deleteById(), deleteInShard(). Para obtener más información, consulte SDK for Spring Data API Reference.

Cree la interfaz UsersRepository. Esta interfaz amplía la interfaz NosqlRepository y proporciona la clase de entidad y el tipo de dato de la clave primaria de esa clase como tipos con parámetros para la interfaz NosqlRepository. La interfaz NosqlRepository proporciona métodos que se utilizan para recuperar datos de la base de datos.

import com.oracle.nosql.spring.data.repository.NosqlRepository;
 
/* The Users is the entity class and Long is the data type of the primary key in the Users class.
   This interface provides methods that return iterable instances of  the Users class. */
 
public interface UsersRepository extends NosqlRepository<Users, Long> {
    Iterable<Users> findAll();
}

En la aplicación, utilice el método deleteAll() para suprimir las filas existentes de la tabla.

@Autowired
private UsersRepository repo;
 
/* Delete all the existing rows if any, from the Users table.*/
repo.deleteAll();