Esta página se ha traducido con Cloud Translation API.

Eliminaciones

En este documento se describe cómo eliminar datos almacenados en tablas de Bigtable, se explica cuándo debe usar cada método y se proporcionan ejemplos. Antes de leer esta página, debes familiarizarte con la descripción general de Bigtable y entender los conceptos relacionados con el diseño de esquemas.

Para mantener la coherencia, en las descripciones de esta página se hace referencia a los métodos de la API que se usan en cada tipo de solicitud. Sin embargo, te recomendamos que siempre uses una de las bibliotecas de cliente de Bigtable para acceder a las APIs de Bigtable en lugar de usar REST o RPC.

En los ejemplos de esta página se usan datos de muestra similares a los que puede almacenar en Bigtable.

Para saber cuántas veces puedes usar al día las operaciones descritas en esta página, consulta Cuotas y límites.

Cómo elimina datos Bigtable

Cuando envías una solicitud de eliminación, las celdas se marcan para eliminarse y no se pueden leer. Los datos se eliminan hasta una semana después durante la compresión, un proceso en segundo plano que optimiza continuamente la tabla. Los metadatos de eliminación pueden hacer que tus datos ocupen un poco más de espacio (varios KB por fila) durante unos días después de enviar una solicitud de eliminación, hasta que se produzca la siguiente compactación.

Siempre puedes enviar una solicitud de eliminación, aunque tu clúster haya superado el límite de almacenamiento y las lecturas y escrituras estén bloqueadas.

Eliminar un intervalo de filas

Si quieres eliminar una gran cantidad de datos almacenados en filas contiguas, usa dropRowRange. Esta operación elimina todas las filas de un intervalo de filas identificado por una fila inicial y una final, o por un prefijo de clave de fila.

Los valores de clave de fila que proporciones al eliminar un intervalo de filas se tratarán como datos de servicio. Para obtener información sobre cómo se tratan los datos del servicio, consulta el Google Cloud Aviso de Privacidad.

Una vez que se haya completado la eliminación y hayas recibido una respuesta, podrás escribir datos en el mismo intervalo de filas sin problemas.

La operación dropRowRange tiene las siguientes restricciones:

No puedes eliminar un intervalo de filas de una vista autorizada.
No puedes llamar al método dropRowRange de forma asíncrona. Si envías una solicitud dropRowRange a una tabla mientras se está procesando otra solicitud, Bigtable devuelve un error UNAVAILABLE con el mensaje A DropRowRange operation is already ongoing. Para resolver el error, vuelve a enviar la solicitud.
En las instancias que usan la replicación, ten en cuenta que Bigtable puede tardar mucho en completar la operación debido al aumento de la latencia de replicación y del uso de la CPU. Para eliminar datos de una instancia que usa la replicación, usa la API Data para leer y, a continuación, eliminar tus datos.

En los siguientes ejemplos de código se muestra cómo eliminar un intervalo de filas que empiezan por el prefijo de clave de fila phone#5c10102:

Java

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

Para autenticarte en Bigtable, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

import com.google.cloud.bigtable.admin.v2.BigtableTableAdminClient;
import java.io.IOException;

public class DropRowRangeExample {
  public void dropRowRange(String projectId, String instanceId, String tableId) throws IOException {
    try (BigtableTableAdminClient tableAdminClient =
        BigtableTableAdminClient.create(projectId, instanceId)) {
      tableAdminClient.dropRowRange(tableId, "phone#4c410523");
    }
  }
}

Python

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

def drop_row_range(project_id, instance_id, table_id):
    from google.cloud.bigtable import Client

    client = Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)
    row_key_prefix = "phone#4c410523"
    table.drop_by_prefix(row_key_prefix, timeout=200)

Node.js

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

await table.deleteRows('phone#5c10102');
await printRows();

Eliminar datos con métodos de la API Data

Si necesitas eliminar pequeñas cantidades de datos no contiguos, lo mejor suele ser usar un método que llame a la API Cloud Bigtable (API Data). Usa estos métodos si vas a eliminar MB de datos en una solicitud, no GB. Usar la API Data es la única forma de eliminar datos de una columna (no de una familia de columnas).

Los métodos de la API Data llaman a MutateRows con uno de estos tres tipos de mutación:

DeleteFromColumn
DeleteFromFamily
DeleteFromRow

Las solicitudes de eliminación que usan la API Data son atómicas: o se realizan correctamente y se eliminan todos los datos, o no se realizan y no se elimina ningún dato.

