מחק נתונים מ-Cloud Firestore

הדוגמאות הבאות מדגימות כיצד למחוק מסמכים, שדות ואוספים.

מחק מסמכים

כדי למחוק מסמך, השתמש בשיטות delete() הספציפיות לשפה הבאות:

Web modular API

השתמש בשיטת deleteDoc() :

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

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

Web namespaced API

השתמש בשיטת delete() :

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

השתמש בשיטת delete() :

הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
do {
  try await db.collection("cities").document("DC").delete()
  print("Document successfully removed!")
} catch {
  print("Error removing document: \(error)")
}
Objective-C

השתמש בשיטת deleteDocumentWithCompletion: ::

הערה: מוצר זה אינו זמין ביעדי watchOS ו-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

השתמש בשיטת delete() :

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

Java

השתמש בשיטת 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

השתמש בשיטת delete() :

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

השתמש בשיטת delete() :

// asynchronously delete a document
ApiFuture<WriteResult> writeResult = db.collection("cities").document("DC").delete();
// ...
System.out.println("Update time : " + writeResult.get().getUpdateTime());
פִּיתוֹן

השתמש בשיטת delete() :

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

Python

השתמש בשיטת delete() :

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

השתמש בשיטת 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;
      }
    });
Node.js

השתמש בשיטת delete() :

const res = await db.collection('cities').doc('DC').delete();
ללכת

השתמש בשיטת 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

השתמש בשיטת delete() :

$db->collection('samples/php/cities')->document('DC')->delete();
אַחְדוּת

השתמש בשיטת DeleteAsync() :

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

השתמש בשיטת DeleteAsync() :

DocumentReference cityRef = db.Collection("cities").Document("DC");
await cityRef.DeleteAsync();
אוֹדֶם

השתמש בשיטת delete() :

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

כאשר אתה מוחק מסמך, Cloud Firestore לא מוחק אוטומטית את המסמכים בתוך אוספי המשנה שלו. אתה עדיין יכול לגשת למסמכי איסוף המשנה על ידי הפניה. לדוגמה, אתה יכול לגשת למסמך ב-path /mycoll/mydoc/mysubcoll/mysubdoc גם אם תמחק את מסמך האב ב- /mycoll/mydoc .

מסמכים קדומים שאינם קיימים מופיעים במסוף , אך הם אינם מופיעים בתוצאות שאילתות ובתצלומי מצב.

אם ברצונך למחוק מסמך ואת כל המסמכים שבתת-האוספים שלו, עליך לעשות זאת באופן ידני. למידע נוסף, ראה מחיקת אוספים .

מחק שדות

כדי למחוק שדות ספציפיים ממסמך, השתמש בשיטות FieldValue.delete() הספציפיות לשפה הבאות בעת עדכון מסמך:

Web modular API

השתמש בשיטת 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

השתמש בשיטת 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()
});
מָהִיר

השתמש בשיטת FieldValue.delete() :

הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
do {

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

השתמש בשיטת fieldValueForDelete: ::

הערה: מוצר זה אינו זמין ביעדי watchOS ו-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

השתמש בשיטת 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

השתמש בשיטת 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

השתמש בשיטת 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

השתמש בשיטת 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());
פִּיתוֹן

השתמש בשיטת firestore.DELETE_FIELD :

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

Python

השתמש בשיטת firestore.DELETE_FIELD :

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

השתמש בשיטת FieldValue::Delete() :

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

השתמש בשיטת 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()
});
ללכת

השתמש בשיטת 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

השתמש בשיטת FieldValue::deleteField() :

$cityRef = $db->collection('samples/php/cities')->document('BJ');
$cityRef->update([
    ['path' => 'capital', 'value' => FieldValue::deleteField()]
]);
אַחְדוּת

השתמש בשיטת FieldValue.Delete :

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

השתמש בשיטת FieldValue.Delete :

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

השתמש בשיטת firestore.field_delete :

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

מחק אוספים

כדי למחוק אוסף שלם או תת-אוסף ב-Cloud Firestore, אחזר (קרא) את כל המסמכים בתוך האוסף או המשנה ומחק אותם. תהליך זה כרוך בעלויות קריאה ומחיקה כאחד. אם יש לך אוספים גדולים יותר, ייתכן שתרצה למחוק את המסמכים בקבוצות קטנות יותר כדי למנוע שגיאות חסרות הזיכרון. חזור על התהליך עד שתמחק את כל האוסף או המשנה.

מחיקת אוסף מחייבת תיאום של מספר בלתי מוגבל של בקשות מחיקה בודדות. אם אתה צריך למחוק אוספים שלמים, עשה זאת רק מסביבת שרת מהימנה. אמנם ניתן למחוק אוסף מלקוח סלולרי/אינטרנט, אך יש לכך השלכות אבטחה וביצועים שליליות.

הקטעים שלהלן מעט מפושטים ואינם עוסקים בטיפול בשגיאות, אבטחה, מחיקת אוספי משנה או מקסום ביצועים. למידע נוסף על גישה מומלצת אחת למחיקת אוספים בהפקה, ראה מחיקת אוספים ותתי-אוספים .

אינטרנט
// Deleting collections from a Web client is not recommended.
מָהִיר
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
// Deleting collections from an Apple client is not recommended.
Objective-C
הערה: מוצר זה אינו זמין ביעדי watchOS ו-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

לא מומלץ למחוק אוספים מהלקוח.

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());
  }
}
פִּיתוֹן
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)

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.
  
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);
  });
}
ללכת

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();
    }
}
אַחְדוּת
// 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.");
}
אוֹדֶם
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

מחק נתונים עם Firebase CLI

אתה יכול גם להשתמש ב- Firebase CLI כדי למחוק מסמכים ואוספים. השתמש בפקודה הבאה כדי למחוק נתונים:

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

מחק נתונים באמצעות המסוף

אתה יכול למחוק מסמכים ואוספים מדף Cloud Firestore במסוף . מחיקת מסמך מהמסוף מוחקת את כל הנתונים המקוננים במסמך זה, כולל אוספי משנה כלשהם.

מחק נתונים עם מדיניות TTL

מדיניות TTL מציינת שדה נתון כזמן התפוגה של מסמכים בקבוצת איסוף נתונה. פעולות מחיקת TTL נחשבות לעלויות מחיקת המסמכים שלך.

למידע על הגדרת TTL, ראה ניהול שמירת נתונים עם מדיניות TTL .

למידע נוסף על קודי שגיאה וכיצד לפתור בעיות אחזור בעת מחיקת נתונים, עיין בדף פתרון הבעיות .

מחק נתונים עם Dataflow

Dataflow הוא כלי נהדר לפעולות בכמות גדולה במסד הנתונים שלך ב-Firestore. פוסט הבלוג המבוא של Firestore for Dataflow כולל דוגמה למחיקת כל המסמכים בקבוצת איסוף.