Warten auf die Ausführung der AWS Athena-Abfrage im Go SDK

php-Editor Baicao wartet auf den AWS Athena-Abfrageausführungsleitfaden im Go SDK, der Entwicklern helfen soll, die Abfrageleistung zu optimieren und die Antwortgeschwindigkeit der Anwendung zu verbessern. AWS Athena ist ein serverloser Abfragedienst, der SQL-Abfragen direkt in S3-Buckets ohne vordefiniertes Schema oder Datenladen ausführen kann. Aufgrund der asynchronen Ausführung der Abfrage müssen Entwickler jedoch warten, bis die Abfrage abgeschlossen ist, bevor sie die Ergebnisse erhalten. In diesem Leitfaden wird erklärt, wie Sie den Wartemechanismus im Go SDK verwenden, um während der Abfrageausführung effektiv zu warten und die Ergebnisse nach Abschluss der Abfrage zu erhalten, was für eine bessere Benutzererfahrung und Anwendungsleistung sorgt.

Frageninhalt

Ich habe einen funktionierenden Code, der eine Athena-Abfrage ausführt und darauf wartet, dass die Abfrage abgeschlossen wird, indem getqueryresults 返回的 error der folgende Code abgefragt wird:

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
}

Das Problem ist, dass ich absolut keine Möglichkeit habe, die Schleife zu durchbrechen, wenn die Abfrage fehlschlägt.

Zum Beispiel kann ich in Python Folgendes tun:

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

Ich kann einchecken for 循环内进行类似 strings.contains(err.error(),"failed"), aber ich suche nach einem saubereren Weg.

Ich habe versucht, nach dem Äquivalent für go zu suchen, aber ohne Erfolg. Gibt es in go sdk eine Funktion, die den Ausführungsstatus zurückgeben kann? Gibt es eine bessere Möglichkeit, in go statt err != nil weiter auf Fehler zu prüfen?

Lösung

sdk verfügt über eine Wiederholungsfunktion.

Dies ist ein Beispiel für die Verwendung von 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
}

Das obige ist der detaillierte Inhalt vonWarten auf die Ausführung der AWS Athena-Abfrage im Go SDK. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!