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

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

מחק מסמכים

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

אינטרנט v8

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

אינטרנט v9

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

await deleteDoc(doc(db, "cities", "DC"));
מָהִיר
db.collection("cities").document("DC").delete() { err in
    if let err = err {
        print("Error removing document: \(err)")
    } else {
        print("Document successfully removed!")
    }
}
מטרה-ג
[[[self.db collectionWithPath:@"cities"] documentWithPath:@"DC"]
    deleteDocumentWithCompletion:^(NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error removing document: %@", error);
      } else {
        NSLog(@"Document successfully removed!");
      }
}];

ג'אווה

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

Kotlin + KTX

db.collection("cities").document("DC")
        .delete()
        .addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully deleted!") }
        .addOnFailureListener { e -> Log.w(TAG, "Error deleting document", e) }
ג'אווה
// asynchronously delete a document
ApiFuture<WriteResult> writeResult = db.collection("cities").document("DC").delete();
// ...
System.out.println("Update time : " + writeResult.get().getUpdateTime());
פִּיתוֹן
db.collection(u'cities').document(u'DC').delete()

פִּיתוֹן

await db.collection("cities").document("DC").delete()
C ++
db->Collection("cities").Document("DC").Delete().OnCompletion(
    [](const Future<void>& future) {
      if (future.error() == Error::kErrorOk) {
        std::cout << "DocumentSnapshot successfully deleted!\n";
      } else {
        std::cout << "Error deleting document: " << future.error_message()
                  << '\n';
      }
    });
Node.js
const res = await db.collection('cities').doc('DC').delete();
ללכת
_, 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)
}
PHP
$db->collection('samples/php/cities')->document('DC')->delete();
אַחְדוּת
DocumentReference cityRef = db.Collection("cities").Document("DC");
cityRef.DeleteAsync();
C #
DocumentReference cityRef = db.Collection("cities").Document("DC");
await cityRef.DeleteAsync();
אוֹדֶם
city_ref = firestore.doc "#{collection_path}/DC"
city_ref.delete

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

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

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

מחק שדות

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

אינטרנט v8

var cityRef = db.collection('cities').doc('BJ');

// Remove the 'capital' field from the document
var removeCapital = cityRef.update({
    capital: firebase.firestore.FieldValue.delete()
});

אינטרנט v9

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()
});
מָהִיר
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")
    }
}
מטרה-ג
[[[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");
  }
}];

ג'אווה

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

Kotlin + KTX

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 { }
ג'אווה
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());
פִּיתוֹן
city_ref = db.collection(u'cities').document(u'BJ')
city_ref.update({
    u'capital': firestore.DELETE_FIELD
})

פִּיתוֹן

city_ref = db.collection("cities").document("BJ")
await city_ref.update({"capital": firestore.DELETE_FIELD})
C ++
DocumentReference doc_ref = db->Collection("cities").Document("BJ");
doc_ref.Update({{"capital", FieldValue::Delete()}})
    .OnCompletion([](const Future<void>& future) { /*...*/ });
Node.js
// Get the `FieldValue` object
const FieldValue = admin.firestore.FieldValue;

// 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()
});
ללכת
_, 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)
}
PHP
$cityRef = $db->collection('samples/php/cities')->document('BJ');
$cityRef->update([
    ['path' => 'capital', 'value' => FieldValue::deleteField()]
]);
אַחְדוּת
DocumentReference cityRef = db.Collection("cities").Document("BJ");
Dictionary<string, object> updates = new Dictionary<string, object>
{
    { "Capital", FieldValue.Delete }
};
C #
DocumentReference cityRef = db.Collection("cities").Document("BJ");
Dictionary<string, object> updates = new Dictionary<string, object>
{
    { "Capital", FieldValue.Delete }
};
await cityRef.UpdateAsync(updates);
אוֹדֶם
city_ref = firestore.doc "#{collection_path}/BJ"
city_ref.update({ capital: firestore.field_delete })

מחק אוספים

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

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

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

אינטרנט
// Deleting collections from a Web client is not recommended.
מָהִיר
// Deleting collections from an iOS client is not recommended.
מטרה-ג
// Deleting collections from an iOS client is not recommended.
  

ג'אווה

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

Kotlin + KTX

// Deleting collections from an Android client is not recommended.
ג'אווה
/** 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.limit(batch_size).stream()
    deleted = 0

    for doc in docs:
        print(f'Deleting doc {doc.id} => {doc.to_dict()}')
        doc.reference.delete()
        deleted = deleted + 1

    if deleted >= batch_size:
        return delete_collection(coll_ref, batch_size)

פִּיתוֹן

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);
  });
}
ללכת
func deleteCollection(ctx context.Context, client *firestore.Client,
	ref *firestore.CollectionRef, batchSize int) error {

	for {
		// Get a batch of documents
		iter := ref.Limit(batchSize).Documents(ctx)
		numDeleted := 0

		// Iterate through the documents, adding
		// a delete operation for each one to a
		// WriteBatch.
		batch := client.Batch()
		for {
			doc, err := iter.Next()
			if err == iterator.Done {
				break
			}
			if err != nil {
				return err
			}

			batch.Delete(doc.Ref)
			numDeleted++
		}

		// If there are no documents to delete,
		// the process is over.
		if numDeleted == 0 {
			return nil
		}

		_, err := batch.Commit(ctx)
		if err != nil {
			return err
		}
	}
}
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

מחק נתונים באמצעות ה- CLI של Firebase

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

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

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

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