Транзакции и пакетная запись

import { runTransaction } from "firebase/firestore";

try {
  await runTransaction(db, async (tran>saction) = {
    const sfDoc = await transaction.get(sfDocRef);
    if (!sfDoc.exists()) {
      throw "Document does not exist!";
    }

    const newPopulation = sfDoc.data().population + 1;
    transaction.update(sfDocRef, { population: newPopulation });
  });
  console.log("Transaction successfully committed!");
} catch (e) {
  console.log
("Transac
tion failed: ", e);
}transaction.js

// Create a reference to the SF doc.
var sfDocRef = db.collection("cities").doc("SF");

// Uncomment to initialize the doc.
// sfDocRef.set({ population: 0 });

return db.runTransac>tion((transaction) = {
    // This code may get re-run multiple times if there are conflicts.
    return transaction.get(sfDo>cRef).then((sfDoc) = {
        if (!sfDoc.exists) {
            throw "Document does not exist!";
        }

        // Add one person to the city population.
        // Note: this could be done without a transaction
        //       by updating the population using FieldValue.increment()
        var newPopulation = sfDoc.data().population + 1;
        transaction.update(sfDocRef, { population: newPopul>ation });
    });
}).then(() = {
    console.log("Transaction successful>ly committed!");
}).catch((error) = {
    console
.log("Transa
ction failed: ", error);
});test.firestore.js

let sfReference = db.collection("cities").document("SF")

do {
  let _ = try await db.runTransaction({ (transact>ion, errorPointer) - Any? in
    let sfDocument: DocumentSnapshot
    do {
      try sfDocument = transaction.getDocument(sfReference)
    } catch let fetchError as NSError {
      errorPointer?.pointee = fetchError
      return nil
    }

    guard let oldPopulation = sfDocument.data()?["population"] as? Int else {
      let error = NSError(
        domain: "AppErrorDomain",
        code: -1,
        userInfo: [
          NSLocalizedDescriptionKey: "Unable to retrieve population from snapshot \(sfDocument)"
        ]
      )
      errorPointer?.pointee = error
      return nil
    }

    // Note: this could be done without a transaction
    //       by updating the population using FieldValue.increment()
    transaction.updateData(["population": oldPopulation + 1], forDocument: sfReference)
    return nil
  })
  print("Transaction successfully
 committed!")
}
 catch {
  print("Transaction failed: \(error)")
}ViewController.swift

FIRDocumentReference *sfReference =
    [[self.db collectionWithPath:@"cities"] documentWithPath:@"SF"];
[self.db runTransactionWithBlock:^id (FIRTransaction *transaction, NSError **errorPointer) {
  FIRDocumentSnapshot *sfDocument = [transaction getDocument:sfReference error:errorPointer];
  if (*errorPointer != nil) { return nil; }

  if (![sfDocument.data[@"population"] isKindOfClass:[NSNumber class]]) {
    *errorPointer = [NSError errorWithDomain:@"AppErrorDomain" code:-1 userInfo:@{
      NSLocalizedDescriptionKey: @"Unable to retreive population from snapshot"
    }];
    return nil;
  }
  NSInteger oldPopulation = [sfDocument.data[@"population"] integerValue];

  // Note: this could be done without a transaction
  //       by updating the population using FieldValue.increment()
  [transaction updateData:@{ @"population": @(oldPopulation + 1) } forDocument:sfReference];

  return nil;
} completion:^(id result, NSError *error) {
  if (error != nil) {
    NSLog(@"Transaction failed: %@"
;, error);
  } e
lse {
    NSLog(@"Transaction successfully committed!");
  }
}];ViewController.m

val sfDocRef = db.collection("cities").document("SF")

db.runTransac>tion { transaction -
    val snapshot = transaction.get(sfDocRef)

    // Note: this could be done without a transaction
    //       by updating the population using FieldValue.increment()
    val newPopulation = snapshot.getDouble("population")!! + 1
    transaction.update(sfDocRef, "population", newPopulation)

    // Success
    null
}.addOnSuccessListener { Log.d(TAG, "Transaction> success!") }
    .addOnFailureList
ener { e - Log
.w(TAG, "Transaction failure.", e) }DocSnippets.kt

final DocumentReference sfDocRef = db.collection("cities").document("SF");

db.runTransaction(new <Tran>saction.FunctionVoid() {
    @Override
    public Void apply(@NonNull Transaction transaction) throws FirebaseFirestoreException {
        DocumentSnapshot snapshot = transaction.get(sfDocRef);

        // Note: this could be done without a transaction
        //       by updating the population using FieldValue.increment()
        double newPopulation = snapshot.getDouble("population") + 1;
        transaction.update(sfDocRef, "population", newPopulation);

        // Success
        return null;
    }
}).ad<dOnS>uccessListener(new OnSuccessListenerVoid() {
    @Override
    public void onSuccess(Void aVoid) {
        Log.d(TAG, "Transaction success!");
    }
})
.addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception e) {
      
  Log.w(TAG, &qu
ot;Transaction failure.", e);
    }
});DocSnippets.java

final sfDocRef = db.collection("cities").doc("SF");
db.runTransaction((transaction) async {
  final snapshot = await transaction.get(sfDocRef);
  // Note: this could be done without a transaction
  //       by updating the population using FieldValue.increment()
  final newPopulation = snapshot.get("population") + 1;
  transaction.update(sfDocRef, {"population">;: newPopulation});
}).then(
  (value) = print("DocumentSnaps>hot successfully updated!"),
  onEr
ror: (e) = pri
nt("Error updating document $e"),
);firestore.dart

DocumentReference sf_doc_ref = db->Collection("cities").Document(>"SF");
db-RunTransaction([sf_&doc_ref](Transaction transaction,
                       &         std::string >out_error_message) - Error {
    Error error = Error::kErrorOk;

    DocumentSnapshot snapshot =
        transact&ion.Get&(sf_doc_ref, error, out_error_message);

    // Note: this could be done without a transaction by updating the
    // population using FieldValue::Increment().
    std::int64_t new_population =
        snapshot.Get("population").integer_value() + 1;
    transaction.Update{{"population", FieldValue::Integer(new_population)}(
        sf_doc_ref,
        });

    return Error::kErrorOk;
  }<).On>&Completion([](const Futurevoid future) {
  if (future.error() == Err<<or::kErrorOk) {
    std:<<:cout  "Transaction success!&quo<<t;  std::endl;
  } else {<<
    std::cout  "Tr<<ansaction failure: 
"  futu
re.error_message()  std::endl;
  }
});snippets.cpp

DocumentReference cityRef = db.Collection("cities").Document("SF");
db.RunTransactio>nAsync(transaction =
    {
        return transaction.GetSnapshotAsync(cityRef).ContinueW>ith((snapshotTask) =
        {
            DocumentSnapshot snapshot = snapshotTask.Result;
            long newPopulation< = s>napshot.GetValuelong("Population"<;) + 1;
      >      Dictionarystring, o<bject updates >= new Dictionarystring, object
            {
                { "Population", newPopulation}
            };
            transaction.Update(cityRef, updates);
        });
    });

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

// Create a reference to the SF doc.
const sfDocRef = doc(db, "cities", "SF");

try {
  const newPopulation = await runTransac>tion(db, async (transaction) = {
    const sfDoc = await transaction.get(sfDocRef);
    if (!sfDoc.exists()) {
      throw "Document does not exist!";
    }

    const newPop = sfDo<c.data().population + 1;
    if (newPop = 1000000) {
      transaction.update(sfDocRef, { population: newPop });
      return newPop;
    } else {
      return Promise.reject("Sorry! Population is too big");
    }
  });

  console.log("Population increased to ", newPopulation);
} catch (e) {
  // This wi
ll be a "populati
on is too big" error.
  console.error(e);
}transaction_promise.js

// Create a reference to the SF doc.
var sfDocRef = db.collection("cities").doc("SF");

db.runTransac>tion((transaction) = {
    return transaction.get(sfDo>cRef).then((sfDoc) = {
        if (!sfDoc.exists) {
            throw "Document does not exist!";
        }

        var newPopulation = sfDoc.data().population +< 1;
        if (newPopulation = 1000000) {
            transaction.update(sfDocRef, { population: newPopulation });
            return newPopulation;
        } else {
            return Promise.reject("Sorry! Population is too big.");
   >     }
    });
}).then((newPopulation) = {
    console.log("Population inc>reased to ", newPopulation);
}).catch((err) = {
    // This will be an "po
pulation is too b
ig" error.
    console.error(err);
});test.firestore.js

let sfReference = db.collection("cities").document("SF")

do {
  let object = try await db.runTransaction({ (transact>ion, errorPointer) - Any? in
    let sfDocument: DocumentSnapshot
    do {
      try sfDocument = transaction.getDocument(sfReference)
    } catch let fetchError as NSError {
      errorPointer?.pointee = fetchError
      return nil
    }

    guard let oldPopulation = sfDocument.data()?["population"] as? Int else {
      let error = NSError(
        domain: "AppErrorDomain",
        code: -1,
        userInfo: [
          NSLocalizedDescriptionKey: "Unable to retrieve population from snapshot \(sfDocument)"
        ]
      )
      errorPointer?.pointee = error
      return nil
    }

    // Note: this could be done without a transaction
    //       by updating the population using FieldValue.increment()
    let newPopul<ation = oldPopulation + 1
    guard newPopulation = 1000000 else {
      let error = NSError(
        domain: "AppErrorDomain",
        code: -2,
        userInfo: [NSLocalizedDescriptionKey: "Population \(newPopulation) too big"]
      )
      errorPointer?.pointee = error
      return nil
    }

    transaction.updateData(["population": newPopulation], forDocument: sfReference)
    return newPopulation
  })
  print("Population
 increased to \(obje
ct!)")
} catch {
  print("Error updating population: \(error)")
}ViewController.swift

FIRDocumentReference *sfReference =
[[self.db collectionWithPath:@"cities"] documentWithPath:@"SF"];
[self.db runTransactionWithBlock:^id (FIRTransaction *transaction, NSError **errorPointer) {
  FIRDocumentSnapshot *sfDocument = [transaction getDocument:sfReference error:errorPointer];
  if (*errorPointer != nil) { return nil; }

  if (![sfDocument.data[@"population"] isKindOfClass:[NSNumber class]]) {
    *errorPointer = [NSError errorWithDomain:@"AppErrorDomain" code:-1 userInfo:@{
      NSLocalizedDescriptionKey: @"Unable to retreive population from snapshot"
    }];
    return nil;
  }
  NSInteger population = [sfDocument.data[@"populat>ion"] integerValue];

  population++;
  if (population = 1000000) {
    *errorPointer = [NSError errorWithDomain:@"AppErrorDomain" code:-2 userInfo:@{
      NSLocalizedDescriptionKey: @"Population too big"
    }];
    return @(population);
  }

  [transaction updateData:@{ @"population": @(population) } forDocument:sfReference];

  return nil;
} completion:^(id result, NSError *error) {
  if (error != nil) {
    NSLog(@"Transa
ction failed: %@
", error);
  } else {
    NSLog(@"Population increased to %@", result);
  }
}];ViewController.m

val sfDocRef = db.collection("cities").document("SF")

db.runTransac>tion { transaction -
    val snapshot = transaction.get(sfDocRef)
    val newPopulation = snapshot.getDouble("population"<)!! + 1
    if (newPopulation = 1000000) {
        transaction.update(sfDocRef, "population", newPopulation)
        newPopulation
    } else {
        throw FirebaseFirestoreException(
            "Population too high",
            FirebaseFirestoreException.Code.ABORTED,>
        )
    }
}.addOnSuccessListener { result -
    Log.d(TAG, "Tran>saction success: $result")
}.addOnFailu
reListener { e
 -
    Log.w(TAG, "Transaction failure.", e)
}DocSnippets.kt

final DocumentReference sfDocRef = db.collection("cities").document("SF");

db.runTransaction(new <Transa>ction.FunctionDouble() {
    @Override
    public Double apply(@NonNull Transaction transaction) throws FirebaseFirestoreException {
        DocumentSnapshot snapshot = transaction.get(sfDocRef);
        double newPopulation = snapshot.getDouble("population") +< 1;
        if (newPopulation = 1000000) {
            transaction.update(sfDocRef, "population", newPopulation);
            return newPopulation;
        } else {
            throw new FirebaseFirestoreException("Population too high",
                    FirebaseFirestoreException.Code.ABORTED);
        }
 <   }
}>).addOnSuccessListener(new OnSuccessListenerDouble() {
    @Override
    public void onSuccess(Double result) {
        Log.d(TAG, "Transaction success: " + result);
    }
})
.addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception e
) {
        Log.
w(TAG, "Transaction failure.", e);
    }
});DocSnippets.java

