Tablestore:Use local transactions

Prérequis

• Installez le SDK Tablestore pour Python et initialisez un client.

• Les transactions locales sont activées pour la table.

  Remarque

  Pour activer les transactions locales sur une table existante ou vérifier si la fonctionnalité est activée, soumettez un ticket .

Description de la fonctionnalité

Une transaction locale est limitée à une seule valeur de clé de partition et utilise le niveau d'isolation Read Committed. Les requêtes exécutées dans la transaction partagent un ID de transaction. Pour utiliser une transaction locale, procédez comme suit :

1. Appelez start_local_transaction avec la valeur de la clé de partition pour obtenir un ID de transaction.

2. Appelez get_row, put_row, update_row, delete_row, batch_write_row ou get_range dans le cadre de la transaction, en transmettant l'ID via le paramètre transaction_id.

3. Appelez commit_transaction pour valider toutes les écritures, ou abort_transaction pour les annuler.

def start_local_transaction(self, table_name, key)
def commit_transaction(self, transaction_id)
def abort_transaction(self, transaction_id)

L'exemple suivant démarre une transaction locale pour la valeur de clé de partition device, écrit une ligne, puis valide la transaction.

table_name = "example_table"
partition_key = [("partition", "device")]
transaction_id = client.start_local_transaction(table_name, partition_key)

primary_key = [("partition", "device"), ("id", 1)]
row = Row(primary_key, [("status", "online")])
condition = Condition(RowExistenceExpectation.IGNORE)
client.put_row(
    table_name,
    row,
    condition,
    transaction_id=transaction_id,
)

client.commit_transaction(transaction_id)

Paramètres

Une transaction locale contient les paramètres clés suivants.

Limites

• Les transactions locales ne sont pas compatibles avec les colonnes de clé primaire à incrémentation automatique.

• Les transactions locales utilisent le verrouillage pessimiste. Pendant une transaction, un verrou en écriture est maintenu sur les données associées à la valeur de la clé de partition ; seules les écritures portant l'ID de transaction peuvent aboutir.

• La durée de vie maximale d'une transaction est de 60 secondes. Si deux opérations consécutives sont séparées par plus de 60 secondes, la transaction expire et le serveur l'annule.

• Un ID de transaction ne peut être utilisé que par une seule requête à la fois. Les requêtes concurrentes partageant le même ID échouent toutes.

• Chaque écriture dans une transaction doit utiliser la valeur de clé de partition qui a servi à démarrer la transaction. Cette restriction ne s'applique pas aux lectures.

• Une seule transaction peut écrire jusqu'à 4 Mo de données.

• Si l'écriture d'une colonne d'attribut ne spécifie pas de version de données, le serveur génère la version au moment de l'écriture, et non lors de la validation.

• Lorsqu'un objet BatchWriteRowRequest porte un ID de transaction, toutes les lignes doivent cibler la table sur laquelle la transaction a été démarrée.

• Si une transaction ne contient aucune écriture, la validation et l'annulation ont le même effet et libèrent toutes deux la transaction.

• Une lecture ou une écriture échouée portant un ID de transaction ne met pas fin à la transaction. Réessayez la requête ou annulez explicitement la transaction.

Exemples

table_name = "example_table"
partition_key = [("partition", "device")]
transaction_id = client.start_local_transaction(table_name, partition_key)

primary_key = [("partition", "device"), ("id", 1)]
consumed, return_row, next_token = client.get_row(
    table_name,
    primary_key,
    transaction_id=transaction_id,
)
print(return_row.primary_key, return_row.attribute_columns)

client.commit_transaction(transaction_id)

table_name = "example_table"
partition_key = [("partition", "device")]
transaction_id = client.start_local_transaction(table_name, partition_key)

condition = Condition(RowExistenceExpectation.IGNORE)
row_items = [
    PutRowItem(Row([("partition", "device"), ("id", 2)], [("status", "online")]), condition),
    PutRowItem(Row([("partition", "device"), ("id", 3)], [("status", "offline")]), condition),
]
request = BatchWriteRowRequest()
request.add(TableInBatchWriteRowItem(table_name, row_items))
request.set_transaction_id(transaction_id)

response = client.batch_write_row(request)
if response.is_all_succeed():
    client.commit_transaction(transaction_id)
else:
    client.abort_transaction(transaction_id)