Supprimer des données de Cloud Firestore

Les exemples suivants montrent comment supprimer des documents, des champs et des collections.

Supprimer des documents

Pour supprimer un document, utilisez les méthodes delete() spécifiques à la langue suivantes :

Web modular API

Utilisez la méthode deleteDoc() :

import { doc, deleteDoc } from "firebase/firestore";

await deleteDoc(doc(db, "cities", "DC"));

Web namespaced API

Utilisez la méthode delete() :

db.collection("cities").doc("DC").delete().then(() => {
    console.log("Document successfully deleted!");
}).catch((error) => {
    console.error("Error removing document: ", error);
});
Rapide

Utilisez la méthode delete() :

Remarque : ce produit n'est pas disponible sur les cibles watchOS et App Clip.
do {
  try await db.collection("cities").document("DC").delete()
  print("Document successfully removed!")
} catch {
  print("Error removing document: \(error)")
}
Objectif c

Utilisez la méthode deleteDocumentWithCompletion: : :

Remarque : ce produit n'est pas disponible sur les cibles watchOS et App Clip.
[[[self.db collectionWithPath:@"cities"] documentWithPath:@"DC"]
    deleteDocumentWithCompletion:^(NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error removing document: %@", error);
      } else {
        NSLog(@"Document successfully removed!");
      }
}];

Kotlin+KTX

Utilisez la méthode delete() :

db.collection("cities").document("DC")
    .delete()
    .addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully deleted!") }
    .addOnFailureListener { e -> Log.w(TAG, "Error deleting document", e) }

Java

Utilisez la méthode delete() :

db.collection("cities").document("DC")
        .delete()
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void aVoid) {
                Log.d(TAG, "DocumentSnapshot successfully deleted!");
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                Log.w(TAG, "Error deleting document", e);
            }
        });

Dart

Utilisez la méthode delete() :

db.collection("cities").doc("DC").delete().then(
      (doc) => print("Document deleted"),
      onError: (e) => print("Error updating document $e"),
    );
Java

Utilisez la méthode delete() :

// asynchronously delete a document
ApiFuture<WriteResult> writeResult = db.collection("cities").document("DC").delete();
// ...
System.out.println("Update time : " + writeResult.get().getUpdateTime());
Python

Utilisez la méthode delete() :

db.collection("cities").document("DC").delete()

Python

Utilisez la méthode delete() :

await db.collection("cities").document("DC").delete()
C++

Utilisez la méthode Delete() :

db->Collection("cities").Document("DC").Delete().OnCompletion(
    [](const Future<void>& future) {
      if (future.error() == Error::kErrorOk) {
        std::cout << "DocumentSnapshot successfully deleted!" << std::endl;
      } else {
        std::cout << "Error deleting document: " << future.error_message()
                  << std::endl;
      }
    });
Noeud.js

Utilisez la méthode delete() :

const res = await db.collection('cities').doc('DC').delete();
Aller

Utilisez la méthode Delete() :


