Tablestore:Transação local

func transactionPutRow(client *tablestore.TableStoreClient, tableName string) {
    // Specify a partition key value for the local transaction. The partition key is the first primary key column. 
    transPk := new(tablestore.PrimaryKey)
    transPk.AddPrimaryKeyColumn("pk1", "pk1value")
    trans := &tablestore.StartLocalTransactionRequest{
        TableName:  tableName,
        PrimaryKey: transPk,
    }
    response, err := client.StartLocalTransaction(trans)
    if err != nil {
        fmt.Println("failed to create transaction", err)
        return
    }
    // Obtain the local transaction ID. 
    transId := response.TransactionId

    putPk := new(tablestore.PrimaryKey)
    putPk.AddPrimaryKeyColumn("pk1", "pk1value")
    putPk.AddPrimaryKeyColumn("pk2", int64(4))
    putRowChange := &tablestore.PutRowChange{
        TableName:  tableName,
        PrimaryKey: putPk,
    }
    putRowChange.AddColumn("col1", "col1data1")
    putRowChange.AddColumn("col2", int64(3))
    putRowChange.AddColumn("col3", []byte("test"))
    putRowChange.SetCondition(tablestore.RowExistenceExpectation_IGNORE)
    // Specify the local transaction ID, which can be obtained by using StartLocalTransactionResponse.TransactionId. 
    putRowChange.TransactionId = transId
    putRowRequest := &tablestore.PutRowRequest{
        PutRowChange: putRowChange,
    }
    _, err = client.PutRow(putRowRequest)
    if err != nil {
        // If a row of data fails to be written in the local transaction, discard the local transaction. In this case, all data modifications in the local transaction do not apply to the data in the data table. 
        fmt.Println("putrow failed with error:", err)
        request := &tablestore.AbortTransactionRequest{
            TransactionId: transId,
        }
        abortResponse, err := client.AbortTransaction(request)
        if err != nil {
            fmt.Println("abort transaction failed with error:", err)
        } else {
            fmt.Println("abort transaction finished. RequestId is", abortResponse.RequestId)
        }
    } else {
        // If a row of data is written in the local transaction, commit the local transaction. In this case, all data modifications in the local transaction take effect. You can discard a local transaction to invalidate all data modifications in the local transaction. 
        fmt.Println("putrow finished")
        request := &tablestore.CommitTransactionRequest{
            TransactionId: transId,
        }
        commitResponse, err := client.CommitTransaction(request)
        if err != nil {
            fmt.Println("commit transaction failed with error:", err)
        } else {
            fmt.Println("commit transaction finished. RequestId is", commitResponse.RequestId)
        }
    }
}

func transactionGetRow(client *tablestore.TableStoreClient, tableName string) {
    // Specify a partition key value for the local transaction. The partition key is the first primary key column. 
    transPk := new(tablestore.PrimaryKey)
    transPk.AddPrimaryKeyColumn("pk1", "pk1value")
    trans := &tablestore.StartLocalTransactionRequest{
        TableName:  tableName,
        PrimaryKey: transPk,
    }
    response, err := client.StartLocalTransaction(trans)
    if err != nil {
        fmt.Println("failed to create transaction", err)
        return
    }
    // Obtain the local transaction ID. 
    transId := response.TransactionId

    // Read data. 
    getRowPk := new(tablestore.PrimaryKey)
    getRowPk.AddPrimaryKeyColumn("pk1", "pk1value")
    getRowPk.AddPrimaryKeyColumn("pk2", int64(18))
    criteria := &tablestore.SingleRowQueryCriteria{
        PrimaryKey: getRowPk,
        TableName:  tableName,
        // Read the latest version of data. 
        MaxVersion: 1,
        // Specify the local transaction ID. 
        TransactionId: transId,
    }
    getRowRequest := &tablestore.GetRowRequest{
        SingleRowQueryCriteria: criteria,
    }
    getResp, err := client.GetRow(getRowRequest)
    if err != nil {
        fmt.Println("getrow failed with error:", err)
    } else {
        fmt.Println("get row col0 result is ", getResp.Columns[0].ColumnName, getResp.Columns[0].Value)
    }

    // Commit or discard the local transaction. Committing and discarding a local transaction have the same effect on a read operation. 
    // Commit the local transaction to allow all data modifications in the local transaction to take effect. 
    request := &tablestore.CommitTransactionRequest{
        TransactionId: transId,
    }
    commitResponse, err := client.CommitTransaction(request)
    if err != nil {
        fmt.Println("commit transaction failed with error:", err)
    } else {
        fmt.Println("commit transaction finished. RequestId is", commitResponse.RequestId)
    }
    // Discard the local transaction. In this case, all data modifications in the local transaction do not apply to the data in the data table. 
    //request := &tablestore.AbortTransactionRequest{
    //    TransactionId: transId,
    //}
    //abortResponse, err := client.AbortTransaction(request)
    //if err != nil {
    //    fmt.Println("abort transaction failed with error:", err)
    //} else {
    //    fmt.Println("abort transaction finished. RequestId is", abortResponse.RequestId)
    //}
}