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() suivantes, spécifiques à chaque langage:

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+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) }
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 suivantes 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+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 { }
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, puis 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 ci-dessous sont simplifiés et ne traitent pas de la gestion des erreurs, de la sécurité, de la suppression des sous-collections, ni de l'optimisation 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+KTX

// 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 du 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 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 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.

Supprimer des données avec des règles TTL

Une règle TTL désigne un champ donné comme date 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 en savoir plus sur la définition du TTL, consultez Gérer la conservation des données avec des règles TTL.

Pour en savoir plus sur les codes d'erreur et découvrir comment 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. L'article de blog sur l'introduction du connecteur Firestore pour Dataflow contient un exemple de suppression de tous les documents d'un groupe de collections.

Utiliser la suppression groupée gérée

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