import (
	"context"
	"log"

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

func deleteDoc(ctx context.Context, client *firestore.Client) error {
	_, err := client.Collection("cities").Doc("DC").Delete(ctx)
	if err != nil {
		// Handle any errors in an appropriate way, such as returning them.
		log.Printf("An error has occurred: %s", err)
	}

	return err
}
PHP

Utilisez la méthode delete() :

$db->collection('samples/php/cities')->document('DC')->delete();
Unité

Utilisez la méthode DeleteAsync() :

DocumentReference cityRef = db.Collection("cities").Document("DC");
cityRef.DeleteAsync();
C#

Utilisez la méthode DeleteAsync() :

DocumentReference cityRef = db.Collection("cities").Document("DC");
await cityRef.DeleteAsync();
Rubis

Utilisez la méthode delete() :

city_ref = firestore.doc "#{collection_path}/DC"
city_ref.delete

Lorsque vous supprimez un document, Cloud Firestore ne supprime pas automatiquement les documents de ses sous-collections. Vous pouvez toujours accéder aux documents de la sous-collection par référence. Par exemple, vous pouvez accéder au document au chemin /mycoll/mydoc/mysubcoll/mysubdoc même si vous supprimez le document ancêtre au /mycoll/mydoc .

Les documents ancêtres inexistants apparaissent dans la console , mais ils n'apparaissent pas dans les résultats de requête ni dans les instantanés.

Si vous souhaitez supprimer un document et tous les documents de ses sous-collections, vous devez le faire manuellement. Pour plus d'informations, consultez Supprimer des collections .

Supprimer des champs

Pour supprimer des champs spécifiques d'un document, utilisez les méthodes FieldValue.delete() spécifiques à la langue suivantes lorsque vous mettez à jour un document :

Web modular API

Utilisez la méthode deleteField() :

import { doc, updateDoc, deleteField } from "firebase/firestore";

const cityRef = doc(db, 'cities', 'BJ');

// Remove the 'capital' field from the document
await updateDoc(cityRef, {
    capital: deleteField()
});

Web namespaced API

Utilisez la méthode FieldValue.delete() :

var cityRef = db.collection('cities').doc('BJ');

// Remove the 'capital' field from the document
var removeCapital = cityRef.update({
    capital: firebase.firestore.FieldValue.delete()
});
Rapide

Utilisez la méthode FieldValue.delete() :

Remarque : ce produit n'est pas disponible sur les cibles watchOS et App Clip.
do {

  try await db.collection("cities").document("BJ").updateData([
    "capital": FieldValue.delete(),
  ])
  print("Document successfully updated")
} catch {
  print("Error updating document: \(error)")
}
Objectif c

Utilisez la méthode fieldValueForDelete: : :

Remarque : ce produit n'est pas disponible sur les cibles watchOS et App Clip.
[[[self.db collectionWithPath:@"cities"] documentWithPath:@"BJ"] updateData:@{
  @"capital": [FIRFieldValue fieldValueForDelete]
} completion:^(NSError * _Nullable error) {
  if (error != nil) {
    NSLog(@"Error updating document: %@", error);
  } else {
    NSLog(@"Document successfully updated");
  }
}];

Kotlin+KTX

Utilisez la méthode FieldValue.delete() :

val docRef = db.collection("cities").document("BJ")

// Remove the 'capital' field from the document
val updates = hashMapOf<String, Any>(
    "capital" to FieldValue.delete(),
)

docRef.update(updates).addOnCompleteListener { }

Java

Utilisez la méthode FieldValue.delete() :

DocumentReference docRef = db.collection("cities").document("BJ");

// Remove the 'capital' field from the document
Map<String,Object> updates = new HashMap<>();
updates.put("capital", FieldValue.delete());

docRef.update(updates).addOnCompleteListener(new OnCompleteListener<Void>() {
    // ...
    // ...

Dart

Utilisez la méthode FieldValue.delete() :

final docRef = db.collection("cities").doc("BJ");

// Remove the 'capital' field from the document
final updates = <String, dynamic>{
  "capital": FieldValue.delete(),
};

docRef.update(updates);
Java

Utilisez la méthode FieldValue.delete() :

DocumentReference docRef = db.collection("cities").document("BJ");
Map<String, Object> updates = new HashMap<>();
updates.put("capital", FieldValue.delete());
// Update and delete the "capital" field in the document
ApiFuture<WriteResult> writeResult = docRef.update(updates);
System.out.println("Update time : " + writeResult.get());
Python

Utilisez la méthode firestore.DELETE_FIELD :

city_ref = db.collection("cities").document("BJ")
city_ref.update({"capital": firestore.DELETE_FIELD})

Python

Utilisez la méthode firestore.DELETE_FIELD :

city_ref = db.collection("cities").document("BJ")
await city_ref.update({"capital": firestore.DELETE_FIELD})
C++

Utilisez la méthode FieldValue::Delete() :

DocumentReference doc_ref = db->Collection("cities").Document("BJ");
doc_ref.Update({{"capital", FieldValue::Delete()}})
    .OnCompletion([](const Future<void>& future) { /*...*/ });
Noeud.js

Utilisez la méthode FieldValue.delete() :

// Create a document reference
const cityRef = db.collection('cities').doc('BJ');

// Remove the 'capital' field from the document
const res = await cityRef.update({
  capital: FieldValue.delete()
});
Aller

Utilisez la méthode firestore.Delete :


import (
	"context"
	"log"

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

func deleteField(ctx context.Context, client *firestore.Client) error {
	_, err := client.Collection("cities").Doc("BJ").Update(ctx, []firestore.Update{
		{
			Path:  "capital",
			Value: firestore.Delete,
		},
	})
	if err != nil {
		// Handle any errors in an appropriate way, such as returning them.
		log.Printf("An error has occurred: %s", err)
	}

	// ...
	return err
}
PHP

Utilisez la méthode FieldValue::deleteField() :

$cityRef = $db->collection('samples/php/cities')->document('BJ');
$cityRef->update([
    ['path' => 'capital', 'value' => FieldValue::deleteField()]
]);
Unité

Utilisez la méthode FieldValue.Delete :

DocumentReference cityRef = db.Collection("cities").Document("BJ");
Dictionary<string, object> updates = new Dictionary<string, object>
{
    { "Capital", FieldValue.Delete }
};
C#

Utilisez la méthode FieldValue.Delete :

DocumentReference cityRef = db.Collection("cities").Document("BJ");
Dictionary<string, object> updates = new Dictionary<string, object>
{
    { "Capital", FieldValue.Delete }
};
await cityRef.UpdateAsync(updates);
Rubis

Utilisez la méthode firestore.field_delete :

city_ref = firestore.doc "#{collection_path}/BJ"
city_ref.update({ capital: firestore.field_delete })

Supprimer des collections

Pour supprimer une collection ou une sous-collection entière dans Cloud Firestore, récupérez (lisez) tous les documents de la collection ou de la sous-collection et supprimez-les. Ce processus entraîne des coûts de lecture et de suppression. Si vous disposez de collections plus importantes, vous souhaiterez peut-être supprimer les documents par lots plus petits pour éviter les erreurs de mémoire insuffisante. Répétez le processus jusqu'à ce que vous ayez supprimé l'intégralité de la collection ou de la sous-collection.

La suppression d'une collection nécessite la coordination d'un nombre illimité de demandes de suppression individuelles. Si vous devez supprimer des collections entières, faites-le uniquement à partir d'un environnement de serveur approuvé. Bien qu'il soit possible de supprimer une collection d'un client mobile/Web, cela a des implications négatives en matière de sécurité et de performances.

Les extraits ci-dessous sont quelque peu simplifiés et ne traitent pas de la gestion des erreurs, de la sécurité, de la suppression de sous-collections ou de l'optimisation des performances. Pour en savoir plus sur une approche recommandée pour supprimer des collections en production, consultez Suppression de collections et de sous-collections .

la toile
// Deleting collections from a Web client is not recommended.
Rapide
Remarque : ce produit n'est pas disponible sur les cibles watchOS et App Clip.
// Deleting collections from an Apple client is not recommended.
Objectif c
Remarque : ce produit n'est pas disponible sur les cibles watchOS et App Clip.
// Deleting collections from an Apple client is not recommended.
  

Kotlin+KTX

// Deleting collections from an Android client is not recommended.

Java

// Deleting collections from an Android client is not recommended.

Dart

La suppression des collections du client n'est pas recommandée.

Java
/**
 * Delete a collection in batches to avoid out-of-memory errors. Batch size may be tuned based on
 * document size (atmost 1MB) and application requirements.
 */
void deleteCollection(CollectionReference collection, int batchSize) {
  try {
    // retrieve a small batch of documents to avoid out-of-memory errors
    ApiFuture<QuerySnapshot> future = collection.limit(batchSize).get();
    int deleted = 0;
    // future.get() blocks on document retrieval
    List<QueryDocumentSnapshot> documents = future.get().getDocuments();
    for (QueryDocumentSnapshot document : documents) {
      document.getReference().delete();
      ++deleted;
    }
    if (deleted >= batchSize) {
      // retrieve and delete another batch
      deleteCollection(collection, batchSize);
    }
  } catch (Exception e) {
    System.err.println("Error deleting collection : " + e.getMessage());
  }
}
Python
def delete_collection(coll_ref, batch_size):
    if batch_size == 0:
        return

    docs = coll_ref.list_documents(page_size=batch_size)
    deleted = 0

    for doc in docs:
        print(f"Deleting doc {doc.id} => {doc.get().to_dict()}")
        doc.delete()
        deleted = deleted + 1

    if deleted >= batch_size:
        return delete_collection(coll_ref, batch_size)

Python

async def delete_collection(coll_ref, batch_size):
    docs = coll_ref.limit(batch_size).stream()
    deleted = 0

    async for doc in docs:
        print(f"Deleting doc {doc.id} => {doc.to_dict()}")
        await doc.reference.delete()
        deleted = deleted + 1

    if deleted >= batch_size:
        return delete_collection(coll_ref, batch_size)
C++
// This is not supported. Delete data using CLI as discussed below.
  
Noeud.js
async function deleteCollection(db, collectionPath, batchSize) {
  const collectionRef = db.collection(collectionPath);
  const query = collectionRef.orderBy('__name__').limit(batchSize);

  return new Promise((resolve, reject) => {
    deleteQueryBatch(db, query, resolve).catch(reject);
  });
}

async function deleteQueryBatch(db, query, resolve) {
  const snapshot = await query.get();

  const batchSize = snapshot.size;
  if (batchSize === 0) {
    // When there are no documents left, we are done
    resolve();
    return;
  }

  // Delete documents in a batch
  const batch = db.batch();
  snapshot.docs.forEach((doc) => {
    batch.delete(doc.ref);
  });
  await batch.commit();

  // Recurse on the next process tick, to avoid
  // exploding the stack.
  process.nextTick(() => {
    deleteQueryBatch(db, query, resolve);
  });
}
Aller

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/firestore"
	"google.golang.org/api/iterator"
)

func deleteCollection(w io.Writer, projectID, collectionName string,
	batchSize int) error {

	// Instantiate a client
	ctx := context.Background()
	client, err := firestore.NewClient(ctx, projectID)
	if err != nil {
		return err
	}

	col := client.Collection(collectionName)
	bulkwriter := client.BulkWriter(ctx)

	for {
		// Get a batch of documents
		iter := col.Limit(batchSize).Documents(ctx)
		numDeleted := 0

		// Iterate through the documents, adding
		// a delete operation for each one to the BulkWriter.
		for {
			doc, err := iter.Next()
			if err == iterator.Done {
				break
			}
			if err != nil {
				return err
			}

			bulkwriter.Delete(doc.Ref)
			numDeleted++
		}

		// If there are no documents to delete,
		// the process is over.
		if numDeleted == 0 {
			bulkwriter.End()
			break
		}

		bulkwriter.Flush()
	}
	fmt.Fprintf(w, "Deleted collection \"%s\"", collectionName)
	return nil
}
PHP
function data_delete_collection(string $projectId, string $collectionName, int $batchSize)
{
    // Create the Cloud Firestore client
    $db = new FirestoreClient([
        'projectId' => $projectId,
    ]);
    $collectionReference = $db->collection($collectionName);
    $documents = $collectionReference->limit($batchSize)->documents();
    while (!$documents->isEmpty()) {
        foreach ($documents as $document) {
            printf('Deleting document %s' . PHP_EOL, $document->id());
            $document->reference()->delete();
        }
        $documents = $collectionReference->limit($batchSize)->documents();
    }
}
Unité
// This is not supported. Delete data using CLI as discussed below.
C#
private static async Task DeleteCollection(CollectionReference collectionReference, int batchSize)
{
    QuerySnapshot snapshot = await collectionReference.Limit(batchSize).GetSnapshotAsync();
    IReadOnlyList<DocumentSnapshot> documents = snapshot.Documents;
    while (documents.Count > 0)
    {
        foreach (DocumentSnapshot document in documents)
        {
            Console.WriteLine("Deleting document {0}", document.Id);
            await document.Reference.DeleteAsync();
        }
        snapshot = await collectionReference.Limit(batchSize).GetSnapshotAsync();
        documents = snapshot.Documents;
    }
    Console.WriteLine("Finished deleting all documents from the collection.");
}
Rubis
cities_ref = firestore.col collection_path
query      = cities_ref

query.get do |document_snapshot|
  puts "Deleting document #{document_snapshot.document_id}."
  document_ref = document_snapshot.ref
  document_ref.delete
end

Supprimer des données avec la CLI Firebase

Vous pouvez également utiliser la CLI Firebase pour supprimer des documents et des collections. Utilisez la commande suivante pour supprimer des données :

firebase firestore:delete [options] <<path>>

Supprimer des données avec la console

Vous pouvez supprimer des documents et des collections de la page Cloud Firestore de la console . La suppression d'un document de la console supprime toutes les données imbriquées dans ce document, y compris les sous-collections.

Supprimer des données avec des politiques TTL

Une stratégie TTL désigne un champ donné comme délai d'expiration pour les documents d'un groupe de collecte donné. Les opérations de suppression TTL sont prises en compte dans les coûts de suppression de vos documents.

Pour plus d'informations sur la définition de la durée de vie, consultez Gérer la conservation des données avec des stratégies TTL .

Pour plus d'informations sur les codes d'erreur et sur la façon de résoudre les problèmes de latence lors de la suppression de données, consultez la page de dépannage .

Supprimer des données avec Dataflow

Dataflow est un excellent outil pour les opérations groupées sur votre base de données Firestore. Le billet de blog d'introduction du connecteur Firestore pour Dataflow présente un exemple de suppression de tous les documents d'un groupe de collection.