Utilisation des E/S Informations de chronométrage

Obtenir les statistiques des instructions PartiQL

Important

Avis de fin de support : les clients existants pourront utiliser Amazon QLDB jusqu'à la fin du support le 31 juillet 2025. Pour plus de détails, consultez Migrer un Amazon QLDB Ledger vers Amazon Aurora SQL Postgre.

Amazon QLDB fournit des statistiques d'exécution des instructions qui peuvent vous aider à optimiser votre utilisation de QLDB en exécutant des instructions partiQL plus efficaces. QLDBrenvoie ces statistiques ainsi que les résultats de l'instruction. Ils incluent des métriques qui quantifient l'utilisation des E/S consommées et le temps de traitement côté serveur, que vous pouvez utiliser pour identifier les instructions inefficaces.

Cette fonctionnalité est actuellement disponible dans l'éditeur partiQL de la QLDBconsole, dans le QLDBshell et dans la dernière version du QLDBpilote pour toutes les langues prises en charge. Vous pouvez également consulter les statistiques des relevés relatives à l'historique de vos requêtes sur la console.

Utilisation des E/S

La métrique d'utilisation des E/S décrit le nombre de demandes d'E/S de lecture. Si le nombre de demandes d'E/S de lecture est plus élevé que prévu, cela indique que l'instruction n'est pas optimisée, par exemple en l'absence d'index. Nous vous recommandons de passer Modèles de requêtes optimaux en revue dans la rubrique précédente, Optimisation des performances des requêtes.

Note

Lorsque vous exécutez une CREATE INDEX instruction sur une table non vide, la métrique d'utilisation des E/S inclut uniquement les demandes de lecture pour l'appel de création d'index synchrone.

QLDBcrée l'index de tous les documents existants dans le tableau de manière asynchrone. Ces demandes de lecture asynchrones ne sont pas incluses dans la métrique d'utilisation des E/S figurant dans les résultats de votre relevé. Les demandes de lecture asynchrones sont facturées séparément et sont ajoutées à votre total d'E/S de lecture une fois la création de l'index terminée.

Utilisation de la console QLDB

Pour connaître l'utilisation des E/S de lecture d'une instruction à l'aide de la QLDB console, procédez comme suit :

Ouvrez la QLDB console Amazon à l'adresse https://console.aws.amazon.com/qldb.
Dans le volet de navigation, choisissez l'éditeur PartiQL.
Choisissez un registre dans la liste déroulante des livres.
Dans la fenêtre de l'éditeur de requêtes, entrez l'instruction de votre choix, puis choisissez Exécuter. Voici un exemple de requête.
```
SELECT * FROM testTable WHERE firstName = 'Jim'
```
Pour exécuter une instruction, vous pouvez également utiliser le raccourci clavier Ctrl + Enter pour Windows ou Cmd + Return pour macOS. Pour plus de raccourcis clavier, voirRaccourcis clavier de l'éditeur PartiQL.
Sous la fenêtre de l'éditeur de requêtes, les résultats de votre requête incluent les E/S de lecture, c'est-à-dire le nombre de demandes de lecture effectuées par l'instruction.

Vous pouvez également consulter les E/S lues de l'historique de vos requêtes en procédant comme suit :

Dans le volet de navigation, choisissez Recent queries sous l'éditeur partiQL.
La colonne Read I/Os affiche le nombre de demandes de lecture effectuées par chaque instruction.

Utilisation du QLDB pilote

Pour obtenir l'utilisation des E/S d'une instruction à l'aide du QLDB pilote, appelez le getConsumedIOs curseur de flux ou le curseur mis en mémoire tampon du résultat.

Les exemples de code suivants montrent comment obtenir des E/S de lecture à partir du curseur de flux du résultat d'une instruction.

Java


import com.amazon.ion.IonSystem;
import com.amazon.ion.IonValue;
import com.amazon.ion.system.IonSystemBuilder;
import software.amazon.qldb.IOUsage;
import software.amazon.qldb.Result;

IonSystem ionSystem = IonSystemBuilder.standard().build();
IonValue ionFirstName = ionSystem.newString("Jim");

driver.execute(txn -> {
    Result result = txn.execute("SELECT * FROM testTable WHERE firstName = ?", ionFirstName);

    for (IonValue ionValue : result) {
        // User code here to handle results
    }

    IOUsage ioUsage = result.getConsumedIOs();
    long readIOs = ioUsage.getReadIOs();
});

.NET


using Amazon.IonDotnet.Builders;
using Amazon.IonDotnet.Tree;
using Amazon.QLDB.Driver;
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult;

