Google is committed to advancing racial equity for Black communities. See how.
Bu sayfa, Cloud Translation API ile çevrilmiştir.
Switch to English

Cloud Firestore'dan verileri silin

Aşağıdaki örnekler, belgelerin, alanların ve koleksiyonların nasıl silineceğini gösterir.

Belgeleri sil

Bir belgeyi delete() için delete() yöntemini kullanın:

db.collection("cities").doc("DC").delete().then(function() {
    console.log("Document successfully deleted!");
}).catch(function(error) {
    console.error("Error removing document: ", error);
});
hızlı
db.collection("cities").document("DC").delete() { err in
    if let err = err {
        print("Error removing document: \(err)")
    } else {
        print("Document successfully removed!")
    }
}
Objective-C
[[[self.db collectionWithPath:@"cities"] documentWithPath:@"DC"]
    deleteDocumentWithCompletion:^(NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error removing document: %@", error);
      } else {
        NSLog(@"Document successfully removed!");
      }
}];
  

Java

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) }
Java
// asynchronously delete a document
ApiFuture<WriteResult> writeResult = db.collection("cities").document("DC").delete();
// ...
System.out.println("Update time : " + writeResult.get().getUpdateTime());
piton
db.collection(u'cities').document(u'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();
Git
_, 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('cities')->document('DC')->delete();
Birlik
DocumentReference cityRef = db.Collection("cities").Document("DC");
cityRef.DeleteAsync();
C #
DocumentReference cityRef = db.Collection("cities").Document("DC");
await cityRef.DeleteAsync();
yakut
city_ref = firestore.doc "cities/DC"
city_ref.delete

Bir belgeyi sildiğinizde, Cloud Firestore, alt koleksiyonlarındaki belgeleri otomatik olarak silmez. Yine de referans olarak tahsilat belgelerine erişebilirsiniz. Örneğin, /mycoll/mydoc/mysubcoll/mysubdoc üst belgeyi /mycoll/mydoc/mysubcoll/mysubdoc bile /mycoll/mydoc/mysubcoll/mysubdoc belgeye /mycoll/mydoc .

Var olmayan üst belgeler konsolda görünür , ancak sorgu sonuçlarında ve anlık görüntülerde görünmezler.

Bir belgeyi ve alt koleksiyonları içindeki tüm belgeleri silmek istiyorsanız, bunu manuel olarak yapmanız gerekir. Daha fazla bilgi için Koleksiyonları Sil bölümüne bakın.

Alanları silin

Bir belgeden belirli alanları silmek için, bir belgeyi güncellediğinizde FieldValue.delete() yöntemini kullanın:

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

// Remove the 'capital' field from the document
var removeCapital = cityRef.update({
    capital: firebase.firestore.FieldValue.delete()
});
hızlı
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")
    }
}
Objective-C
[[[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");
  }
}];
  

Java

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 { }
Java
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());
piton
city_ref = db.collection(u'cities').document(u'BJ')
city_ref.update({
    u'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()
});
Git
_, 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('cities')->document('BJ');
$cityRef->update([
    ['path' => 'capital', 'value' => FieldValue::deleteField()]
]);
Birlik
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);
yakut
city_ref = firestore.doc "cities/BJ"
city_ref.update capital: firestore.field_delete

Koleksiyonları silin

Cloud Firestore'da bir koleksiyonun veya alt koleksiyonun tamamını silmek için koleksiyon veya alt koleksiyondaki tüm belgeleri alın ve silin. Daha büyük koleksiyonlarınız varsa, yetersiz bellek hatalarını önlemek için belgeleri daha küçük gruplar halinde silmek isteyebilirsiniz. Tüm koleksiyonu veya koleksiyonu silene kadar işlemi tekrarlayın.

Bir koleksiyonun silinmesi, sınırsız sayıda bireysel silme talebinin koordine edilmesini gerektirir. Tüm koleksiyonları silmeniz gerekiyorsa, bunu yalnızca güvenilir bir sunucu ortamından yapın. Bir mobil / web istemcisinden bir koleksiyonun silinmesi mümkün olsa da, bunun güvenlik ve performans açısından olumsuz etkileri vardır.

Aşağıdaki parçacıklar bir şekilde basitleştirilmiştir ve hata işleme, güvenlik, alt koleksiyonları silme veya performansı en üst düzeye çıkarma ile ilgilenmez. Üretimde koleksiyonları silmeye yönelik önerilen bir yaklaşım hakkında daha fazla bilgi edinmek için Koleksiyonları ve Alt Koleksiyonları Silme konusuna bakın.

// Deleting collections from a Web client is not recommended.
hızlı
// Deleting collections from an iOS client is not recommended.
Objective-C
// Deleting collections from an iOS client is not recommended.
  

Java

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

Kotlin + ktx

// Deleting collections from an Android client is not recommended.
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());
  }
}
piton
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)
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);
  });
}

Git
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 delete_collection($collectionReference, $batchSize)
{
    $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();
    }
}
Birlik
// 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.");
}
yakut
cities_ref = firestore.col "cities"
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 ile verileri silin

Belgeleri ve koleksiyonları silmek için Firebase CLI'yi de kullanabilirsiniz. Verileri silmek için aşağıdaki komutu kullanın:

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

Konsol ile verileri sil

Konsoldaki Cloud Firestore sayfasından belgeleri ve koleksiyonları silebilirsiniz . Konsoldan bir belgenin silinmesi, alt koleksiyonlar da dahil olmak üzere bu belgedeki tüm iç içe geçmiş verileri siler.