Jak zaktualizować „tablicę obiektów” za pomocą Firestore?

Obecnie próbuję Firestore i utknąłem na czymś bardzo prostym: „aktualizowanie tablicy (czyli dokumentu podrzędnego)”.

Moja struktura bazy danych jest super prosta. Na przykład:

proprietary: "John Doe",
sharedWith:
  [
    {who: "first@test.com", when:timestamp},
    {who: "another@test.com", when:timestamp},
  ],

Próbuję (bez powodzenia) wypchnąć nowe rekordy do shareWithtablicy obiektów.

Próbowałem:

// With SET
firebase.firestore()
.collection('proprietary')
.doc(docID)
.set(
  { sharedWith: [{ who: "third@test.com", when: new Date() }] },
  { merge: true }
)

// With UPDATE
firebase.firestore()
.collection('proprietary')
.doc(docID)
.update({ sharedWith: [{ who: "third@test.com", when: new Date() }] })

Żadne nie działa. Te zapytania zastępują moją tablicę.

Odpowiedź może być prosta, ale nie mogłem jej znaleźć ...

Edycja 13.08.2018 : W Cloud Firestore dostępna jest teraz obsługa natywnych operacji na macierzach. Zobacz odpowiedź Douga poniżej.

Obecnie nie ma możliwości zaktualizowania pojedynczego elementu tablicy (lub dodania / usunięcia pojedynczego elementu) w Cloud Firestore.

Ten kod tutaj:

firebase.firestore()
.collection('proprietary')
.doc(docID)
.set(
  { sharedWith: [{ who: "third@test.com", when: new Date() }] },
  { merge: true }
)

