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 suivante :

Web

Utilisez la méthode deleteDoc().

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

await deleteDoc(doc(db, "cities", "DC"));
delete_document.js

Web

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);
});
test.firestore.js
Swift

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)")
}
ViewController.swift
Objective-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!");
      }
}];
ViewController.m

Kotlin

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) }
DocSnippets.kt

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);
            }
        });
DocSnippets.java

Dart

Utilisez la méthode delete().

db.collection("cities").doc("DC").delete().then(
      (doc) => print("Document deleted"),
      onError: (e) => print("Error updating document $e"),
    );
firestore.dart
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());
ManageDataSnippets.java
Python

Utilisez la méthode delete().

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

Python

Utilisez la méthode delete().

await db.collection("cities").document("DC").delete()
snippets.py
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;
      }
    });
snippets.cpp
Node.js

Utilisez la méthode delete().

const res = await db.collection('cities').doc('DC').delete();
index.js
Accéder

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
}

save_data_delete_doc.go
PHP

Utilisez la méthode delete().

$db->collection('samples/php/cities')->document('DC')->delete();
data_delete_doc.php
Unity

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();
Program.cs
Ruby

Utilisez la méthode delete().

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

Lorsque vous supprimez un document, Cloud Firestore ne supprime pas automatiquement les documents de ses sous-collections. Vous pouvez toujours accéder aux documents des sous-collections par référence. Par exemple, vous pouvez accéder au document en suivant le chemin d'accès /mycoll/mydoc/mysubcoll/mysubdoc même si vous supprimez le document ancêtre à l'emplacement /mycoll/mydoc.

Des 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 la section 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 suivante lorsque vous mettez à jour un document :

Web

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()
});
update_delete_field.js

Web

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()
});
test.firestore.js
Swift

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)")
}
ViewController.swift
Objective-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");
  }
}];
ViewController.m

Kotlin

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 { }
DocSnippets.kt

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>() {
    // ...
    // ...
DocSnippets.java

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);
firestore.dart
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());
ManageDataSnippets.java
Python

Utilisez la méthode firestore.DELETE_FIELD.

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

Python

Utilisez la méthode firestore.DELETE_FIELD.

city_ref = db.collection("cities").document("BJ")
await city_ref.update({"capital": firestore.DELETE_FIELD})
snippets.py
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) { /*...*/ });
snippets.cpp
Node.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()
});
index.js
Accéder

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
}

save_data_delete_field.go
PHP

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

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

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);
Program.cs
Ruby

Utilisez la méthode firestore.field_delete.

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

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 vos collections sont plus volumineuses, vous pouvez les supprimer en petits lots 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 requêtes de suppression individuelles. Si vous devez supprimer des collections entières, faites-le uniquement depuis un environnement de serveur de confiance. Bien qu'il soit possible de supprimer une collection d'un client mobile ou Web, cela a des implications négatives en termes de sécurité et de performance.

Les extraits suivants sont simplifiés pour plus de clarté et n'incluent pas la gestion des erreurs, la sécurité, la suppression des sous-collections ni les optimisations des performances. Pour en savoir plus sur une méthode recommandée pour supprimer des collections en production, consultez la section Supprimer des collections et sous-collections.

Web 
// Deleting collections from a Web client is not recommended.
Swift
Remarque : Ce produit n'est pas disponible sur les cibles watchOS et App Clip. 
// Deleting collections from an Apple client is not recommended.
Objective-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

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

Java

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

Dart

Il n'est pas recommandé de supprimer des collections depuis le client.

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());
  }
}

ManageDataSnippets.java
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)

snippets.py

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)

snippets.py
C++
// This is not supported. Delete data using CLI as discussed below.
Node.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);
  });
}

index.js
Go

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
}

save_data_delete_collection.go
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();
    }
}
data_delete_collection.php
Unity
// 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.");
}
Program.cs
Ruby
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
delete_data.rb

Supprimer des données avec des règles TTL

Une règle TTL désigne un champ donné comme heure d'expiration des documents d'un groupe de collections donné. Les opérations de suppression TTL sont comptabilisées dans vos coûts de suppression de documents.

Pour savoir comment définir le TTL, consultez Gérer la conservation des données avec des règles TTL.

Tâches de suppression groupée

Cloud Firestore est compatible avec plusieurs outils de suppression groupée. Vous devez sélectionner un outil en fonction du nombre de documents que vous devez supprimer et du niveau de configurabilité dont vous avez besoin.

Pour les tâches plus petites, de l'ordre de milliers de documents, utilisez la console ou la CLI Firebase. Pour les tâches plus importantes, ces outils peuvent commencer à expirer et vous obliger à les exécuter plusieurs fois.

Console

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

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  --database=DATABASE_ID PATH

Remplacez DATABASE_ID par l'ID de votre base de données et PATH par le chemin d'accès à un document ou à une collection.

Pour les grands jobs de suppression (millions de documents), utilisez l'une des méthodes suivantes :

Suppression groupée gérée

Cloud Firestore permet de supprimer plusieurs groupes de collections à la fois. Pour en savoir plus, consultez Supprimer des données de manière groupée.

Connecteur Dataflow

Vous pouvez utiliser Dataflow pour effectuer des opérations groupées sur votre base de données. Cette option est la plus configurable, mais elle nécessite également plus de configuration que les autres options de suppression groupée. L'article de blog sur le connecteur Cloud Firestore et l'introduction à Dataflow contient un exemple de suppression de tous les documents d'un groupe de collections.