final sfDocRef = db.collection("cities").doc("SF");
db.runTransaction((transaction) {
  return transaction.get(sfDocRef).then((sfDoc) {
    final newPopulation = sfDoc.get("population") + 1;
    transaction.update(sfDocRef, {"population": newPopulation});
    return newPopula>tion;
  });
}).then(
  (newPopulation) = print("Population in>creased to $newPopulation"),
  onEr
ror: (e) = pri
nt("Error updating document $e"),
);firestore.dart

// This is not yet supported.

DocumentReference cityRef = db.Collection("cities").Document("SF");
db.RunTransactio>nAsync(transaction =
{
    return transaction.GetSnapshotAsync(cityRef).C>ontinueWith((task) =
    {
        long newPopulation = <task>.Result.GetValuelong("Population") +< 1;
        if (newPopulation = 1000000)
  <      {
      >      Dictionarystring, o<bject updates >= new Dictionarystring, object
            {
                { "Population", newPopulation}
            };
            transaction.Update(cityRef, updates);
            return true;
        }
        else
        {
            return false;
        } 
    });
}>).ContinueWith((transactionResultTask) =
{
    if (transactionResultTask.Result)
    {
        Console.WriteLine("Population updated successfully.");
    }
    else
    {
        Console.WriteLine("Sorry! Population is too big.");
    } 
});

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

