Cloud Firestore'dan verileri silin

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

Belgeleri sil

Bir belgeyi silmek için aşağıdaki dile özgü delete() yöntemlerini kullanın:

Web modular API

deleteDoc() yöntemini kullanın:

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

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

Web namespaced API

delete() yöntemini kullanın:

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

delete() yöntemini kullanın:

Not: Bu ürün watchOS ve App Clip hedeflerinde mevcut değildir.
do {
  try await db.collection("cities").document("DC").delete()
  print("Document successfully removed!")
} catch {
  print("Error removing document: \(error)")
}
Amaç-C

deleteDocumentWithCompletion: yöntemini kullanın:

Not: Bu ürün watchOS ve App Clip hedeflerinde mevcut değildir.
[[[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() yöntemini kullanın:

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

Java

delete() yöntemini kullanın:

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() yöntemini kullanın:

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

delete() yöntemini kullanın:

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

delete() yöntemini kullanın:

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

Python

delete() yöntemini kullanın:

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

Delete() yöntemini kullanın:

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() yöntemini kullanın:

const res = await db.collection('cities').doc('DC').delete();
Gitmek

Delete() yöntemini kullanın:


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() yöntemini kullanın:

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

DeleteAsync() yöntemini kullanın:

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

DeleteAsync() yöntemini kullanın:

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

delete() yöntemini kullanın:

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

Bir belgeyi sildiğinizde Cloud Firestore, alt koleksiyonlarındaki belgeleri otomatik olarak silmez. Alt koleksiyon belgelerine referans olarak erişmeye devam edebilirsiniz. Örneğin, /mycoll/mydoc/mysubcoll/mysubdoc adresindeki ana belgeyi silseniz bile belgeye /mycoll/mydoc yolundan erişebilirsiniz.

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

Bir belgeyi ve alt koleksiyonlarındaki tüm belgeleri silmek istiyorsanız bunu manuel olarak yapmanız gerekir. Daha fazla bilgi için bkz . Koleksiyonları Silme.

Alanları sil

Bir belgeden belirli alanları silmek için, bir belgeyi güncellerken aşağıdaki dile özgü FieldValue.delete() yöntemlerini kullanın:

Web modular API

deleteField() yöntemini kullanın:

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() 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()
});
Süratli

FieldValue.delete() yöntemini kullanın:

Not: Bu ürün watchOS ve App Clip hedeflerinde mevcut değildir.
do {

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

fieldValueForDelete: yöntemini kullanın:

Not: Bu ürün watchOS ve App Clip hedeflerinde mevcut değildir.
[[[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() yöntemini kullanın:

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() yöntemini kullanın:

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() yöntemini kullanın:

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() yöntemini kullanın:

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());
Python

firestore.DELETE_FIELD yöntemini kullanın:

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

Python

firestore.DELETE_FIELD yöntemini kullanın:

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

FieldValue::Delete() yöntemini kullanın:

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

FieldValue.delete() yöntemini kullanın:

// 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()
});
Gitmek

firestore.Delete yöntemini kullanın:


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() yöntemini kullanın:

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

FieldValue.Delete yöntemini kullanın:

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

FieldValue.Delete yöntemini kullanın:

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

firestore.field_delete yöntemini kullanın:

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

Koleksiyonları sil

Cloud Firestore'da bir koleksiyonun veya alt koleksiyonun tamamını silmek için koleksiyon veya alt koleksiyon içindeki tüm belgeleri alın (okuyun) ve silin. Bu işlem hem okuma hem de silme maliyetlerine neden olur. Daha büyük koleksiyonlarınız varsa, yetersiz bellek hatalarını önlemek için belgeleri daha küçük gruplar halinde silmek isteyebilirsiniz. Koleksiyonun veya alt koleksiyonun tamamını silene kadar işlemi tekrarlayın.

Bir koleksiyonun silinmesi, sınırsız sayıda bireysel silme isteğinin koordine edilmesini gerektirir. Koleksiyonların tamamını silmeniz gerekiyorsa bunu yalnızca güvenilir bir sunucu ortamından yapın. Bir koleksiyonun mobil/web istemcisinden silinmesi mümkün olsa da bunun yapılmasının güvenlik ve performans üzerinde olumsuz etkileri vardır.

Aşağıdaki parçalar biraz basitleştirilmiştir ve hata yönetimi, güvenlik, alt koleksiyonların silinmesi veya performansın en üst düzeye çıkarılmasıyla ilgilenmez. Üretimdeki koleksiyonları silmeye yönelik önerilen bir yaklaşım hakkında daha fazla bilgi edinmek için bkz . Koleksiyonları ve Alt Koleksiyonları Silme .

// Deleting collections from a Web client is not recommended.
Süratli
Not: Bu ürün watchOS ve App Clip hedeflerinde mevcut değildir.
// Deleting collections from an Apple client is not recommended.
Amaç-C
Not: Bu ürün watchOS ve App Clip hedeflerinde mevcut değildir.
// 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

Koleksiyonların istemciden silinmesi önerilmez.

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());
  }
}
Python
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);
  });
}
Gitmek

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

Konsolla verileri silin

Belgeleri ve koleksiyonları konsoldaki Cloud Firestore sayfasından silebilirsiniz . Bir belgenin konsoldan silinmesi, alt koleksiyonlar da dahil olmak üzere o belgedeki tüm iç içe geçmiş verilerin silinmesine neden olur.

TTL politikalarına sahip verileri silin

Bir TTL ilkesi, belirli bir koleksiyon grubundaki belgelerin sona erme süresi olarak belirli bir alanı belirler. TTL silme işlemleri, belge silme maliyetlerinize dahil edilir.

TTL'yi ayarlama hakkında bilgi için bkz. TTL politikalarıyla veri saklamayı yönetme .

Hata kodları ve verileri silerken gecikme sorunlarının nasıl çözüleceği hakkında daha fazla bilgi için sorun giderme sayfasına bakın.

Dataflow ile verileri silin

Dataflow, Firestore veritabanınızdaki toplu işlemler için harika bir araçtır. Dataflow tanıtım blog gönderisine yönelik Firestore bağlayıcısında, bir koleksiyon grubundaki tüm belgelerin silinmesine ilişkin bir örnek bulunur.