// This is one way of creating Ion values. We can also use a ValueFactory.
// For more details, see: https://docs.aws.amazon.com/qldb/latest/developerguide/driver-cookbook-dotnet.html#cookbook-dotnet.ion
IIonValue ionFirstName = IonLoader.Default.Load("Jim");

await driver.Execute(async txn =>
{
    IAsyncResult result = await txn.Execute("SELECT * FROM testTable WHERE firstName = ?", ionFirstName);

    // Iterate through stream cursor to accumulate read IOs.
    await foreach (IIonValue ionValue in result)
    {
        // User code here to handle results.
        // Warning: It is bad practice to rely on results within a lambda block, unless
        // it is to check the state of a result. This is because lambdas are retryable.
    }

    var ioUsage = result.GetConsumedIOs();
    var readIOs = ioUsage?.ReadIOs;
});

Note

Pour convertir en code synchrone, supprimez les async mots clés await et, puis remplacez le IAsyncResult type par. IResult

Go


import (
    "context"
    "fmt"
    "github.com/awslabs/amazon-qldb-driver-go/v2/qldbdriver"
)

driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) {
    result, err := txn.Execute("SELECT * FROM testTable WHERE firstName = ?", "Jim")

    if err != nil {
        panic(err)
    }

    for result.Next(txn) {
        // User code here to handle results
    }

    ioUsage := result.GetConsumedIOs()
    readIOs := *ioUsage.GetReadIOs()
    fmt.Println(readIOs)
    return nil,nil
})

Node.js


import { IOUsage, ResultReadable, TransactionExecutor } from "amazon-qldb-driver-nodejs";

await driver.executeLambda(async (txn: TransactionExecutor) => {
    const result: ResultReadable = await txn.executeAndStreamResults("SELECT * FROM testTable WHERE firstName = ?", "Jim");

    for await (const chunk of result) {
        // User code here to handle results
    }

    const ioUsage: IOUsage = result.getConsumedIOs();
    const readIOs: number = ioUsage.getReadIOs();
});

Python


def get_read_ios(transaction_executor):
    cursor = transaction_executor.execute_statement("SELECT * FROM testTable WHERE firstName = ?", "Jim")

    for row in cursor:
        # User code here to handle results
        pass

    consumed_ios = cursor.get_consumed_ios()
    read_ios = consumed_ios.get('ReadIOs')

qldb_driver.execute_lambda(lambda txn: get_read_ios(txn))

Les exemples de code suivants montrent comment obtenir des E/S de lecture à partir du curseur mis en mémoire tampon du résultat d'une instruction. Cela renvoie le nombre total d'E/S de lecture ExecuteStatement et de FetchPage demandes.

Java


import com.amazon.ion.IonSystem;
import com.amazon.ion.IonValue;
import com.amazon.ion.system.IonSystemBuilder;
import software.amazon.qldb.IOUsage;
import software.amazon.qldb.Result;

IonSystem ionSystem = IonSystemBuilder.standard().build();
IonValue ionFirstName = ionSystem.newString("Jim");

Result result = driver.execute(txn -> {
    return txn.execute("SELECT * FROM testTable WHERE firstName = ?", ionFirstName);
});

IOUsage ioUsage = result.getConsumedIOs();
long readIOs = ioUsage.getReadIOs();

.NET


using Amazon.IonDotnet.Builders;
using Amazon.IonDotnet.Tree;
using Amazon.QLDB.Driver;
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult;

IIonValue ionFirstName = IonLoader.Default.Load("Jim");

IAsyncResult result = await driver.Execute(async txn =>
{
    return await txn.Execute("SELECT * FROM testTable WHERE firstName = ?", ionFirstName);
});

var ioUsage = result.GetConsumedIOs();
var readIOs = ioUsage?.ReadIOs;

Note

Pour convertir en code synchrone, supprimez les async mots clés await et, puis remplacez le IAsyncResult type par. IResult

Go


import (
    "context"
    "fmt"
    "github.com/awslabs/amazon-qldb-driver-go/v2/qldbdriver"
)

result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) {
    result, err :=  txn.Execute("SELECT * FROM testTable WHERE firstName = ?", "Jim")
    if err != nil {
        return nil, err
    }
    return txn.BufferResult(result)
})

if err != nil {
    panic(err)
}

qldbResult := result.(*qldbdriver.BufferedResult)
ioUsage := qldbResult.GetConsumedIOs()
readIOs := *ioUsage.GetReadIOs()
fmt.Println(readIOs)

Node.js


import { IOUsage, Result, TransactionExecutor } from "amazon-qldb-driver-nodejs";

const result: Result = await driver.executeLambda(async (txn: TransactionExecutor) => {
    return await txn.execute("SELECT * FROM testTable WHERE firstName = ?", "Jim");
});