En la mayoría de los casos, no utilices métodos CheckAndMutate para eliminar datos. En el caso poco probable de que necesites una coherencia sólida, puedes usar este enfoque, pero ten en cuenta que requiere muchos recursos y que el rendimiento puede verse afectado.

Para usar MutateRows y eliminar datos, envía una solicitud readRows con un filtro para determinar qué quieres eliminar y, a continuación, envía la solicitud de eliminación. Para ver una lista de los filtros disponibles, consulta Filtros.

En los ejemplos de esta sección se presupone que ya has determinado qué datos quieres eliminar.

Eliminar datos de una columna

En los siguientes ejemplos de código se muestra cómo eliminar todas las celdas de una columna de una fila:

Java

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

import com.google.cloud.bigtable.data.v2.BigtableDataClient;
import com.google.cloud.bigtable.data.v2.models.Mutation;
import com.google.cloud.bigtable.data.v2.models.RowMutation;
import com.google.cloud.bigtable.data.v2.models.TableId;
import java.io.IOException;

public class DeleteFromColumnExample {
  public void deleteFromColumnCells(String projectId, String instanceId, String tableId)
      throws IOException {
    try (BigtableDataClient dataClient = BigtableDataClient.create(projectId, instanceId)) {
      Mutation mutation = Mutation.create().deleteCells("cell_plan", "data_plan_01gb");
      dataClient.mutateRow(
          RowMutation.create(TableId.of(tableId), "phone#4c410523#20190501", mutation));
    }
  }
}

Python

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

def delete_from_column(project_id, instance_id, table_id):
    from google.cloud.bigtable import Client

    client = Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)
    row = table.row("phone#4c410523#20190501")
    row.delete_cell(column_family_id="cell_plan", column="data_plan_01gb")
    row.commit()

Python asyncio

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

async def delete_from_column(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import BigtableDataClientAsync
    from google.cloud.bigtable.data import DeleteRangeFromColumn

    client = BigtableDataClientAsync(project=project_id)
    table = client.get_table(instance_id, table_id)

    await table.mutate_row(
        "phone#4c410523#20190501",
        DeleteRangeFromColumn(family="cell_plan", qualifier=b"data_plan_01gb"),
    )

    await table.close()
    await client.close()

Node.js

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

await table.mutate({
  key: 'phone#4c410523#20190501',
  method: 'delete',
  data: {
    column: 'cell_plan:data_plan_05gb',
  },
});
await printRows();

Eliminar de una familia de columnas

En los siguientes ejemplos de código se muestra cómo eliminar celdas de una familia de columnas de una fila:

Java

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

import com.google.cloud.bigtable.data.v2.BigtableDataClient;
import com.google.cloud.bigtable.data.v2.models.RowMutation;
import com.google.cloud.bigtable.data.v2.models.TableId;
import java.io.IOException;

public class DeleteFromColumnFamilyExample {
  public void deleteFromColumnFamily(String projectId, String instanceId, String tableId)
      throws IOException {
    try (BigtableDataClient dataClient = BigtableDataClient.create(projectId, instanceId)) {
      dataClient.mutateRow(
          RowMutation.create(TableId.of(tableId), "phone#5c10102#20190501")
              .deleteFamily("stats_summary"));
    }
  }
}

Python

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

def delete_from_column_family(project_id, instance_id, table_id):
    from google.cloud.bigtable import Client

    client = Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)
    row = table.row("phone#4c410523#20190501")
    row.delete_cells(column_family_id="cell_plan", columns=row.ALL_COLUMNS)
    row.commit()

Python asyncio

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

