Administra el optimizador de consultas

Cloud Spanner proporciona control del optimizador mediante el control de versiones del optimizador de consultas. En esta guía, se muestra cómo administrar la versión del optimizador de consultas que usan tus consultas.

A medida que implementemos actualizaciones en el optimizador de consultas de Cloud Spanner, nuestro objetivo será mejorar los planes de ejecución de consultas y entregar un rendimiento mejorado de tus consultas. De forma predeterminada, Cloud Spanner usa la versión más reciente del optimizador de consultas para cada base de datos. Con el control de versiones del optimizador de consultas, puedes ejecutar consultas en una versión anterior del optimizador que te proporciona un rendimiento predecible.

Enumera las versiones compatibles del optimizador

La versión del optimizador de consultas es un valor de número entero, que aumenta en 1 con cada actualización. La versión más reciente del optimizador de consultas es 2.

Ejecuta la siguiente instrucción de SQL a fin de mostrar una lista de todas las versiones del optimizador compatibles, junto con sus fechas de lanzamiento correspondientes. El número de versión más grande que se muestra es la versión compatible del optimizador más reciente.

SELECT * FROM SPANNER_SYS.SUPPORTED_OPTIMIZER_VERSIONS

De forma predeterminada, Cloud Spanner usa la versión más reciente del optimizador, que, en la actualidad, es 2. Usa uno de los métodos descritos en esta guía para anular este comportamiento predeterminado en tu situación.

Para obtener detalles sobre cada versión, consulta Historial de versiones del optimizador de consultas.

Prioridad de anulación de versión

Cloud Spanner ofrece varias formas de cambiar la versión del optimizador. Por ejemplo, puedes configurar la versión para una consulta específica o configurarla en la biblioteca cliente a nivel de proceso o de consulta. Cuando la versión se configura de muchas formas, se aplica el siguiente orden de prioridad. (Selecciona un vínculo para ir a esa sección en este documento).

Predeterminado de Cloud Spanner ← opción de base de datos ← app cliente ← variable de entorno ← consulta del cliente ← Sugerencia de declaración

Podemos interpretar el orden de prioridad anterior de la siguiente manera: cuando creas una base de datos, usa la versión predeterminada del optimizador de Cloud Spanner, que siempre es la versión más reciente. Configura de la versión del optimizador con uno de los métodos mencionados antes, que tiene prioridad sobre cualquier elemento que se encuentre a la izquierda. Por ejemplo, configurar el optimizador para una aplicación mediante una variable de entorno tiene prioridad sobre cualquier valor que establezcas para la base de datos con la opción de base de datos. La configuración de la versión del optimizador a través de una sugerencia de instrucción tiene la prioridad más alta para la consulta determinada y tiene prioridad sobre el valor establecido mediante cualquier otro método.

Ahora analicemos cada método con más detalle.

Configura la versión del optimizador para una base de datos con ALTER DATABASE

Puedes configurar la versión del optimizador predeterminada en una base de datos mediante el siguiente comando de DDL ALTER DATABASE.

ALTER DATABASE MyDatabase
SET OPTIONS (optimizer_version = 2);

Puedes ejecutar ALTER DATABASE en gcloud spanner con el comando gcloud spanner databases ddl update de la siguiente manera.

gcloud spanner databases ddl update MyDatabase --instance=test-instance \
    --ddl='ALTER DATABASE MyDatabase SET OPTIONS ( optimizer_version = 2 )'

Si configuras la opción de base de datos como NULL, esta se borra y se establece como base de datos predeterminada en la versión más reciente. Este es el valor predeterminado para las bases de datos nuevas.

Para consultar el valor actual de esta opción para una base de datos, léelo desde la vista INFORMATION_SCHEMA.DATABASE_OPTIONS.

Configura la versión del optimizador para una app cliente

Cuando interactúas de manera programática con Cloud Spanner a través de bibliotecas cliente, existen varias formas de cambiar la versión del optimizador para tu aplicación cliente.

