Utilisation des E/S Informations de chronométrage

Obtention des statistiques d'instruction PartiQL

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. QLDB renvoie ces statistiques ainsi que les résultats de l'instruction. Ils incluent des mesures qui quantifient l'utilisation des E/S consommées et le temps de traitement côté serveur, que vous pouvez utiliser pour identifier les déclarations inefficaces.

Cette fonctionnalité est actuellement disponible dans l'éditeur PartiQL de la console QLDB, dans le shell QLDB et dans la dernière version du pilote QLDB pour toutes les langues prises en charge. Vous pouvez également consulter les statistiques des relevés pour 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 consulterModèles de données optimaux la rubrique précédente intitulée Optimisation des performances des requêtes.

Note

Lorsque vous exécutez uneCREATE 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.

QLDB construit l'index de tous les documents existants dans la table de manière asynchrone. Ces demandes de lecture asynchrones ne sont pas incluses dans la métrique d'utilisation des E/S à partir des résultats de vos relevés. Les demandes de lecture asynchrones sont facturées séparément et sont ajoutées au total de vos E/S de lecture une fois la construction de l'index terminée.

Utilisation de la console QLDB

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

Ouvrez la console Amazon QLDB à l'adresse https://console.aws.amazon.com/qldb.
Dans le panneau de navigation, choisissez PartiQL editor.
Choisissez un livre dans la liste déroulante des registres.
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 clavierCtrl +Enter pour Windows ouCmd +Return pour macOS. Pour plus de raccourcis clavier, consultezRaccourcis 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 de lecture de l'historique de vos requêtes en procédant comme suit :

Dans le volet de navigation, choisissez Requêtes récentes sous l'éditeur PartiQL.
La colonne Read I/Os affiche le nombre de demandes de lecture effectuées par chaque instruction.

Utilisation du pilote QLDB

Pour connaître l'utilisation des E/S d'une instruction à l'aide du pilote QLDB, appelez l'getConsumedIOsopération du curseur de flux ou du curseur mis en mémoire tampon du résultat.

Les exemples de code suivants montrent comment obtenir des E/S lues à partir du curseur de flux d'un résultat d'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 lesasync mots-clésawait et, puis remplacez leIAsyncResult type parIResult.

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 lues à partir du curseur en mémoire tampon du résultat d'une instruction. Cela renvoie le nombre total d'E/S de lectureExecuteStatement et deFetchPage 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 lesasync mots-clésawait et, puis remplacez leIAsyncResult type parIResult.

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, lesgetTimingInformation opérationsgetConsumedIOs et renvoient les mesures accumulées à partir du moment où vous les appelez.

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

Informations de chronométrage

La métrique d'informations de synchronisation décrit le temps de traitement côté serveur en millisecondes. Le temps de traitement côté serveur est défini comme le temps que QLDB consacre au traitement d'une instruction. Cela n'inclut pas le temps passé sur les appels réseau ni les pauses. Cette métrique élimine l'ambiguïté entre le temps de traitement côté service QLDB et le temps de traitement côté client.

Utilisation de la console QLDB

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

Ouvrez la console Amazon QLDB à l'adresse https://console.aws.amazon.com/qldb.
Dans le panneau de navigation, choisissez PartiQL editor.
Choisissez un livre dans la liste déroulante des registres.
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 clavierCtrl +Enter pour Windows ouCmd +Return pour macOS. Pour plus de raccourcis clavier, consultezRaccourcis 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 délai entre la réception de la demande d'instruction par QLDB 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 Requêtes récentes sous l'éditeur PartiQL.
La colonne Temps d'exécution (ms) affiche ces informations de synchronisation pour chaque instruction.

Utilisation du pilote QLDB

Pour obtenir les informations de synchronisation d'une instruction à l'aide du pilote QLDB, appelez l'getTimingInformationopération du curseur de flux ou du 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 lesasync mots-clésawait et, puis remplacez leIAsyncResult type parIResult.

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 en mémoire tampon du résultat d'une instruction. Cela renvoie le temps de traitement total desFetchPage demandesExecuteStatement 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 lesasync mots-clésawait et, puis remplacez leIAsyncResult type parIResult.

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 le jeu de résultats et renvoie le total des mesures cumulées.

Pour savoir comment interroger le catalogue système, passez àInterrogation du catalogue 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 données

Interrogation du catalogue système