async def delete_from_column_family(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import BigtableDataClientAsync
    from google.cloud.bigtable.data import DeleteAllFromFamily

    client = BigtableDataClientAsync(project=project_id)
    table = client.get_table(instance_id, table_id)

    await table.mutate_row("phone#4c410523#20190501", DeleteAllFromFamily("cell_plan"))

    await table.close()
    await client.close()

Node.js

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

await table.mutate({
  key: 'phone#4c410523#20190501',
  method: 'delete',
  data: {
    column: 'cell_plan',
  },
});
await printRows();

Eliminar de una fila

En los siguientes fragmentos de código se muestra cómo eliminar todas las celdas de una fila:

Java

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

import com.google.cloud.bigtable.data.v2.BigtableDataClient;
import com.google.cloud.bigtable.data.v2.models.Mutation;
import com.google.cloud.bigtable.data.v2.models.RowMutation;
import com.google.cloud.bigtable.data.v2.models.TableId;
import java.io.IOException;

public class DeleteFromRowExample {
  public void deleteFromRow(String projectId, String instanceId, String tableId)
      throws IOException {
    try (BigtableDataClient dataClient = BigtableDataClient.create(projectId, instanceId)) {
      Mutation mutation = Mutation.create().deleteRow();
      dataClient.mutateRow(
          RowMutation.create(TableId.of(tableId), "phone#4c410523#20190501", mutation));
    }
  }
}

Python

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

def delete_from_row(project_id, instance_id, table_id):
    from google.cloud.bigtable import Client

    client = Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)
    row = table.row("phone#4c410523#20190501")
    row.delete()
    row.commit()

Python asyncio

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

async def delete_from_row(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import BigtableDataClientAsync
    from google.cloud.bigtable.data import DeleteAllFromRow

    client = BigtableDataClientAsync(project=project_id)
    table = client.get_table(instance_id, table_id)

    await table.mutate_row("phone#4c410523#20190501", DeleteAllFromRow())

    await table.close()
    await client.close()

Node.js

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

const row = table.row('phone#4c410523#20190501');
await row.delete();
await printRows();

Eliminar por streaming y por lotes

A menudo, la mejor forma de eliminar grandes cantidades de datos es transmitir y agrupar en lotes las solicitudes de eliminación. Esta estrategia puede ser útil cuando tengas requisitos de conservación de datos más detallados que los que permiten las políticas de recogida de elementos no utilizados.

Si tu aplicación está escrita en Java, puedes habilitar el control del flujo de escritura por lotes cuando envíes eliminaciones por lotes a Bigtable. Para obtener más información, consulta Control de flujo de escritura por lotes y Habilitar el control de flujo de escritura por lotes.

En los siguientes ejemplos de código se inicia un flujo de datos (lectura de filas), se agrupan en lotes y, a continuación, se recorre el lote y se eliminan todas las celdas de la columna data_plan_01gb1 de la familia de columnas cell_plan:

Go

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package deletes


import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigtable"
)

// streamingAndBatching starts a stream of data (reading rows), batches them, and then goes through the batch and deletes all the cells in column
func streamingAndBatching(w io.Writer, projectID, instanceID string, tableName string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance-id"
	// tableName := "mobile-time-series"

	ctx := context.Background()
	client, err := bigtable.NewClient(ctx, projectID, instanceID)
	if err != nil {
		return fmt.Errorf("bigtable.NewClient: %w", err)
	}
	defer client.Close()
	tbl := client.Open(tableName)

	// Slices to hold the row keys and the corresponding mutations.
	var rowKeys []string
	var mutations []*bigtable.Mutation

	// Read all rows from the table.
	err = tbl.ReadRows(ctx, bigtable.InfiniteRange(""), func(row bigtable.Row) bool {
		// For each row, create a mutation to delete the specified cell.
		mut := bigtable.NewMutation()
		mut.DeleteCellsInColumn("cell_plan", "data_plan_01gb")

		// Append the row key and mutation to the slices.
		rowKeys = append(rowKeys, row.Key())
		mutations = append(mutations, mut)

		// Continue processing rows.
		return true
	})
	if err != nil {
		return fmt.Errorf("tbl.ReadRows: %w", err)
	}

	if len(mutations) == 0 {
		return nil
	}
	// If there are mutations to apply, apply them in a single bulk request.
	// ApplyBulk returns a slice of errors, one for each mutation.
	var errs []error
	if errs, err = tbl.ApplyBulk(ctx, rowKeys, mutations); err != nil {
		return fmt.Errorf("tbl.ApplyBulk: %w", err)
	}
	if errs != nil {
		// Log any individual errors that occurred during the bulk operation.
		var errorCount int
		for _, individualErr := range errs {
			if individualErr != nil {
				fmt.Fprintf(w, "Error applying mutation: %v\n", individualErr)
				errorCount++
			}
		}
		if errorCount > 0 {
			return fmt.Errorf("encountered %d error(s) out of %d mutations", errorCount, len(errs))
		}
	}

	fmt.Fprintf(w, "Successfully deleted cells from all rows")
	return nil
}

Java

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

