Utilizzo dell'I/O Informazioni sulla tempistica

Ottenere statistiche sulle istruzioni PartiQL

Importante

Avviso di fine del supporto: i clienti esistenti potranno utilizzare Amazon QLDB fino alla fine del supporto il 31/07/2025. Per ulteriori dettagli, consulta Migrare un Amazon QLDB Ledger ad Amazon Aurora Postgre. SQL

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

Questa funzionalità è attualmente disponibile nell'editor PartiQL sulla QLDBconsole, nella QLDBshell e nella versione più recente del QLDBdriver per tutte le lingue supportate. È inoltre possibile visualizzare le statistiche relative alle dichiarazioni relative alla cronologia delle query sulla console.

Utilizzo dell'I/O

La metrica di utilizzo dell'I/O descrive il numero di richieste di I/O lette. Se il numero di richieste I/O di lettura è superiore al previsto, indica che l'istruzione non è ottimizzata, ad esempio la mancanza di un indice. Si consiglia di consultare Modelli di interrogazione 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 sincrona per la creazione dell'indice.

QLDBcrea l'indice per tutti i documenti esistenti nella tabella in modo asincrono. Queste richieste di lettura asincrone non sono incluse nella metrica di utilizzo dell'I/O contenuta nei risultati delle istruzioni. Le richieste di lettura asincrone vengono addebitate separatamente e vengono aggiunte agli I/O di lettura totali dopo il completamento della creazione dell'indice.

Utilizzo della console di QLDB

Per ottenere l'utilizzo dell'I/O in lettura da parte di un'istruzione utilizzando la QLDB console, procedi nel seguente modo:

Apri la QLDB console Amazon all'indirizzo https://console.aws.amazon.com/qldb.
Nel pannello di navigazione, scegli Editor PartiQl.
Scegli un libro mastro dall'elenco a discesa dei libri contabili.
Nella finestra dell'editor di query, inserisci una dichiarazione a 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 tastiera Ctrl + Enter per Windows o Cmd + Return per macOS. Per altre scelte rapide da tastiera, consulta. Scelte rapide da tastiera dell'editor PartiQL
Sotto la finestra dell'editor di query, i risultati delle query includono gli I/O di lettura, ovvero il numero di richieste di lettura effettuate dall'istruzione.

È inoltre possibile visualizzare gli I/O di lettura della cronologia delle query effettuando le seguenti operazioni:

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 QLDB driver, chiamate l'getConsumedIOsoperazione dello stream cursor o del cursore bufferizzato del risultato.

I seguenti esempi di codice mostrano come ottenere gli I/O letti 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.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 eseguire la conversione in codice sincrono, rimuovete le async parole chiave await and e modificate il IAsyncResult tipo in. 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))

I seguenti esempi di codice mostrano come ottenere gli I/O letti dal cursore bufferizzato del risultato di un'istruzione. Ciò restituisce gli I/O totali di lettura e le richieste. ExecuteStatement FetchPage

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, rimuovete le async parole chiave await and e modificate il IAsyncResult tipo in. 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')

Nota

Il cursore stream è statico perché impagina il set di risultati. Pertanto, le getTimingInformation operazioni getConsumedIOs and restituiscono le metriche accumulate dal momento in cui le chiamate.

Il cursore memorizzato nel buffer memorizza il set di risultati e restituisce le metriche totali accumulate.

Informazioni sulla tempistica

La metrica delle informazioni sulla tempistica descrive il tempo di elaborazione lato server in millisecondi. Il tempo di elaborazione lato server è definito come la quantità di tempo impiegata per l'elaborazione di un'istruzione. QLDB Questo non include il tempo dedicato alle chiamate o alle pause di rete. Questa metrica disambigua il tempo di elaborazione sul lato QLDB servizio dal tempo di elaborazione sul lato client.

Utilizzo della console di QLDB

Per ottenere le informazioni sulla tempistica di un'istruzione utilizzando la QLDB console, procedi nel seguente modo:

Apri la QLDB console Amazon all'indirizzo https://console.aws.amazon.com/qldb.
Nel pannello di navigazione, scegli Editor PartiQl.
Scegli un libro mastro dall'elenco a discesa dei libri contabili.
Nella finestra dell'editor di query, inserisci una dichiarazione a 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 tastiera Ctrl + Enter per Windows o Cmd + Return per macOS. Per altre scelte rapide da tastiera, consulta. Scelte rapide da tastiera dell'editor PartiQL
Sotto la finestra dell'editor di query, i risultati delle query includono la latenza lato server, che è il periodo di tempo che intercorre tra la QLDB ricezione della richiesta di istruzione e l'invio della risposta. Si tratta di un sottoinsieme della durata totale della query.

È inoltre possibile visualizzare le informazioni temporali della cronologia delle query effettuando le seguenti operazioni:

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

Utilizzo del driver QLDB

Per ottenere le informazioni sulla temporizzazione di un'istruzione utilizzando il QLDB driver, richiamate l'getTimingInformationoperazione dello stream cursor o del cursore bufferizzato del risultato.

I seguenti esempi di codice mostrano come ottenere il tempo di elaborazione dal cursore 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.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 eseguire la conversione in codice sincrono, rimuovete le async parole chiave await and e modificate il IAsyncResult tipo in. 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))

I seguenti esempi di codice mostrano come ottenere il tempo di elaborazione dal cursore bufferizzato del risultato di un'istruzione. Ciò restituisce il tempo totale di elaborazione ExecuteStatement e FetchPage le 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 eseguire la conversione in codice sincrono, rimuovete le async parole chiave await and e modificate il IAsyncResult 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 memorizzato nel buffer memorizza il set di risultati e restituisce le metriche totali accumulate.

Per informazioni su come interrogare il catalogo di sistema, procedi a. Interrogazione 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