Una aplicación puede configurar una opción de consulta global en la biblioteca cliente mediante la configuración de la propiedad de opciones de consulta como se muestra en los siguientes fragmentos de código. La configuración de la versión del optimizador se almacena en la instancia del cliente y se aplica a todas las consultas que se ejecutan durante toda la vida útil del cliente. Aunque las opciones se aplican a nivel de base de datos en el backend, cuando se configuran a nivel de cliente, se aplican a todas las bases de datos conectadas a través de ese cliente.

C++

namespace spanner = ::google::cloud::spanner;
spanner::Client client(
    spanner::MakeConnection(db),
    spanner::ClientOptions().set_query_options(
        spanner::QueryOptions()
            .set_optimizer_version("1")
            .set_optimizer_statistics_package("auto_20191128_14_47_22UTC")));

C#

var builder = new SpannerConnectionStringBuilder
{
    DataSource = $"projects/{projectId}/instances/{instanceId}/databases/{databaseId}"
};
// Create connection to Cloud Spanner.
using (var connection = new SpannerConnection(builder))
{
    // Set query options on the connection.
    connection.QueryOptions = QueryOptions.Empty.WithOptimizerVersion("1");
    var cmd = connection.CreateSelectCommand(
        "SELECT SingerId, AlbumId, AlbumTitle FROM Albums");
    using (var reader = await cmd.ExecuteReaderAsync())
    {
        while (await reader.ReadAsync())
        {
            Console.WriteLine("SingerId : "
            + reader.GetFieldValue<string>("SingerId")
            + " AlbumId : "
            + reader.GetFieldValue<string>("AlbumId")
            + " AlbumTitle : "
            + reader.GetFieldValue<string>("AlbumTitle"));
        }
    }
}

Go


import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/spanner"
	"google.golang.org/api/iterator"
	sppb "google.golang.org/genproto/googleapis/spanner/v1"
)

func createClientWithQueryOptions(w io.Writer, database string) error {
	ctx := context.Background()
	queryOptions := spanner.QueryOptions{
		Options: &sppb.ExecuteSqlRequest_QueryOptions{
			OptimizerVersion:           "1",
			OptimizerStatisticsPackage: "auto_20191128_14_47_22UTC",
		},
	}
	client, err := spanner.NewClientWithConfig(
		ctx, database, spanner.ClientConfig{QueryOptions: queryOptions},
	)
	if err != nil {
		return err
	}
	defer client.Close()

	stmt := spanner.Statement{SQL: `SELECT VenueId, VenueName, LastUpdateTime FROM Venues`}
	iter := client.Single().Query(ctx, stmt)
	defer iter.Stop()
	for {
		row, err := iter.Next()
		if err == iterator.Done {
			return nil
		}
		if err != nil {
			return err
		}
		var venueID int64
		var venueName string
		var lastUpdateTime time.Time
		if err := row.Columns(&venueID, &venueName, &lastUpdateTime); err != nil {
			return err
		}
		fmt.Fprintf(w, "%d %s %s\n", venueID, venueName, lastUpdateTime)
	}
}

Java

static void clientWithQueryOptions(DatabaseId db) {
  SpannerOptions options =
      SpannerOptions.newBuilder()
          .setDefaultQueryOptions(
              db, QueryOptions
                  .newBuilder()
                  .setOptimizerVersion("1")
                  .setOptimizerStatisticsPackage("auto_20191128_14_47_22UTC")
                  .build())
          .build();
  Spanner spanner = options.getService();
  DatabaseClient dbClient = spanner.getDatabaseClient(db);
  try (ResultSet resultSet =
      dbClient
          .singleUse()
          .executeQuery(Statement.of("SELECT SingerId, AlbumId, AlbumTitle FROM Albums"))) {
    while (resultSet.next()) {
      System.out.printf(
          "%d %d %s\n", resultSet.getLong(0), resultSet.getLong(1), resultSet.getString(2));
    }
  }
}

Node.js

// Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Gets a reference to a Cloud Spanner instance and database
const instance = spanner.instance(instanceId);
const database = instance.database(
  databaseId,
  {},
  {
    optimizerVersion: '1',
    optimizerStatisticsPackage: 'auto_20191128_14_47_22UTC',
  }
);

const query = {
  sql: `SELECT AlbumId, AlbumTitle, MarketingBudget
        FROM Albums
        ORDER BY AlbumTitle`,
};