To mówi, aby ustawić dokument w proprietary/docIDtaki sposób, sharedWith = [{ who: "third@test.com", when: new Date() }aby nie wpływał na żadne istniejące właściwości dokumentu. Jest to bardzo podobne do update()wywołania, które podałeś, jednak set()wywołanie z tworzeniem dokumentu, jeśli nie istnieje, a update()wywołanie zakończy się niepowodzeniem.

Masz więc dwie możliwości osiągnięcia tego, co chcesz.

Opcja 1 - Ustaw całą tablicę

Wywołaj set()całą zawartość tablicy, co będzie wymagało najpierw odczytania bieżących danych z bazy danych. Jeśli obawiasz się jednoczesnych aktualizacji, możesz to wszystko zrobić w transakcji.

Opcja 2 - użyj kolekcji podrzędnej

Możesz utworzyć sharedWithpodkolekcję głównego dokumentu. Wtedy dodanie pojedynczego elementu wyglądałoby tak:

firebase.firestore()
  .collection('proprietary')
  .doc(docID)
  .collection('sharedWith')
  .add({ who: "third@test.com", when: new Date() })

Oczywiście wiąże się to z nowymi ograniczeniami. Nie byłbyś w stanie przeszukiwać dokumentów na podstawie tego, komu są one udostępnione, ani nie byłbyś w stanie uzyskać dokumentu i wszystkich sharedWithdanych w jednej operacji.

Firestore ma teraz dwie funkcje, które pozwalają aktualizować tablicę bez ponownego pisania całej rzeczy.

Link: https://firebase.google.com/docs/firestore/manage-data/add-data , w szczególności https://firebase.google.com/docs/firestore/manage-data/add-data#update_elements_in_an_array

Zaktualizuj elementy w tablicy

Jeśli dokument zawiera pole tablicy, możesz użyć funkcji arrayUnion () i arrayRemove (), aby dodawać i usuwać elementy. arrayUnion () dodaje elementy do tablicy, ale tylko elementy, które nie są jeszcze obecne. arrayRemove () usuwa wszystkie wystąpienia każdego podanego elementu.

Możesz użyć transakcji ( https://firebase.google.com/docs/firestore/manage-data/transactions ), aby pobrać tablicę, wypchnąć ją, a następnie zaktualizować dokument:

    const booking = { some: "data" };
    const userRef = this.db.collection("users").doc(userId);

    this.db.runTransaction(transaction => {
        // This code may get re-run multiple times if there are conflicts.
        return transaction.get(userRef).then(doc => {
            if (!doc.data().bookings) {
                transaction.set({
                    bookings: [booking]
                });
            } else {
                const bookings = doc.data().bookings;
                bookings.push(booking);
                transaction.update(userRef, { bookings: bookings });
            }
        });
    }).then(function () {
        console.log("Transaction successfully committed!");
    }).catch(function (error) {
        console.log("Transaction failed: ", error);
    });

Oto najnowszy przykład z dokumentacji Firestore:

firebase.firestore.FieldValue. ArrayUnion

var washingtonRef = db.collection("cities").doc("DC");

// Atomically add a new region to the "regions" array field.
washingtonRef.update({
    regions: firebase.firestore.FieldValue.arrayUnion("greater_virginia")
});

// Atomically remove a region from the "regions" array field.
washingtonRef.update({
    regions: firebase.firestore.FieldValue.arrayRemove("east_coast")
});

Przepraszamy za spóźnienie na imprezę, ale Firestore rozwiązało to już w sierpniu 2018 roku, więc jeśli nadal tego szukasz, wszystkie problemy dotyczące tablic zostały rozwiązane.

https://firebase.googleblog.com/2018/08/better-arrays-in-cloud-firestore.html Oficjalny post na blogu

array-zawiera, arrayRemove, arrayUnion do sprawdzania, usuwania i aktualizowania tablic. Mam nadzieję, że to pomoże.

Aby oprzeć się na odpowiedzi Sama Sterna , istnieje również trzecia opcja co czyniło rzeczy łatwiejsze dla mnie i że jest za pomocą tego, co nazywamy mapą Google, która jest w zasadzie słownika.

Myślę, że słownik jest znacznie lepszy dla opisywanego przypadku użycia. Zwykle używam tablic do rzeczy, które nie są zbytnio aktualizowane, więc są mniej więcej statyczne. Ale w przypadku rzeczy, które są często pisane, w szczególności wartości, które wymagają aktualizacji dla pól, które są powiązane z czymś innym w bazie danych, słowniki okazują się znacznie łatwiejsze w utrzymaniu i pracy z nimi.

Więc w twoim konkretnym przypadku struktura DB wyglądałaby następująco:

proprietary: "John Doe"
sharedWith:{
  whoEmail1: {when: timestamp},
  whoEmail2: {when: timestamp}
}

Umożliwi to wykonanie następujących czynności:

var whoEmail = 'first@test.com';

var sharedObject = {};
sharedObject['sharedWith.' + whoEmail + '.when'] = new Date();
sharedObject['merge'] = true;

firebase.firestore()
.collection('proprietary')
.doc(docID)
.update(sharedObject);

Powodem definiowania obiektu jako zmiennej jest użycie 'sharedWith.' + whoEmail + '.when' bezpośrednio w metodzie set spowoduje błąd, przynajmniej podczas używania go w funkcji chmury Node.js.

Poza odpowiedziami wymienionymi powyżej. To wystarczy. Korzystanie z Angular 5 i AngularFire2. lub użyj firebase.firestore () zamiast this.afs

  // say you have have the following object and 
  // database structure as you mentioned in your post
  data = { who: "third@test.com", when: new Date() };

  ...othercode


  addSharedWith(data) {

    const postDocRef = this.afs.collection('posts').doc('docID');

    postDocRef.subscribe( post => {

      // Grab the existing sharedWith Array
      // If post.sharedWith doesn`t exsit initiated with empty array
      const foo = { 'sharedWith' : post.sharedWith || []};

      // Grab the existing sharedWith Array
      foo['sharedWith'].push(data);

      // pass updated to fireStore
      postsDocRef.update(foo);
      // using .set() will overwrite everything
      // .update will only update existing values, 
      // so we initiated sharedWith with empty array
    });
 }  

Potraktuj Johna Doe jako dokument, a nie kolekcję

Daj mu kolekcję rzeczy i rzeczy udostępnianych przez innych

Następnie możesz mapować i wyszukiwać współdzielone elementy Johna Doe w tej równoległej kolekcji thingsSharedWithOthers.

proprietary: "John Doe"(a document)

things(collection of John's things documents)

thingsSharedWithOthers(collection of John's things being shared with others):
[thingId]:
    {who: "first@test.com", when:timestamp}
    {who: "another@test.com", when:timestamp}

then set thingsSharedWithOthers

firebase.firestore()
.collection('thingsSharedWithOthers')
.set(
{ [thingId]:{ who: "third@test.com", when: new Date() } },
{ merge: true }
)

Jeśli ktoś szuka rozwiązania Java Firestore SDK, aby dodać elementy w polu tablicy:

List<String> list = java.util.Arrays.asList("A", "B");
Object[] fieldsToUpdate = list.toArray();
DocumentReference docRef = getCollection().document("docId");
docRef.update(fieldName, FieldValue.arrayUnion(fieldsToUpdate));

Aby usunąć elementy z użytkownika tablicy: FieldValue.arrayRemove()

addToCart(docId: string, prodId: string): Promise<void> {
    return this.baseAngularFirestore.collection('carts').doc(docId).update({
        products:
        firestore.FieldValue.arrayUnion({
            productId: prodId,
            qty: 1
        }),
    });
}