Obtener estadísticas de instrucciones PartiQL

Amazon QLDB proporciona estadísticas de ejecución de instrucciones que lo ayudarán a optimizar el uso de Amazon QLDB mediante la ejecución de instrucciones PartiQL más eficientes. QLDB devuelve estas estadísticas junto con los resultados de la instrucción. Incluyen métricas que cuantifican el uso de E/S consumido y el tiempo de procesamiento del lado del servidor, que puede utilizar para identificar instrucciones ineficientes.

Esta característica está disponible actualmente en el editor de PartiQL de la consola de QLDB, en el intérprete de comandos de QLDB y en la última versión del controlador de QLDB para todos los lenguajes compatibles. También puede ver las estadísticas de las instrucciones para su historial de consultas en la consola.

Uso de E/S

La métrica de uso de E/S describe la cantidad de solicitudes de E/S de lectura. Si el número de solicitudes de E/S de lectura es superior al esperado, indica que la instrucción no está optimizada, por ejemplo, porque no hay un índice. Le recomendamos que consulte Patrones de consulta óptimos en el tema anterior, Optimización del rendimiento de las consultas.

nota

Al ejecutar una instrucción CREATE INDEX en una tabla que no esté vacía, la métrica de uso de E/S incluye únicamente las solicitudes de lectura de la llamada de creación de índices sincrónica.

QLDB crea el índice de todos los documentos existentes en la tabla de forma asíncrona. Estas solicitudes de lectura asíncronas no se incluyen en la métrica de uso de E/S de los resultados de su instrucción. Las solicitudes de lectura asincrónica se cargan por separado y se añaden al total de E/S de lectura una vez finalizada la creación del índice.

Usar la consola de QLDB

Para obtener el uso de E/S de lectura de una instrucción mediante la consola de QLDB, lleve a cabo los siguientes pasos:

Abra la consola de Amazon QLDB en https://console.aws.amazon.com/qldb.
En el panel de navegación, seleccione Editor PartiQL.
Seleccione un libro mayor de la lista desplegable de libros mayores.
En la ventana del editor de consultas, introduzca cualquier instrucción que desee y, a continuación, seleccione Ejecutar. A continuación se muestra un ejemplo de consulta:
```
SELECT * FROM testTable WHERE firstName = 'Jim'
```
Para ejecutar una instrucción, también puede utilizar el atajo de teclado Ctrl+Enter para Windows o Cmd+Return para macOS. Para obtener más atajos de teclado, consulte Atajos de teclado del editor PartiQL.
Debajo de la ventana del editor de consultas, los resultados de la consulta incluyen las E/S de lectura, que es el número de solicitudes de lectura realizadas por la instrucción.

También puede ver las E/S de lectura del historial de consultas siguiendo estos pasos:

En el panel de navegación, seleccione Consultas recientes en el editor de PartiQL.
En la columna E/S de lectura, se muestra el número de solicitudes de lectura realizadas por cada instrucción.

Uso del controlador de QLDB

Para obtener el uso de E/S de una instrucción mediante el controlador de QLDB, llame a la operación getConsumedIOs del cursor de secuencia o del cursor almacenado en búfer del resultado.

En los siguientes ejemplos de código, se muestra cómo obtener E/S de lectura del cursor de secuencia del resultado de una instrucción.

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

Para convertirlo a código sincrónico, elimine las palabras clave await y async y cambie el tipo IAsyncResult a 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))

En los siguientes ejemplos de código, se muestra cómo obtener E/S de lectura del cursor almacenado en búfer del resultado de una instrucción. Esto devuelve el total de E/S de lectura de las solicitudes ExecuteStatement y 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

Para convertirlo a código sincrónico, elimine las palabras clave await y async y cambie el tipo IAsyncResult a 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

El cursor de secuencia tiene estado porque pagina el conjunto de resultados. Por lo tanto, las operaciones getConsumedIOs y getTimingInformation devuelven las métricas acumuladas desde el momento en que las llama.

El cursor almacenado en búfer almacena el conjunto de resultados en la memoria y devuelve el total de métricas acumuladas.

Información de temporización

La métrica de información de temporización describe el tiempo de procesamiento del lado del servidor en milisegundos. El tiempo de procesamiento del lado del servidor se define como la cantidad de tiempo que QLDB dedica a procesar una instrucción. Esto no incluye el tiempo dedicado a las llamadas o pausas de la red. Esta métrica elimina la ambigüedad entre el tiempo de procesamiento en el lado del servidor de QLDB y el tiempo de procesamiento en el lado del cliente.

Usar la consola de QLDB

Para obtener información de temporización de una instrucción mediante la consola de QLDB, lleve a cabo los siguientes pasos:

Abra la consola de Amazon QLDB en https://console.aws.amazon.com/qldb.
En el panel de navegación, seleccione Editor PartiQL.
Seleccione un libro mayor de la lista desplegable de libros mayores.
En la ventana del editor de consultas, introduzca cualquier instrucción que desee y, a continuación, seleccione Ejecutar. A continuación se muestra un ejemplo de consulta:
```
SELECT * FROM testTable WHERE firstName = 'Jim'
```
Para ejecutar una instrucción, también puede utilizar el atajo de teclado Ctrl+Enter para Windows o Cmd+Return para macOS. Para obtener más atajos de teclado, consulte Atajos de teclado del editor PartiQL.
Debajo de la ventana del editor de consultas, los resultados de la consulta incluyen la latencia del lado del servidor, que es el tiempo transcurrido entre el momento en que QLDB recibe la solicitud de instrucción y el momento en que envía la respuesta. Es un subconjunto de la duración total de la consulta.

También puede ver la información de temporización de su historial de consultas siguiendo estos pasos:

En el panel de navegación, seleccione Consultas recientes en el editor de PartiQL.
La columna Tiempo de ejecución (ms) muestra esta información de temporización para cada instrucción.

Uso del controlador de QLDB

Para obtener información de temporización de una instrucción mediante el controlador de QLDB, llame a la operación getTimingInformation del curos de secuencia o almacenado en búfer del resultado.

En los siguientes ejemplos de código, se muestra cómo obtener el tiempo de procesamiento del cursor de secuencia del resultado de una instrucción.

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

Para convertirlo a código sincrónico, elimine las palabras clave await y async y cambie el tipo IAsyncResult a 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))

En los siguientes ejemplos de código, se muestra cómo obtener el tiempo de procesamiento del cursor almacenado en búfer del resultado de una instrucción. Esto devuelve el tiempo de procesamiento total de las solicitudes ExecuteStatement y FetchPage.

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

Para convertirlo a código sincrónico, elimine las palabras clave await y async y cambie el tipo IAsyncResult a 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')

nota

El cursor almacenado en búfer almacena el conjunto de resultados en la memoria y devuelve el total de métricas acumuladas.

Para obtener más información sobre cómo consultar el catálogo del sistema, continúe con Consulta del catálogo del sistema.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Optimizar el rendimiento de las consul‎tas‎

Consulta del catálogo del sistema