Lors du stockage d'une grande quantité de données dans le DB, une certaine quantité de traitement d'écriture peut être accumulée dans l'objet batch et le traitement peut être effectué périodiquement.

Voici une note de code Python sur la façon de traiter un tableau à intervalles réguliers pour faire ce qui précède. Si vous connaissez un meilleur moyen, je vous serais reconnaissant si vous pouviez le signaler.

Enfin, l'exemple de code pour l'écriture par lots dans le Firestore de GCP est publié.

Mise à jour: Ajout de la "Méthode 4 (en utilisant des tranches)" après l'avoir signalé (Merci à @shiracamus)

Méthode 1 (utiliser un compteur dédié)

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']

Méthode 2 (en utilisant l'index et le reste)

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']

Méthode 3 (concevoir le dernier commit)

C'est un bon moyen de se débarrasser de la dernière instruction de validation et d'avoir une meilleure vue du code.

Puisqu'il est nécessaire d'acquérir la taille des données à l'avance, elle ne peut pas être utilisée pour des données itérables, et la faiblesse est que le traitement du jugement est inefficace.

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']

Méthode 3 + alpha

La méthode 3 peut être un peu plus simple car l'énumération de Python vous permet de spécifier le numéro de départ avec le deuxième argument.

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']

Méthode 4 (en utilisant des tranches)

Méthode à la mode (Merci à @shiracamus) S'il ne peut pas être passé en tant que tableau à q de l'objet batch, séparez-le par 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']

référence

Dans la méthode 4, il s'agit d'un échantillon pour ajouter la limite supérieure de 500 inserts de lots au firestore de GCP.

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