Eliminare documenti e campi

Eliminare documenti e campi

I seguenti esempi mostrano come eliminare documenti, campi raccolte.

Elimina documenti

Per eliminare un documento, utilizza i seguenti metodi delete() specifici per la lingua:

Versione web 9

Utilizza il metodo deleteDoc():

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

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

Versione web 8

Usa 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

Swift

Utilizza il metodo delete():

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

Utilizza il metodo deleteDocumentWithCompletion::

Nota: questo prodotto non è disponibile come target per 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
Android

Usa 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
Android

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

Usa il metodo delete():

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

Java

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

Python

Usa il metodo delete():

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

Python
(Async)

Utilizza il metodo delete():

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

C++

Usa 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

Vai

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

Usa il metodo delete():

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

Unity

Utilizza il metodo DeleteAsync():

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

C#

Usa il metodo DeleteAsync():

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

Ruby

Usa il metodo delete():

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

Attenzione: l'eliminazione di un documento non comporta l'eliminazione delle relative sottocollezioni.

Quando elimini un documento, Firestore non elimina automaticamente i documenti all'interno delle sue sottocollezioni. Puoi comunque accedere ai documenti della sottoraccolta tramite riferimento. Ad esempio, puoi accedere al documento nel percorso/mycoll/mydoc/mysubcoll/mysubdoc anche se elimini il documento principale in /mycoll/mydoc.

I documenti predecessore inesistenti vengono visualizzati nella console, ma non appariranno nei risultati delle query e negli snapshot.

Se vuoi eliminare un documento e tutti i documenti all'interno delle sue raccolte secondarie, devi farlo manualmente. Per ulteriori informazioni, vedi Eliminare le raccolte.

Elimina campi

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

Versione web 9

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

Versione web 8

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

Swift

Utilizza il metodo FieldValue.delete():

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

Utilizza il metodo fieldValueForDelete::

Nota: questo prodotto non è disponibile come target per 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
Android

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
Android

Usa 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

Usa 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

Java

Usa 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

Python

Usa il metodo firestore.DELETE_FIELD:

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

Python
(Async)

Usa il metodo firestore.DELETE_FIELD:

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

C++

Usa 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

Usa 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

Vai

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

Unity

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

Ruby

Utilizza il metodo firestore.field_delete:

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

Eliminare le raccolte

Per eliminare un'intera raccolta o sottoraccolta in Firestore: recuperare (leggere) tutti i documenti all'interno della raccolta o sottoraccolta ed eliminare che li rappresentano. Questo processo prevede costi sia di lettura che di eliminazione. Se hai immagini più grandi raccolte, è consigliabile eliminare i documenti in batch più piccoli per evitare di esaurimento della memoria. Ripeti la procedura finché non avrai eliminato l'intero in una raccolta o una sottoraccolta.

L'eliminazione di una raccolta richiede il coordinamento di un numero illimitato singole richieste di eliminazione. Se devi eliminare intere raccolte, puoi farlo solo da un ambiente server attendibile. Sebbene sia possibile eliminare una raccolta da un client web/mobile, ciò ha implicazioni negative in termini di sicurezza e prestazioni.

Gli snippet riportati di seguito sono semplificati e non gestiscono la gestione degli errori, la sicurezza, l'eliminazione delle sottocollezioni o la massimizzazione delle prestazioni. Per scoprire di più su un approccio consigliato per eliminare le raccolte in produzione, consulta Eliminazione di raccolte e raccolte secondarie.

Web

// Deleting collections from a Web client is not recommended.

Swift

Nota: questo prodotto non è disponibile come target per watchOS e App Clip.

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

Objective-C

Nota: questo prodotto non è disponibile come target per watchOS e App Clip.

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

Kotlin+KTX
Android

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

Java
Android

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

Dart

L'eliminazione delle raccolte dal client non è consigliata.

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
(asincrono)

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

Vai

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

Elimina i dati con l'interfaccia a riga di comando di Firebase

Puoi anche utilizzare l'interfaccia a riga di comando di Firebase per eliminare documenti e raccolte. Utilizza il seguente comando per eliminare i dati:

Nota: l'eliminazione dei dati con l'interfaccia a riga di comando di Firebase comporta costi di lettura ed eliminazione. Per ulteriori informazioni, vedi Prezzi.

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

Elimina i dati con la console

Puoi elimina documenti e raccolte dalla pagina Firestore nella console. L'eliminazione di un documento dalla console comporta l'eliminazione di tutti i dati nidificati al suo interno, incluse le eventuali sottoraccolte.

Nota: l'eliminazione dei dati con l'interfaccia a riga di comando di Firebase comporta costi di lettura ed eliminazione. Per ulteriori informazioni, consulta la sezione Prezzi.

Elimina i dati con criteri TTL

Un criterio TTL designa un determinato campo come data di scadenza per i documenti in un un determinato gruppo di raccolte. Le operazioni di eliminazione TTL vengono conteggiate ai fini dell'eliminazione dei documenti costi aggiuntivi.

Per informazioni sull'impostazione del 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.

Eliminare i dati con Dataflow

Dataflow è un ottimo strumento per le operazioni collettive sul database Firestore. La Il post del blog dell'introduzione al connettore Firestore per Dataflow presenta un esempio dell'eliminazione di tutti i documenti in un gruppo di raccolte.