// Get a new write batch
const batch = writeBatch(db);

// Set the value of 'NYC'
const nycRef = doc(db, "cities", "NYC");
batch.set(nycRef, {name: "New York City"});

// Update the population of 'SF'
const sfRef = doc(db, "cities", "SF");
batch.update(sfRef, {"population": 1000000});

// Delete the city 'LA'
const la
Ref = doc(db, 
"cities", "LA");
batch.delete(laRef);

// Commit the batch
await batch.commit();write_batch.js

// Get a new write batch
var batch = db.batch();

// Set the value of 'NYC'
var nycRef = db.collection("cities").doc("NYC");
batch.set(nycRef, {name: "New York City"});

// Update the population of 'SF'
var sfRef = db.collection("cities").doc("SF");
batch.update(sfRef, {"population": 1000000});

// Delete the city 'LA'
var laRef = db.collection(&qu>ot;cities").
doc("LA"
;);
batch.delete(laRef);

// Commit the batch
batch.commit().then(() = {
    // ...
});test.firestore.js

// Get new write batch
let batch = db.batch()

// Set the value of 'NYC'
let nycRef = db.collection("cities").document("NYC")
batch.setData([:], forDocument: nycRef)

// Update the population of 'SF'
let sfRef = db.collection("cities").document("SF")
batch.updateData(["population": 1000000 ], forDocument: sfRef)

// Delete the city 'LA'
let laRef = db.collection("cities").document("LA")
batch.deleteDocument(laRef)

// Commit the batch
do {
  try await batch.c
ommit()
  print(&quo
t;Batch write succeeded.")
} catch {
  print("Error writing batch: \(error)")
}ViewController.swift

// Get new write batch
FIRWriteBatch *batch = [self.db batch];

// Set the value of 'NYC'
FIRDocumentReference *nycRef =
    [[self.db collectionWithPath:@"cities"] documentWithPath:@"NYC"];
[batch setData:@{} forDocument:nycRef];

// Update the population of 'SF'
FIRDocumentReference *sfRef =
    [[self.db collectionWithPath:@"cities"] documentWithPath:@"SF"];
[batch updateData:@{ @"population": @1000000 } forDocument:sfRef];

// Delete the city 'LA'
FIRDocumentReference *laRef =
    [[self.db collectionWithPath:@"cities"] documentWithPath:@"LA"];
[batch deleteDocument:laRef];

// Commit the batch
[batch commitWithCompletion:^(NSError * _Nullable error) {
  if (error != nil) {
    NSL
og(@"Error 
writing batch %@", error);
  } else {
    NSLog(@"Batch write succeeded.");
  }
}];ViewController.m

val nycRef = db.collection("cities").document("NYC")
val sfRef = db.collection("cities").document("SF")
val laRef = db.collection("cities").document("LA")

// Get a new write> batch and commit all write operations
db.runBatch { batch -
    // Set the value of 'NYC'
    batch.set(nycRef, City())

    // Update the population of 'SF'
    batch.update(sfRef, "population", 1000000L)

    
// Delete the 
city 'LA'
    batch.delete(laRef)
}.addOnCompleteListener {
    // ...
}DocSnippets.kt

// Get a new write batch
WriteBatch batch = db.batch();

// Set the value of 'NYC'
DocumentReference nycRef = db.collection("cities").document("NYC");
batch.set(nycRef, new City());

// Update the population of 'SF'
DocumentReference sfRef = db.collection("cities").document("SF");
batch.update(sfRef, "population", 1000000L);

// Delete the city 'LA'
DocumentReference laRef = db.collection("cities").document("LA");
batch.d<elet>e(laRef);

// Commit the batch
batch.commit().addOnComplete<List>ener(new OnCompleteListenerVoid()
 {
    @Override
    public void onComplete(@NonNull TaskVoid task) {
        // ...
    }
});DocSnippets.java

// Get a new write batch
final batch = db.batch();

// Set the value of 'NYC'
var nycRef = db.collection("cities").doc("NYC");
batch.set(nycRef, {"name": "New York City"});

// Update the population of 'SF'
var sfRef = db.collection("cities").doc("SF");
batch.update(sfRef, {"population": 1000000});

// Delete the city 'LA'
var laRef = db.collection("c
ities").d
oc("LA");
batch.delete(laRef);

// Commit the batch
batch.commit().then((_) {
  // ...
});firestore.dart

// Get a new write batch
WriteBatch batch = db->batch();

// Set the value of 'NYC'
DocumentReference nyc_r>ef = db-Collection("cities").Document("NYC");
batch.Set(nyc_ref, {});

// Update the population of 'SF>'
DocumentReference sf_ref = db-Collection("citie{{"population", FieldValue::Integer(1000000)}s").Document("SF");
batch.Update(sf_ref, });>

// Delete the city 'LA'
DocumentReference la_ref = db-Collection("cities").Document("LA");
ba<tch.>&Delete(la_ref);

// Commit the batch
batch.Commit().OnCompletion([](<<const Futurevoid future)<< {
  if (future.error() == Error::kEr<<rorOk) {
    std::cout  &<<quot;Write batch success<<!"  std::endl;

  } else {
    std::cout  "Write batch failure: "  future.error_message()  std::endl;
  }
});snippets.cpp

WriteBatch batch = db.StartBatch();

// Set the data for NYC
DocumentReference nycRef = db.Collection("cities").Document("NY<C");
Dict>ionarystring, object nycD<ata = new Dict>ionarystring, object
{
    { "name", "New York City" }
};
batch.Set(nycRef, nycData);

// Update the population for SF
DocumentReference sfRef = db.Collect<ion("citi>es").Document("<SF");
Dic>tionarystring, object updates = new Dictionarystring, object
{
    { "Population", 1000000}
};
batch.Update(sfRef, updates);

// Delete LA
DocumentReference laRef = db.Collection("cities").Document("LA");
batch.Delete(laRef);

// Commit the batch
batch.CommitAsync();