import com.google.api.gax.batching.Batcher;
import com.google.api.gax.rpc.ServerStream;
import com.google.cloud.bigtable.data.v2.BigtableDataClient;
import com.google.cloud.bigtable.data.v2.models.Query;
import com.google.cloud.bigtable.data.v2.models.Row;
import com.google.cloud.bigtable.data.v2.models.RowMutationEntry;
import com.google.cloud.bigtable.data.v2.models.TableId;
import java.io.IOException;

public class BatchDeleteExample {
  public void batchDelete(String projectId, String instanceId, String tableId)
      throws InterruptedException, IOException {
    try (BigtableDataClient dataClient = BigtableDataClient.create(projectId, instanceId)) {
      try (Batcher<RowMutationEntry, Void> batcher =
          dataClient.newBulkMutationBatcher(TableId.of(tableId))) {
        ServerStream<Row> rows = dataClient.readRows(Query.create(TableId.of(tableId)));
        for (Row row : rows) {
          batcher.add(
              RowMutationEntry.create(row.getKey()).deleteCells("cell_plan", "data_plan_05gb"));
        }
        // Blocks until mutations are applied on all submitted row entries.
        batcher.flush();
      }
    }
  }
}

Python

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

def streaming_and_batching(project_id, instance_id, table_id):
    from google.cloud.bigtable import Client

    client = Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)
    batcher = table.mutations_batcher(flush_count=2)
    rows = table.read_rows()
    for row in rows:
        row = table.row(row.row_key)
        row.delete_cell(column_family_id="cell_plan", column="data_plan_01gb")

    batcher.mutate_rows(rows)

Python asyncio

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

async def streaming_and_batching(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import BigtableDataClientAsync
    from google.cloud.bigtable.data import DeleteRangeFromColumn
    from google.cloud.bigtable.data import RowMutationEntry
    from google.cloud.bigtable.data import ReadRowsQuery

    client = BigtableDataClientAsync(project=project_id)
    table = client.get_table(instance_id, table_id)

    async with table.mutations_batcher() as batcher:
        async for row in await table.read_rows_stream(ReadRowsQuery(limit=10)):
            await batcher.append(
                RowMutationEntry(
                    row.row_key,
                    DeleteRangeFromColumn(
                        family="cell_plan", qualifier=b"data_plan_01gb"
                    ),
                )
            )

    await table.close()
    await client.close()

Node.js

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

const rows = (await table.getRows({limit: 2}))[0];
const entries = rows.map(row => {
  return {
    key: row.id,
    method: 'delete',
    data: {
      column: 'cell_plan:data_plan_05gb',
    },
  };
});
await table.mutate(entries);
await printRows();

Eliminar datos de una vista autorizada

Puede eliminar datos de una tabla enviando una solicitud de eliminación a una vista autorizada. Debes usar uno de los siguientes elementos:

CLI de gcloud
Cliente de Bigtable para Java

Cuando elimina datos de una vista autorizada, debe proporcionar el ID de la vista autorizada, además del ID de la tabla.

Los datos que puedes eliminar de una vista autorizada están limitados por la definición de la vista autorizada. Solo puedes eliminar los datos que se incluyan en la vista autorizada. Si intentas eliminar datos que no se ajustan a la definición de la vista autorizada o que están sujetos a las siguientes reglas, se devolverá un error PERMISSION_DENIED:

No se puede eliminar un intervalo de filas de una vista autorizada mediante DropRowRange en la API Admin.
No se puede eliminar contenido de una fila.
Se puede eliminar contenido de una columna siempre que se trate de filas que estén en la vista autorizada.
Solo se permite eliminar datos de una familia de columnas si esta se ha configurado para permitir todos los prefijos de calificador de columna (qualifier_prefixes="") en la vista autorizada.

Por ejemplo, si intentas eliminar datos de una fila específica y esa fila contiene columnas de la tabla subyacente que no están en tu vista autorizada, la solicitud fallará.

Eliminaciones

Cómo elimina datos Bigtable

Eliminar un intervalo de filas

Java

Python

Node.js

Eliminar datos con métodos de la API Data

Eliminar datos de una columna

Java

Python

Python asyncio

Node.js

Eliminar de una familia de columnas

Java

Python

Python asyncio

Node.js

Eliminar de una fila

Java

Python

Python asyncio

Node.js

Eliminar por streaming y por lotes

Go

Java

Python

Python asyncio

Node.js

Eliminar datos de una vista autorizada

Siguientes pasos