const ioUsage: IOUsage = result.getConsumedIOs();
const readIOs: number = ioUsage.getReadIOs();

Python


cursor = qldb_driver.execute_lambda(
    lambda txn: txn.execute_statement("SELECT * FROM testTable WHERE firstName = ?", "Jim"))

consumed_ios = cursor.get_consumed_ios()
read_ios = consumed_ios.get('ReadIOs')

Note

Le curseur de flux est dynamique car il pagine le jeu de résultats. Par conséquent, les getTimingInformation opérations getConsumedIOs et renvoient les métriques accumulées à partir du moment où vous les appelez.

Le curseur mis en mémoire tampon met en mémoire tampon le jeu de résultats et renvoie le total des métriques cumulées.

Informations de chronométrage

La métrique des informations temporelles décrit le temps de traitement côté serveur en millisecondes. Le temps de traitement côté serveur est défini comme le temps consacré au traitement d'une instruction. QLDB Cela n'inclut pas le temps passé sur les appels réseau ou les pauses. Cette métrique permet de distinguer le temps de traitement côté QLDB service du temps de traitement côté client.

Utilisation de la console QLDB

Pour obtenir les informations temporelles d'une instruction à l'aide de la QLDB console, procédez comme suit :

Ouvrez la QLDB console Amazon à l'adresse https://console.aws.amazon.com/qldb.
Dans le volet de navigation, choisissez l'éditeur PartiQL.
Choisissez un registre dans la liste déroulante des livres.
Dans la fenêtre de l'éditeur de requêtes, entrez l'instruction de votre choix, puis choisissez Exécuter. Voici un exemple de requête.
```
SELECT * FROM testTable WHERE firstName = 'Jim'
```
Pour exécuter une instruction, vous pouvez également utiliser le raccourci clavier Ctrl + Enter pour Windows ou Cmd + Return pour macOS. Pour plus de raccourcis clavier, voirRaccourcis clavier de l'éditeur PartiQL.
Sous la fenêtre de l'éditeur de requêtes, les résultats de votre requête incluent la latence côté serveur, c'est-à-dire le temps écoulé entre la QLDB réception de la demande de relevé et l'envoi de la réponse. Il s'agit d'un sous-ensemble de la durée totale de la requête.

Vous pouvez également consulter les informations temporelles de l'historique de vos requêtes en procédant comme suit :

Dans le volet de navigation, choisissez Recent queries sous l'éditeur partiQL.
La colonne Temps d'exécution (ms) affiche ces informations temporelles pour chaque instruction.

Utilisation du QLDB pilote

Pour obtenir les informations temporelles d'une instruction à l'aide du QLDB pilote, appelez le getTimingInformation curseur de flux ou le curseur mis en mémoire tampon du résultat.

Les exemples de code suivants montrent comment obtenir le temps de traitement à partir du curseur de flux du résultat d'une instruction.

Java


import com.amazon.ion.IonSystem;
import com.amazon.ion.IonValue;
import com.amazon.ion.system.IonSystemBuilder;
import software.amazon.qldb.Result;
import software.amazon.qldb.TimingInformation;

IonSystem ionSystem = IonSystemBuilder.standard().build();
IonValue ionFirstName = ionSystem.newString("Jim");

driver.execute(txn -> {
    Result result = txn.execute("SELECT * FROM testTable WHERE firstName = ?", ionFirstName);

    for (IonValue ionValue : result) {
        // User code here to handle results
    }

    TimingInformation timingInformation = result.getTimingInformation();
    long processingTimeMilliseconds = timingInformation.getProcessingTimeMilliseconds();
});

.NET


using Amazon.IonDotnet.Builders;
using Amazon.IonDotnet.Tree;
using Amazon.QLDB.Driver;
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult;

IIonValue ionFirstName = IonLoader.Default.Load("Jim");

await driver.Execute(async txn =>
{
    IAsyncResult result = await txn.Execute("SELECT * FROM testTable WHERE firstName = ?", ionFirstName);

    // Iterate through stream cursor to accumulate processing time.
    await foreach(IIonValue ionValue in result)
    {
        // User code here to handle results.
        // Warning: It is bad practice to rely on results within a lambda block, unless
        // it is to check the state of a result. This is because lambdas are retryable.
    }

    var timingInformation = result.GetTimingInformation();
    var processingTimeMilliseconds = timingInformation?.ProcessingTimeMilliseconds;
});

Note

Pour convertir en code synchrone, supprimez les async mots clés await et, puis remplacez le IAsyncResult type par. IResult

Go


import (
    "context"
    "fmt"
    "github.com/awslabs/amazon-qldb-driver-go/v2/qldbdriver"
)

driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) {
    result, err := txn.Execute("SELECT * FROM testTable WHERE firstName = ?", "Jim")

    if err != nil {
        panic(err)
    }

    for result.Next(txn) {
        // User code here to handle results
    }

    timingInformation := result.GetTimingInformation()
    processingTimeMilliseconds := *timingInformation.GetProcessingTimeMilliseconds()
    fmt.Println(processingTimeMilliseconds)
    return nil, nil
})

Node.js


import { ResultReadable, TimingInformation, TransactionExecutor } from "amazon-qldb-driver-nodejs";

await driver.executeLambda(async (txn: TransactionExecutor) => {
    const result: ResultReadable = await txn.executeAndStreamResults("SELECT * FROM testTable WHERE firstName = ?", "Jim");

    for await (const chunk of result) {
        // User code here to handle results
    }

    const timingInformation: TimingInformation = result.getTimingInformation();
    const processingTimeMilliseconds: number = timingInformation.getProcessingTimeMilliseconds();
});

Python


def get_processing_time_milliseconds(transaction_executor):
    cursor = transaction_executor.execute_statement("SELECT * FROM testTable WHERE firstName = ?", "Jim")

    for row in cursor:
        # User code here to handle results
        pass

    timing_information = cursor.get_timing_information()
    processing_time_milliseconds = timing_information.get('ProcessingTimeMilliseconds')

qldb_driver.execute_lambda(lambda txn: get_processing_time_milliseconds(txn))

Les exemples de code suivants montrent comment obtenir le temps de traitement à partir du curseur mis en mémoire tampon du résultat d'une instruction. Cela renvoie le temps de traitement total des FetchPage demandes ExecuteStatement et des demandes.

Java


import com.amazon.ion.IonSystem;
import com.amazon.ion.IonValue;
import com.amazon.ion.system.IonSystemBuilder;
import software.amazon.qldb.Result;
import software.amazon.qldb.TimingInformation;

IonSystem ionSystem = IonSystemBuilder.standard().build();
IonValue ionFirstName = ionSystem.newString("Jim");

Result result = driver.execute(txn -> {
    return txn.execute("SELECT * FROM testTable WHERE firstName = ?", ionFirstName);
});

TimingInformation timingInformation = result.getTimingInformation();
long processingTimeMilliseconds = timingInformation.getProcessingTimeMilliseconds();

.NET


using Amazon.IonDotnet.Builders;
using Amazon.IonDotnet.Tree;
using Amazon.QLDB.Driver;
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult;

IIonValue ionFirstName = IonLoader.Default.Load("Jim");

IAsyncResult result = await driver.Execute(async txn =>
{
    return await txn.Execute("SELECT * FROM testTable WHERE firstName = ?", ionFirstName);
});

var timingInformation = result.GetTimingInformation();
var processingTimeMilliseconds = timingInformation?.ProcessingTimeMilliseconds;

Note

Pour convertir en code synchrone, supprimez les async mots clés await et, puis remplacez le IAsyncResult type par. IResult

Go


import (
    "context"
    "fmt"
    "github.com/awslabs/amazon-qldb-driver-go/v2/qldbdriver"
)

result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) {
    result, err :=  txn.Execute("SELECT * FROM testTable WHERE firstName = ?", "Jim")
    if err != nil {
        return nil, err
    }
    return txn.BufferResult(result)
})

if err != nil {
    panic(err)
}

qldbResult := result.(*qldbdriver.BufferedResult)
timingInformation := qldbResult.GetTimingInformation()
processingTimeMilliseconds := *timingInformation.GetProcessingTimeMilliseconds()
fmt.Println(processingTimeMilliseconds)

Node.js


import { Result, TimingInformation, TransactionExecutor } from "amazon-qldb-driver-nodejs";

const result: Result = await driver.executeLambda(async (txn: TransactionExecutor) => {
    return await txn.execute("SELECT * FROM testTable WHERE firstName = ?", "Jim");
});

const timingInformation: TimingInformation = result.getTimingInformation();
const processingTimeMilliseconds: number = timingInformation.getProcessingTimeMilliseconds();

Python


cursor = qldb_driver.execute_lambda(
    lambda txn: txn.execute_statement("SELECT * FROM testTable WHERE firstName = ?", "Jim"))

timing_information = cursor.get_timing_information()
processing_time_milliseconds = timing_information.get('ProcessingTimeMilliseconds')

Note

Le curseur mis en mémoire tampon met en mémoire tampon le jeu de résultats et renvoie le total des métriques cumulées.

Pour savoir comment interroger le catalogue du système, passez àInterrogation du catalogue du système.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Optimisation des performances des requêtes

Interrogation du catalogue du système