Tablestore:Utiliser les transactions locales

Prérequis

• Installez le SDK Tablestore pour Go et initialisez le client. Les transactions locales nécessitent la version 1.7.8 ou ultérieure. Nous vous recommandons d'utiliser la dernière version.

• Les transactions locales doivent être activées pour la table. Vous pouvez définir EnableLocalTxn lors de la création d'une table. Pour vérifier si les transactions locales sont activées pour une table existante ou pour les activer, soumettez un ticket .

Description

Une transaction locale est limitée à une seule valeur de clé de partition. Les lectures et les écritures de la transaction partagent un ID de transaction. Le flux de travail comporte trois étapes :

1. Appelez StartLocalTransaction avec une valeur de clé de partition pour créer une transaction locale et obtenir son ID de transaction.

2. Appelez GetRow, PutRow, UpdateRow, DeleteRow, BatchWriteRow ou GetRange dans la transaction et incluez l'ID de transaction dans chaque requête.

3. Appelez CommitTransaction pour appliquer toutes les modifications ou AbortTransaction pour annuler la transaction et toutes les modifications.

func (client *TableStoreClient) StartLocalTransaction(request *StartLocalTransactionRequest) (*StartLocalTransactionResponse, error)
func (client *TableStoreClient) CommitTransaction(request *CommitTransactionRequest) (*CommitTransactionResponse, error)
func (client *TableStoreClient) AbortTransaction(request *AbortTransactionRequest) (*AbortTransactionResponse, error)

L'exemple suivant crée une transaction locale pour la valeur de clé de partition user-a, écrit une ligne dans la transaction et valide celle-ci.

partitionKey := &tablestore.PrimaryKey{}
partitionKey.AddPrimaryKeyColumn("user_id", "user-a")

startResponse, err := client.StartLocalTransaction(
    &tablestore.StartLocalTransactionRequest{
        TableName:  "example_table",
        PrimaryKey: partitionKey,
    },
)
if err != nil {
    log.Fatal(err)
}
transactionID := startResponse.TransactionId

rowKey := &tablestore.PrimaryKey{}
rowKey.AddPrimaryKeyColumn("user_id", "user-a")
rowKey.AddPrimaryKeyColumn("record_id", int64(1))

change := &tablestore.PutRowChange{
    TableName:     "example_table",
    PrimaryKey:    rowKey,
    TransactionId: transactionID,
}
change.AddColumn("status", "created")
change.SetCondition(tablestore.RowExistenceExpectation_IGNORE)

_, err = client.PutRow(&tablestore.PutRowRequest{PutRowChange: change})
if err != nil {
    _, _ = client.AbortTransaction(
        &tablestore.AbortTransactionRequest{TransactionId: transactionID},
    )
    log.Fatal(err)
}

_, err = client.CommitTransaction(
    &tablestore.CommitTransactionRequest{TransactionId: transactionID},
)
if err != nil {
    log.Fatal(err)
}

Paramètres

Réponse

StartLocalTransactionResponse contient les informations métier suivantes.

Limites

• Les colonnes de clé primaire à incrémentation automatique et les transactions locales ne peuvent pas être utilisées conjointement.

• Les transactions locales utilisent des verrous pessimistes pour le contrôle de la concurrence. Pendant une transaction, les écritures pour la valeur de clé de partition sont verrouillées. Seules les requêtes d'écriture portant l'ID de transaction peuvent aboutir. Le serveur libère le verrou d'écriture lorsque la transaction est validée, annulée ou expire.

• Une transaction peut rester active pendant 60 secondes maximum. Si l'intervalle entre deux opérations dépasse 60 secondes, le serveur annule automatiquement la transaction.

• Si une demande de création d'une transaction locale expire, il est possible que la transaction ait déjà été créée sur le serveur. Attendez l'expiration de la transaction avant d'en créer une autre.

• Une transaction locale non validée peut devenir invalide. Dans ce cas, réessayez les opérations de la transaction.

• Un seul ID de transaction peut être utilisé par une requête à la fois. Les requêtes concurrentes utilisant le même ID de transaction échouent.

• Les requêtes d'écriture dans la transaction doivent utiliser la valeur de clé de partition employée pour créer la transaction. Les requêtes de lecture ne sont pas soumises à cette restriction.

• Lorsque vous utilisez BatchWriteRow pour écrire des lignes dans une transaction, toutes les lignes de la requête doivent appartenir à la table pour laquelle la transaction a été créée.

• Une transaction peut écrire jusqu'à 4 Mo de données. La quantité de données est accumulée selon les règles de calcul des requêtes d'écriture standard.

• Si aucune version n'est spécifiée pour une colonne d'attribut, le serveur génère la version selon les règles des écritures standard au moment de l'écriture des données, et non lors de la validation de la transaction.

• Une lecture ou une écriture ayant échoué n'invalide pas la transaction. Vous pouvez réessayer la requête ou annuler la transaction.

Exemples

criteria := &tablestore.SingleRowQueryCriteria{
    TableName:     "example_table",
    PrimaryKey:    rowKey,
    MaxVersion:    1,
    TransactionId: transactionID,
}
response, err := client.GetRow(
    &tablestore.GetRowRequest{SingleRowQueryCriteria: criteria},
)
if err != nil {
    log.Fatal(err)
}
fmt.Println(response.Columns)

_, err = client.CommitTransaction(
    &tablestore.CommitTransactionRequest{TransactionId: transactionID},
)
if err != nil {
    log.Fatal(err)
}