Elimina i dati da Cloud Firestore

Gli esempi seguenti dimostrano come eliminare documenti, campi e raccolte.

Elimina documenti

Per eliminare un documento, utilizzare i seguenti metodi delete() specifici della lingua:

Web modular API

Utilizza il metodo deleteDoc() :

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

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

Web namespaced API

Utilizza il metodo delete() :

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

Utilizza il metodo delete() :

Nota: questo prodotto non è disponibile sui target watchOS e App Clip.
db.collection("cities").document("DC").delete() { err in
    if let err = err {
        print("Error removing document: \(err)")
    } else {
        print("Document successfully removed!")
    }
}
ViewController.swift
Obiettivo-C

Utilizza il metodo deleteDocumentWithCompletion: ::

Nota: questo prodotto non è disponibile sui target watchOS e 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

Utilizza il metodo 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

Utilizza il metodo 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

Utilizza il metodo delete() :

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

Utilizza il metodo delete() :

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

Utilizza il metodo delete() :

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

Python

Utilizza il metodo delete() :

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

Utilizza il metodo 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

Utilizza il metodo delete() :

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

Utilizza il metodo 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

Utilizza il metodo delete() :

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

Utilizza il metodo DeleteAsync() :

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

Utilizza il metodo DeleteAsync() :

DocumentReference cityRef = db.Collection("cities").Document("DC");
await cityRef.DeleteAsync();
Program.cs
Rubino

Utilizza il metodo delete() :

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

Quando elimini un documento, Cloud Firestore non elimina automaticamente i documenti nelle sue sottoraccolte. È comunque possibile accedere ai documenti della sottoraccolta tramite riferimento. Ad esempio, puoi accedere al documento nel percorso /mycoll/mydoc/mysubcoll/mysubdoc anche se elimini il documento antenato in /mycoll/mydoc .

Nella console vengono visualizzati documenti antenati inesistenti, ma non vengono visualizzati nei risultati delle query e negli snapshot.

Se desideri eliminare un documento e tutti i documenti nelle sue sottoraccolte, devi farlo manualmente. Per ulteriori informazioni, vedere Elimina raccolte .

Elimina campi

Per eliminare campi specifici da un documento, utilizza i seguenti metodi FieldValue.delete() specifici della lingua quando aggiorni un documento:

Web modular API

Utilizza il metodo 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 namespaced API

Utilizza il metodo 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
Veloce

Utilizza il metodo FieldValue.delete() :

Nota: questo prodotto non è disponibile sui target watchOS e App Clip.
db.collection("cities").document("BJ").updateData([
    "capital": FieldValue.delete(),
]) { err in
    if let err = err {
        print("Error updating document: \(err)")
    } else {
        print("Document successfully updated")
    }
}
ViewController.swift
Obiettivo-C

Utilizza il metodo fieldValueForDelete: ::

Nota: questo prodotto non è disponibile sui target watchOS e 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

Utilizza il metodo 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

Utilizza il metodo 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

Utilizza il metodo 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
Giava

Utilizza il metodo 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
Pitone

Utilizza il metodo firestore.DELETE_FIELD :

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

Python

Utilizza il metodo firestore.DELETE_FIELD :

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

Utilizza il metodo 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

Utilizza il metodo 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
Andare

Utilizza il metodo 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

Utilizza il metodo FieldValue::deleteField() :

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

Utilizza il metodo FieldValue.Delete :

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

Utilizza il metodo 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
Rubino

Utilizza il metodo firestore.field_delete :

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

Elimina raccolte

Per eliminare un'intera raccolta o sottoraccolta in Cloud Firestore, recupera (leggi) tutti i documenti all'interno della raccolta o sottoraccolta ed eliminali. Questo processo comporta costi di lettura ed eliminazione. Se disponi di raccolte più grandi, potresti voler eliminare i documenti in batch più piccoli per evitare errori di memoria insufficiente. Ripeti la procedura finché non avrai eliminato l'intera raccolta o sottoraccolta.

L'eliminazione di una raccolta richiede il coordinamento di un numero illimitato di singole richieste di eliminazione. Se è necessario eliminare intere raccolte, farlo solo da un ambiente server attendibile. Anche se è possibile eliminare una raccolta da un client mobile/web, ciò ha implicazioni negative sulla sicurezza e sulle prestazioni.

I frammenti di seguito sono in qualche modo semplificati e non riguardano la gestione degli errori, la sicurezza, l'eliminazione di sottoraccolte o l'ottimizzazione delle prestazioni. Per ulteriori informazioni su un approccio consigliato all'eliminazione delle raccolte in produzione, consulta Eliminazione di raccolte e sottoraccolte .

ragnatela
// Deleting collections from a Web client is not recommended.
Veloce
Nota: questo prodotto non è disponibile sui target watchOS e App Clip.
// Deleting collections from an Apple client is not recommended.
Obiettivo-C
Nota: questo prodotto non è disponibile sui target watchOS e 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

Non è consigliabile eliminare le raccolte dal client.

Giava
/**
 * 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
Pitone
def delete_collection(coll_ref, batch_size):
    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
Andare

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
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.");
}
Program.cs
Rubino
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

Elimina i dati con la CLI Firebase

Puoi anche utilizzare la CLI di Firebase per eliminare documenti e raccolte. Utilizzare il seguente comando per eliminare i dati:

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

Elimina i dati con la console

Puoi eliminare documenti e raccolte dalla pagina Cloud Firestore nella console . L'eliminazione di un documento dalla console elimina tutti i dati nidificati in quel documento, incluse eventuali sottoraccolte.

Elimina i dati con i criteri TTL

Una policy TTL designa un determinato campo come data di scadenza per i documenti in un determinato gruppo di raccolte. Le operazioni di eliminazione TTL vengono conteggiate nei costi di eliminazione dei documenti.

Per informazioni sull'impostazione di TTL, consulta Gestire la conservazione dei dati con i criteri TTL .

Per ulteriori informazioni sui codici di errore e su come risolvere i problemi di latenza durante l'eliminazione dei dati, consulta la pagina di risoluzione dei problemi .

Elimina i dati con Dataflow

Dataflow è un ottimo strumento per operazioni in blocco sul tuo database Firestore. Il post di blog introduttivo al connettore Firestore per Dataflow contiene un esempio di eliminazione di tutti i documenti in un gruppo di raccolte.