Beim Speichern einer großen Datenmenge in der Datenbank kann eine bestimmte Menge an Schreibverarbeitung im Stapelobjekt akkumuliert werden, und die Verarbeitung kann periodisch durchgeführt werden.

Hier ist ein Python-Code-Hinweis, wie ein Array in regelmäßigen Abständen verarbeitet wird, um die oben genannten Schritte auszuführen. Wenn Sie einen besseren Weg kennen, würde ich es begrüßen, wenn Sie darauf hinweisen könnten.

Schließlich wird der Beispielcode für das Batch-Schreiben in den Firestore von GCP veröffentlicht.

Update: "Methode 4 (mit Slices)" hinzugefügt, nachdem darauf hingewiesen wurde (Dank an @shiracamus)

Methode 1 (verwenden Sie einen dedizierten Zähler)

data = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

q = []
batch_size = 3
batch_count = 0
for d in data:
    print("{}".format(d))
    q.append(d)
    batch_count += 1
    if batch_count == batch_size:
        print("commit {}".format(q))
        q = []
        batch_count = 0

print("commit {}".format(q))

> python sample1.py
a
b
c
commit ['a', 'b', 'c']
d
e
f
commit ['d', 'e', 'f']
g
h
commit ['g', 'h']

Methode 2 (unter Verwendung von Index und Rest)

data = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

q = []
batch_size = 3
for i, d in enumerate(data):
    print(d)
    q.append(d)
    if (i + 1) % batch_size == 0:
        print("commit {}".format(q))
        q = []

print("commit {}".format(q))

> python sample2.py
a
b
c
commit ['a', 'b', 'c']
d
e
f
commit ['d', 'e', 'f']
g
h
commit ['g', 'h']

Methode 3 (das letzte Commit erstellen)

Dies ist eine gute Möglichkeit, die letzte Festschreibungsanweisung zu entfernen und den Code besser anzuzeigen.

Da es erforderlich ist, die Datengröße im Voraus zu erfassen, kann sie nicht für iterierbare Daten verwendet werden, und die Schwäche besteht darin, dass die Beurteilungsverarbeitung ineffizient ist.

data = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
  
q = []
last = len(data)
batch_size = 3
for i, d in enumerate(data):
    print(d)
    q.append(d)
    if ((i + 1) % batch_size == 0) | ((i + 1) == last):
        print("commit {}".format(q))
        q = []

> python sample3.py
a
b
c
commit ['a', 'b', 'c']
d
e
f
commit ['d', 'e', 'f']
g
h
commit ['g', 'h']

Methode 3 + Alpha

Methode 3 kann etwas einfacher sein, da Sie mit Pythons Aufzählung die Startnummer mit dem zweiten Argument angeben können.

data = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
  
q = []
last = len(data)
batch_size = 3
for n, d in enumerate(data, 1):
    print(d)
    q.append(d)
    if (n % batch_size == 0) | (n == last):
        print("commit {}".format(q))
        q = []

> python sample3.py
a
b
c
commit ['a', 'b', 'c']
d
e
f
commit ['d', 'e', 'f']
g
h
commit ['g', 'h']

Methode 4 (unter Verwendung von Scheiben)

Modische Methode (Dank an @shiracamus) Wenn es nicht als Array an q des Batch-Objekts übergeben werden kann, trennen Sie es mit for in.

data = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

batch_size = 3
for i in range(0, len(data), batch_size):
    q = data[i:i+batch_size]
    print("commit", q)

> python sample3.py
commit ['a', 'b', 'c']
commit ['d', 'e', 'f']
commit ['g', 'h']

Referenz

Bei Methode 4 handelt es sich um eine Probe, bei der die Obergrenze von 500 Chargeneinsätzen zum Firestore von GCP hinzugefügt wird.

    db = firestore.Client()
    collection = db.collection("<COLLECTION NAME>")

    batch_size = 500
    batch = db.batch()
    for i in range(0, len(data), batch_size):
        for row in data[i:i + batch_size]:
            batch.set(collection.document(), row)
        print('committing...')
        batch.commit()
        batch = db.batch()