En attente de l'exécution de la requête AWS Athena dans le SDK Go

l'éditeur php Baicao attend le guide d'exécution des requêtes AWS Athena dans le SDK Go, conçu pour aider les développeurs à optimiser les performances des requêtes et à améliorer la vitesse de réponse des applications. AWS Athena est un service de requêtes sans serveur qui peut exécuter des requêtes SQL directement dans des compartiments S3 sans schéma prédéfini ni chargement de données. Cependant, en raison de la nature d'exécution asynchrone de la requête, les développeurs doivent attendre que la requête soit terminée avant d'obtenir les résultats. Ce guide expliquera comment utiliser le mécanisme d'attente du SDK Go pour attendre efficacement pendant l'exécution de la requête et obtenir les résultats une fois la requête terminée, offrant ainsi une meilleure expérience utilisateur et des performances applicatives.

Contenu de la question

J'ai un code fonctionnel qui exécute une requête athena et attend que la requête se termine en interrogeant getqueryresults 返回的 error en utilisant le code suivant :

func getqueryresults(client *athena.client, queryid *string) []types.row {

    params := &athena.getqueryresultsinput{
        queryexecutionid: queryid,
    }

    data, err := client.getqueryresults(context.todo(), params)

    for err != nil {
        println(err.error())
        time.sleep(time.second)
        data, err = client.getqueryresults(context.todo(), params)
    }

    return data.resultset.rows
}

Le problème est que je n'ai absolument aucun moyen de rompre la boucle si la requête échoue.

Par exemple, en python, je peux faire ce qui suit :

    while athena.get_query_execution(QueryExecutionId=execution_id)["QueryExecution"][
        "Status"
    ]["State"] in ["RUNNING", "QUEUED"]:
        sleep(2)

Je peux m'enregistrer for 循环内进行类似 strings.contains(err.error(),"failed") mais je cherche un moyen plus propre.

J'ai essayé de chercher l'équivalent pour go mais sans succès. Existe-t-il une fonction dans go sdk qui peut renvoyer l'état d'exécution ? Existe-t-il un meilleur moyen de vérifier davantage les erreurs dans go au lieu de err != nil ?

Solution

sdk a fourni une fonction de nouvelle tentative.

Ceci est un exemple utilisant aws-sdk-go-v2.

package main

import (
    "context"
    "fmt"
    "time"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/service/athena"
    "github.com/aws/aws-sdk-go-v2/service/athena/types"
)

func main() {
    cfg := aws.NewConfig()
    ath := athena.NewFromConfig(*cfg)

    ctx, cancelFunc := context.WithTimeout(context.Background(), time.Minute*5)
    defer cancelFunc()

    rows, err := GetQueryResults(ctx, ath, aws.String("query-id"), 10)
    if err != nil {
        panic(err) // TODO: handle error
    }

    fmt.Println(rows)
}

func GetQueryResults(ctx context.Context, client *athena.Client, QueryID *string, attempts int) ([]types.Row, error) {
    t := time.NewTicker(time.Second * 5)
    defer t.Stop()

    attemptsFunc := func(o *athena.Options) { o.RetryMaxAttempts = attempts }

WAIT:
    for {
        select {
        case <-t.C:
            out, err := client.GetQueryExecution(ctx, &athena.GetQueryExecutionInput{
                QueryExecutionId: QueryID,
            }, attemptsFunc)
            if err != nil {
                return nil, err
            }

            switch out.QueryExecution.Status.State {
            case types.QueryExecutionStateCancelled,
                types.QueryExecutionStateFailed,
                types.QueryExecutionStateSucceeded:
                break WAIT
            }

        case <-ctx.Done():
            break WAIT
        }
    }

    data, err := client.GetQueryResults(ctx, &athena.GetQueryResultsInput{
        QueryExecutionId: QueryID,
    })
    if err != nil {
        return nil, err
    }

    return data.ResultSet.Rows, nil
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!