Utilizzo I/O Informazioni sulla tempistica

Ottenere le statistiche delle dichiarazioni PartiQL

Amazon QLDB fornisce statistiche sull'esecuzione delle dichiarazioni che possono aiutarti a ottimizzare l'utilizzo di QLDB eseguendo istruzioni PartiQL più efficienti. QLDB restituisce queste statistiche insieme ai risultati della dichiarazione. Includono metriche che quantificano l'utilizzo di I/O consumato e il tempo di elaborazione lato server, che è possibile utilizzare per identificare le dichiarazioni inefficienti.

Questa funzionalità è attualmente disponibile nell'editor PartiQL sulla console QLDB, nella shell QLDB e nell'ultima versione del driver QLDB per tutte le lingue supportate. È inoltre possibile visualizzare le statistiche delle dichiarazioni relative alla cronologia delle interrogazioni sulla console.

Utilizzo I/O

La metrica di utilizzo dell'I/O descrive il numero di richieste di I/O di lettura. Se il numero di richieste di I/O di lettura è superiore al previsto, indica che l'istruzione non è ottimizzata, ad esempio la mancanza di un indice. Ti consigliamo di esaminareSchemi di query ottimali l'argomento precedente, Ottimizzazione delle prestazioni delle query.

Nota

Quando si esegue un'CREATE INDEXistruzione su una tabella non vuota, la metrica di utilizzo dell'I/O include le richieste di lettura solo per la chiamata di creazione sincrona dell'indice.

QLDB crea l'indice per qualsiasi documento esistente nella tabella in modo asincrono. Queste richieste di lettura asincrona non sono incluse nella metrica di utilizzo dell'I/O contenuta nei risultati del rendiconto. Le richieste di lettura asincrona vengono addebitate separatamente e vengono aggiunte al totale degli I/O di lettura dopo il completamento della creazione dell'indice.

Utilizzo della console QLDB

Per ottenere l'utilizzo dell'I/O di lettura di una dichiarazione utilizzando la console QLDB, procedi come segue:

Apri la console Amazon QLDB all'indirizzo https://console.aws.amazon.com/qldb.
Nel riquadro di navigazione, seleziona l'editor PartiQL.
Scegli un libro contabile dall'elenco a discesa dei libri contabili.
Nella finestra dell'editor di query, inserisci qualsiasi istruzione di tua scelta, quindi scegli Esegui. Di seguito è riportato un esempio di interrogazione.
```
SELECT * FROM testTable WHERE firstName = 'Jim'
```
Per eseguire un'istruzione, puoi anche usare la scorciatoia da tastieraCtrl +Enter per Windows oCmd +Return per macOS. Per altre scelte rapide da tastiera, consultaScelte rapide da tastiera dell'editor PartiQL.
Sotto la finestra dell'editor delle query, i risultati della query includono gli I/O di lettura, ovvero il numero di richieste di lettura effettuate dall'istruzione.

Puoi anche visualizzare gli I/O letti della cronologia delle query eseguendo i seguenti passaggi:

Nel pannello di navigazione, scegli Query recenti nell'editor PartiQL.
La colonna Read I/O mostra il numero di richieste di lettura effettuate da ciascuna istruzione.

Utilizzo del driver QLDB

Per ottenere l'utilizzo dell'I/O di un'istruzione utilizzando il driver QLDB, chiamate l'getConsumedIOsoperazione del cursore di flusso o del cursore bufferizzato del risultato.

Gli esempi di codice seguenti mostrano come ottenere gli I/O di lettura dal cursore di lettura dal cursore dello stream del risultato di un'istruzione.

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;
});

Nota

Per convertire in codice sincrono, rimuovi leasync parole chiaveawait e e modificane ilIAsyncResult tipo inIResult.

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))

Gli esempi di codice seguenti mostrano come ottenere gli I/O di lettura dal cursore in formato UTC. Questo restituisce il totale degli I/O di letturaExecuteStatement eFetchPage delle richieste.

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;

Nota

Per convertire in codice sincrono, rimuovi leasync parole chiaveawait e e modificane ilIAsyncResult tipo inIResult.

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')

Nota

Il cursore dello stream è statico perché impagina il set di risultati. Pertanto, legetTimingInformation operazionigetConsumedIOs and restituiscono le metriche accumulate dal momento in cui le chiami.

Il cursore bufferizzato memorizza il set di risultati in memoria e restituisce le metriche totali accumulate.

Informazioni sulla tempistica

La metrica delle informazioni sui tempi descrive il tempo di elaborazione lato server in millisecondi. Il tempo di elaborazione sul lato server è definito come la quantità di tempo che QLDB impiega per elaborare una dichiarazione. Questo non include il tempo dedicato alle chiamate di rete o alle pause. Questa metrica distingue il tempo di elaborazione sul lato del servizio QLDB dal tempo di elaborazione sul lato client.

Utilizzo della console QLDB

Per ottenere le informazioni sulla tempistica di un rendiconto utilizzando la console QLDB, procedi come segue:

Apri la console Amazon QLDB all'indirizzo https://console.aws.amazon.com/qldb.
Nel riquadro di navigazione, seleziona l'editor PartiQL.
Scegli un libro contabile dall'elenco a discesa dei libri contabili.
Nella finestra dell'editor di query, inserisci qualsiasi istruzione di tua scelta, quindi scegli Esegui. Di seguito è riportato un esempio di interrogazione.
```
SELECT * FROM testTable WHERE firstName = 'Jim'
```
Per eseguire un'istruzione, puoi anche usare la scorciatoia da tastieraCtrl +Enter per Windows oCmd +Return per macOS. Per altre scelte rapide da tastiera, consultaScelte rapide da tastiera dell'editor PartiQL.
Sotto la finestra dell'editor delle query, i risultati della query includono la latenza sul lato server, che è la quantità di tempo tra il momento in cui QLDB ha ricevuto la richiesta di dichiarazione e il momento in cui ha inviato la risposta. Si tratta di un sottoinsieme della durata totale della query.

Puoi anche visualizzare le informazioni sulla tempistica della cronologia delle interrogazioni eseguendo i seguenti passaggi:

Nel pannello di navigazione, scegli Query recenti nell'editor PartiQL.
La colonna Tempo di esecuzione (ms) visualizza queste informazioni sulla tempistica per ogni istruzione.

Utilizzo del driver QLDB

Per ottenere le informazioni sulla temporizzazione di un'istruzione utilizzando il driver QLDB, chiamate l'getTimingInformationoperazione del cursore di flusso o del cursore bufferizzato del risultato.

Gli esempi di codice seguenti mostrano come ottenere il tempo di elaborazione dal cursore di elaborazione dal cursore di flusso del risultato di un'istruzione.

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;
});

Nota

Per convertire in codice sincrono, rimuovi leasync parole chiaveawait e e modificane ilIAsyncResult tipo inIResult.

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))

Gli esempi di codice seguenti mostrano come ottenere il tempo di elaborazione dal cursore in formato UTC. Questo restituisce il tempo totale di elaborazione delleFetchPage richiesteExecuteStatement e delle richieste.

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;

Nota

Per convertire in codice sincrono, rimuovi leasync parole chiaveawait e e modificane ilIAsyncResult tipo inIResult.

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')

Nota

Il cursore bufferizzato memorizza il set di risultati in memoria e restituisce le metriche totali accumulate.

Per informazioni su come eseguire query nel catalogo di sistema, procedere aInterrogazione del catalogo di sistema.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Ottimizzazione delle prestazioni delle query

Interrogazione del catalogo di sistema