// Queries rows from the Albums table
try {
  const [rows] = await database.run(query);

  rows.forEach(row => {
    const json = row.toJSON();
    const marketingBudget = json.MarketingBudget
      ? json.MarketingBudget
      : null; // This value is nullable
    console.log(
      `AlbumId: ${json.AlbumId}, AlbumTitle: ${json.AlbumTitle}, MarketingBudget: ${marketingBudget}`
    );
  });
} catch (err) {
  console.error('ERROR:', err);
} finally {
  // Close the database when finished.
  database.close();
}

PHP

use Google\Cloud\Spanner\SpannerClient;
use Google\Cloud\Spanner\Database;

/**
 * Create a client with query options.
 * Example:
 * ```
 * create_client_with_query_options($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function create_client_with_query_options($instanceId, $databaseId)
{
    $spanner = new SpannerClient([
        'queryOptions' => [
            'optimizerVersion' => "1"
        ]
    ]);
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $results = $database->execute(
        'SELECT VenueId, VenueName, LastUpdateTime FROM Venues'
    );

    foreach ($results as $row) {
        printf('VenueId: %s, VenueName: %s, LastUpdateTime: %s' . PHP_EOL,
            $row['VenueId'], $row['VenueName'], $row['LastUpdateTime']);
    }
}

Python

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client(query_options={"optimizer_version": "1"})
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

with database.snapshot() as snapshot:
    results = snapshot.execute_sql(
        "SELECT VenueId, VenueName, LastUpdateTime FROM Venues"
    )

    for row in results:
        print(u"VenueId: {}, VenueName: {}, LastUpdateTime: {}".format(*row))

Ruby

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

query_options = { optimizer_version: "1", optimizer_statistics_package: "auto_20191128_14_47_22UTC" }

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id, query_options: query_options

sql_query = "SELECT VenueId, VenueName, LastUpdateTime FROM Venues"

client.execute(sql_query).rows.each do |row|
  puts "#{row[:VenueId]} #{row[:VenueName]} #{row[:LastUpdateTime]}"
end

Configura la versión del optimizador para una app cliente con una variable de entorno

Para que sea más fácil probar diferentes versiones del optimizador sin tener que volver a compilar tu app, puedes configurar la variable de entorno SPANNER_OPTIMIZER_VERSION y ejecutarla, como se muestra en el siguiente fragmento.

Linux/macOS

export SPANNER_OPTIMIZER_VERSION="2"

Windows

set SPANNER_OPTIMIZER_VERSION="2"

El valor de la versión del optimizador de consultas que se especificó se lee y se almacena en la instancia del cliente en el momento de la inicialización y se aplica a todas las consultas que se ejecutan durante toda la vida útil del cliente.

Configura la versión del optimizador para una consulta del cliente

Puedes especificar un valor para la versión del optimizador a nivel de consulta en tu aplicación cliente si especificas una propiedad de opciones de consulta cuando compiles tu consulta. Esto se ilustra en los siguientes fragmentos de código de cada lenguaje compatible.

C++

void QueryWithQueryOptions(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;
  auto sql = spanner::SqlStatement("SELECT SingerId, FirstName FROM Singers");
  auto opts = spanner::QueryOptions()
                  .set_optimizer_version("1")
                  .set_optimizer_statistics_package("latest");
  auto rows = client.ExecuteQuery(std::move(sql), std::move(opts));

  using RowType = std::tuple<std::int64_t, std::string>;
  for (auto const& row : spanner::StreamOf<RowType>(rows)) {
    if (!row) throw std::runtime_error(row.status().message());
    std::cout << "SingerId: " << std::get<0>(*row) << "\t";
    std::cout << "FirstName: " << std::get<1>(*row) << "\n";
  }
  std::cout << "Read completed for [spanner_query_with_query_options]\n";
}

C#

var builder = new SpannerConnectionStringBuilder
{
    DataSource = $"projects/{projectId}/instances/{instanceId}/databases/{databaseId}"
};
// Create connection to Cloud Spanner.
using (var connection = new SpannerConnection(builder))
{
    var cmd = connection.CreateSelectCommand(
        "SELECT SingerId, AlbumId, AlbumTitle FROM Albums");
    // Set query options just for this command.
    cmd.QueryOptions = QueryOptions.Empty.WithOptimizerVersion("1");
    using (var reader = await cmd.ExecuteReaderAsync())
    {
        while (await reader.ReadAsync())
        {
            Console.WriteLine("SingerId : "
            + reader.GetFieldValue<string>("SingerId")
            + " AlbumId : "
            + reader.GetFieldValue<string>("AlbumId")
            + " AlbumTitle : "
            + reader.GetFieldValue<string>("AlbumTitle"));
        }
    }
}

Go


import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/spanner"
	"google.golang.org/api/iterator"
	sppb "google.golang.org/genproto/googleapis/spanner/v1"
)

func queryWithQueryOptions(w io.Writer, db string) error {
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return err
	}
	defer client.Close()

	stmt := spanner.Statement{SQL: `SELECT VenueId, VenueName, LastUpdateTime FROM Venues`}
	queryOptions := spanner.QueryOptions{
		Options: &sppb.ExecuteSqlRequest_QueryOptions{
			OptimizerVersion:           "1",
			OptimizerStatisticsPackage: "latest",
		},
	}
	iter := client.Single().QueryWithOptions(ctx, stmt, queryOptions)
	defer iter.Stop()
	for {
		row, err := iter.Next()
		if err == iterator.Done {
			return nil
		}
		if err != nil {
			return err
		}
		var venueID int64
		var venueName string
		var lastUpdateTime time.Time
		if err := row.Columns(&venueID, &venueName, &lastUpdateTime); err != nil {
			return err
		}
		fmt.Fprintf(w, "%d %s %s\n", venueID, venueName, lastUpdateTime)
	}
}

Java

static void queryWithQueryOptions(DatabaseClient dbClient) {
  try (ResultSet resultSet =
      dbClient
          .singleUse()
          .executeQuery(
              Statement
                  .newBuilder("SELECT SingerId, AlbumId, AlbumTitle FROM Albums")
                  .withQueryOptions(QueryOptions
                      .newBuilder()
                      .setOptimizerVersion("1")
                      .setOptimizerStatisticsPackage("latest")
                      .build())
                  .build())) {
    while (resultSet.next()) {
      System.out.printf(
          "%d %d %s\n", resultSet.getLong(0), resultSet.getLong(1), resultSet.getString(2));
    }
  }
}

Node.js

// Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Gets a reference to a Cloud Spanner instance and database
const instance = spanner.instance(instanceId);
const database = instance.database(databaseId);

const query = {
  sql: `SELECT AlbumId, AlbumTitle, MarketingBudget
        FROM Albums
        ORDER BY AlbumTitle`,
  queryOptions: {
    optimizerVersion: 'latest',
    optimizerStatisticsPackage: 'latest',
  },
};

// Queries rows from the Albums table
try {
  const [rows] = await database.run(query);

  rows.forEach(row => {
    const json = row.toJSON();
    const marketingBudget = json.MarketingBudget
      ? json.MarketingBudget
      : null; // This value is nullable
    console.log(
      `AlbumId: ${json.AlbumId}, AlbumTitle: ${json.AlbumTitle}, MarketingBudget: ${marketingBudget}`
    );
  });
} catch (err) {
  console.error('ERROR:', err);
} finally {
  // Close the database when finished.
  database.close();
}

PHP

use Google\Cloud\Spanner\SpannerClient;
use Google\Cloud\Spanner\Database;

/**
 * Queries sample data using SQL with query options.
 * Example:
 * ```
 * query_data_with_query_options($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function query_data_with_query_options($instanceId, $databaseId)
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $results = $database->execute(
        'SELECT VenueId, VenueName, LastUpdateTime FROM Venues',
        [
            'queryOptions' => [
                'optimizerVersion' => "1"
            ]
        ]
    );

    foreach ($results as $row) {
        printf('VenueId: %s, VenueName: %s, LastUpdateTime: %s' . PHP_EOL,
            $row['VenueId'], $row['VenueName'], $row['LastUpdateTime']);
    }
}

Python

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

with database.snapshot() as snapshot:
    results = snapshot.execute_sql(
        "SELECT VenueId, VenueName, LastUpdateTime FROM Venues",
        query_options={"optimizer_version": "1"},
    )

    for row in results:
        print(u"VenueId: {}, VenueName: {}, LastUpdateTime: {}".format(*row))

Ruby

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

sql_query = "SELECT VenueId, VenueName, LastUpdateTime FROM Venues"
query_options = { optimizer_version: "1", optimizer_statistics_package: "latest" }

client.execute(sql_query, query_options: query_options).rows.each do |row|
  puts "#{row[:VenueId]} #{row[:VenueName]} #{row[:LastUpdateTime]}"
end

Configura la versión del optimizador para una consulta mediante una sugerencia de instrucción

Una sugerencia de instrucción es una sugerencia en una declaración de consulta que cambia la ejecución de la consulta desde el comportamiento predeterminado. Configurar la sugerencia OPTIMIZER_VERSION en una declaración obliga la ejecución de esa consulta mediante la versión del optimizador de consultas especificada.

La sugerencia OPTIMIZER_VERSION tiene la prioridad de versión más alta del optimizador. Si se especifica la sugerencia de la declaración, se usará independientemente de todas las demás configuraciones de la versión del optimizador.

@{OPTIMIZER_VERSION=2} SELECT * FROM MyTable

También puedes usar el literal latest para establecer la versión del optimizador de una consulta en la versión más reciente, como se muestra aquí.

@{OPTIMIZER_VERSION=latest} SELECT * FROM MyTable

Configura la versión del optimizador cuando usas el controlador de JDBC

Puedes anular el valor predeterminado de la versión del optimizador si especificas una versión en la string de conexión JDBC, como se muestra en el siguiente ejemplo.

import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

class ConnectionWithQueryOptionsExample {

  static void connectionWithQueryOptions() throws SQLException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    connectionWithQueryOptions(projectId, instanceId, databaseId);
  }

  @SuppressFBWarnings(
      value = "OBL_UNSATISFIED_OBLIGATION",
      justification = "https://github.com/spotbugs/spotbugs/issues/293")
  static void connectionWithQueryOptions(String projectId, String instanceId, String databaseId)
      throws SQLException {
    String optimizerVersion = "1";
    String connectionUrl =
        String.format(
            "jdbc:cloudspanner:/projects/%s/instances/%s/databases/%s?optimizerVersion=%s",
            projectId, instanceId, databaseId, optimizerVersion);
    try (Connection connection = DriverManager.getConnection(connectionUrl);
        Statement statement = connection.createStatement()) {
      // Execute a query using the optimizer version '1'.
      try (ResultSet rs =
          statement.executeQuery(
              "SELECT SingerId, FirstName, LastName FROM Singers ORDER BY LastName")) {
        while (rs.next()) {
          System.out.printf("%d %s %s%n", rs.getLong(1), rs.getString(2), rs.getString(3));
        }
      }
      try (ResultSet rs = statement.executeQuery("SHOW VARIABLE OPTIMIZER_VERSION")) {
        while (rs.next()) {
          System.out.printf("Optimizer version: %s%n", rs.getString(1));
        }
      }
    }
  }
}

También puedes configurar la versión del optimizador de consultas con la declaración SET OPTIMIZER_VERSION, como se muestra en el siguiente ejemplo.

import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

class SetQueryOptionsExample {

  static void setQueryOptions() throws SQLException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    setQueryOptions(projectId, instanceId, databaseId);
  }

  @SuppressFBWarnings(
      value = "OBL_UNSATISFIED_OBLIGATION",
      justification = "https://github.com/spotbugs/spotbugs/issues/293")
  static void setQueryOptions(String projectId, String instanceId, String databaseId)
      throws SQLException {
    String connectionUrl =
        String.format(
            "jdbc:cloudspanner:/projects/%s/instances/%s/databases/%s",
            projectId, instanceId, databaseId);
    try (Connection connection = DriverManager.getConnection(connectionUrl);
        Statement statement = connection.createStatement()) {
      // Instruct the JDBC connection to use version '1' of the query optimizer.
      statement.execute("SET OPTIMIZER_VERSION='1'");
      // Execute a query using the latest optimizer version.
      try (ResultSet rs =
          statement.executeQuery(
              "SELECT SingerId, FirstName, LastName FROM Singers ORDER BY LastName")) {
        while (rs.next()) {
          System.out.printf("%d %s %s%n", rs.getLong(1), rs.getString(2), rs.getString(3));
        }
      }
      try (ResultSet rs = statement.executeQuery("SHOW VARIABLE OPTIMIZER_VERSION")) {
        while (rs.next()) {
          System.out.printf("Optimizer version: %s%n", rs.getString(1));
        }
      }
    }
  }
}

Para obtener más detalles sobre el uso del controlador de código abierto, consulta Usa el controlador JDBC de código abierto.

Cómo se controlan las versiones del optimizador no válidas

Cloud Spanner admite un rango de versiones de optimizador. Este rango cambia con el tiempo cuando se actualiza el optimizador de consultas. Si la versión que especificas cuando usas uno de los métodos que se describen en esta guía está fuera de rango, Cloud Spanner falla la consulta. Por ejemplo, si intentas ejecutar una consulta con la versión 100 del optimizador, y supongamos que excede el valor máximo actual, recibirás el siguiente error.

Query optimizer version: 100 is not supported

Determina la versión del optimizador de consultas que se usa para ejecutar una consulta

La versión del optimizador que se usa para una consulta es visible en gcloud Spanner y a través de Cloud Console.

gcloud spanner

Para ver la versión que se usa cuando se ejecuta una consulta en gcloud Spanner, configura la marca --query-mode como PROFILE, como se muestra en el siguiente fragmento.

gcloud spanner databases execute-sql MyDatabase --instance=test-instance \
    --query-mode=PROFILE --sql='SELECT * FROM MyTable'

Cloud Console

Para ver la versión del optimizador que se usó en una consulta, ejecútala en la vista Base de datos de consultas de Cloud Console y, luego, selecciona la pestaña Explicaciones. Deberías ver un mensaje similar al siguiente:

Esta consulta se ejecutó con la versión 2 del optimizador.

Visualiza la versión del optimizador de consultas en el Explorador de métricas

Cloud Monitoring recopila medidas para ayudarte a comprender el rendimiento de las aplicaciones y los servicios del sistema. Una de las métricas recopiladas para Cloud Spanner es el Recuento de consultas, que mide la cantidad de consultas en una instancia, muestredas a lo largo del tiempo. Aunque esta métrica es muy útil para ver las consultas agrupadas por código de error, también podemos usarla con el fin de ver qué versión del optimizador se usó para ejecutar cada consulta.

Puedes usar el Explorador de métricas en Cloud Console para visualizar el Recuento de consultas de tu instancia de base de datos. En la Figura 1, se muestra el recuento de consultas para tres bases de datos. Puedes ver qué versión del optimizador se usa en cada base de datos.

En la tabla que aparece debajo del gráfico de esta figura, se muestra lo siguiente:my-db-1 trató de ejecutar una consulta con una versión del optimizador no válida, que mostraba el estadoUso inadecuado y se obtiene un recuento de consultas de 0. Las otras bases de datos ejecutaron consultas con las versiones 1 y 2 del optimizador, respectivamente.

Recuento de consultas en el Explorador de métricas agrupadas por versión del optimizador de consultas

Figura 1. Recuento de consultas que se muestra en el Explorador de métricas con consultas agrupadas por versión del optimizador.

Para configurar un gráfico similar para tu instancia, sigue estos pasos:

  1. En Cloud Console, navega al Explorador de métricas.
  2. En el campo Tipo de recurso, selecciona Cloud Spanner Instance.
  3. En el campo Métrica, selecciona Count of queries.
  4. En el campo Agrupar por, selecciona database, optimizer_version y status.

No se muestra en este ejemplo el caso en el que se usa una versión diferente del optimizador para consultas diferentes en la misma base de datos. En ese caso, el gráfico mostraría un segmento de barras para cada combinación de versión de base de datos y optimizador.

Si deseas obtener información sobre cómo usar Cloud Monitoring para supervisar tus instancias de Cloud Spanner, consulta Supervisa con Cloud Monitoring.