Lecture en dehors des transactions

Cette page explique comment effectuer des lectures dans Spanner en dehors du contexte des transactions de lecture seule et des transactions de lecture/écriture. Ainsi, vous devriez plutôt lire la page Transactions dans les cas suivants :

• Si vous avez besoin d'effectuer une écriture, en fonction de la valeur d'une ou plusieurs lectures, vous devez exécuter la lecture dans le cadre d'une transaction en lecture-écriture. En savoir plus sur les transactions en lecture-écriture

• Si vous effectuez plusieurs appels en lecture nécessitant une vue cohérente de vos données, vous devez exécuter les lectures dans le cadre d'une transaction en lecture seule. En savoir plus sur les transactions en lecture seule

Si vous devez effectuer un seul appel en lecture ou lire des données en parallèle sans avoir besoin d'écrire, lisez ce qui suit.

Types de lecture

Spanner vous permet de déterminer le niveau d'actualisation des données lorsque vous les lisez en proposant deux types de lectures:

• La lecture forte qui est une lecture avec un horodatage actuel. Elle garantit l'affichage de toutes les données qui ont été enregistrées jusqu'au début de cette lecture. Spanner utilise par défaut les lectures fortes pour diffuser les requêtes de lecture.
• La lecture non actualisée qui est une lecture avec un horodatage passé. Si votre application est sensible au temps de latence, mais tolère les données passées, les lectures non actualisées peuvent s'avérer avantageuses en termes de performances.

Choisir des limites d'horodatage

Pour choisir le type de lecture souhaité, définissez une limite d'horodatage dans la requête de lecture. Appliquez les bonnes pratiques suivantes lorsque vous choisissez une limite d'horodatage:

• Choisissez des lectures fortes autant que possible. Il s'agit de la limite d'horodatage par défaut pour les lectures Spanner, y compris les transactions en lecture seule. Il est garanti que les lectures fortes tiennent compte des effets de toutes les transactions enregistrées avant le début de l'opération, quelle que soit l'instance dupliquée recevant la lecture. De ce fait, les lectures fortes simplifient le code des applications et augmentent la fiabilité de ces dernières. Pour en savoir plus sur les propriétés de cohérence de Spanner, consultez la section TrueTime et cohérence externe.

• Si, dans certaines situations, la latence empêche les lectures fortes, préférez les lectures non actualisées (obsolescence limitée ou exacte) pour améliorer les performances lorsque vous n'avez pas besoin de lectures très récentes. Comme décrit dans la réplication de Cloud Spanner, 15 secondes est une valeur d'obsolescence raisonnable à utiliser pour obtenir de bonnes performances.

Méthodes de lecture unique

Spanner accepte les méthodes de lecture unique (c'est-à-dire, une lecture en dehors du contexte d'une transaction) sur une base de données pour:

• Exécuter la lecture sous la forme d'une instruction de requête SQL ou à l'aide de l'API Read de Spanner.
• effectuer une lecture forte à partir d'une ou de plusieurs lignes d'une table ;
• effectuer une lecture non actualisée à partir d'une ou de plusieurs lignes d'une table ;
• lire à partir d'une ou de plusieurs lignes d'un index secondaire.

Les sections ci-dessous décrivent l'utilisation des méthodes de lecture à l'aide des bibliothèques clientes cloud pour l'API Cloud Spanner.

Exécuter une requête

Pour exécuter une instruction de requête SQL sur une base de données, procédez comme suit :

SQL standard Google

C++

Utilisez ExecuteQuery() pour exécuter une instruction de requête SQL sur une base de données.

Afficher sur GitHub

void QueryData(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;

  spanner::SqlStatement select("SELECT SingerId, LastName FROM Singers");
  using RowType = std::tuple<std::int64_t, std::string>;
  auto rows = client.ExecuteQuery(std::move(select));
  for (auto& row : spanner::StreamOf<RowType>(rows)) {
    if (!row) throw std::move(row).status();
    std::cout << "SingerId: " << std::get<0>(*row) << "\t";
    std::cout << "LastName: " << std::get<1>(*row) << "\n";
  }

  std::cout << "Query completed for [spanner_query_data]\n";
}

C#

Utilisez ExecuteReaderAsync() pour interroger la base de données.

Afficher sur GitHub

using Google.Cloud.Spanner.Data;
using System.Collections.Generic;
using System.Threading.Tasks;

public class QuerySampleDataAsyncSample
{
    public class Album
    {
        public int SingerId { get; set; }
        public int AlbumId { get; set; }
        public string AlbumTitle { get; set; }
    }

    public async Task<List<Album>> QuerySampleDataAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";

        var albums = new List<Album>();
        using var connection = new SpannerConnection(connectionString);
        using var cmd = connection.CreateSelectCommand("SELECT SingerId, AlbumId, AlbumTitle FROM Albums");

        using var reader = await cmd.ExecuteReaderAsync();
        while (await reader.ReadAsync())
        {
            albums.Add(new Album
            {
                AlbumId = reader.GetFieldValue<int>("AlbumId"),
                SingerId = reader.GetFieldValue<int>("SingerId"),
                AlbumTitle = reader.GetFieldValue<string>("AlbumTitle")
            });
        }
        return albums;
    }
}

Go

Utilisez Client.Single().Query pour interroger la base de données.

Afficher sur GitHub

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
	"google.golang.org/api/iterator"
)

func query(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 SingerId, AlbumId, AlbumTitle FROM Albums`}
	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 singerID, albumID int64
		var albumTitle string
		if err := row.Columns(&singerID, &albumID, &albumTitle); err != nil {
			return err
		}
		fmt.Fprintf(w, "%d %d %s\n", singerID, albumID, albumTitle)
	}
}

Java

Utilisez ReadContext.executeQuery pour interroger la base de données.

Afficher sur GitHub

static void query(DatabaseClient dbClient) {
  try (ResultSet resultSet =
      dbClient
          .singleUse() // Execute a single read or query against Cloud Spanner.
          .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

Utilisez Database.run pour interroger la base de données.

Afficher sur GitHub

// 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 SingerId, AlbumId, AlbumTitle FROM Albums',
};

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

  rows.forEach(row => {
    const json = row.toJSON();
    console.log(
      `SingerId: ${json.SingerId}, AlbumId: ${json.AlbumId}, AlbumTitle: ${json.AlbumTitle}`
    );
  });
} catch (err) {
  console.error('ERROR:', err);
} finally {
  // Close the database when finished.
  await database.close();
}

PHP

Utilisez Database::execute pour interroger la base de données.

Afficher sur GitHub

use Google\Cloud\Spanner\SpannerClient;

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

    $results = $database->execute(
        'SELECT SingerId, AlbumId, AlbumTitle FROM Albums'
    );

    foreach ($results as $row) {
        printf('SingerId: %s, AlbumId: %s, AlbumTitle: %s' . PHP_EOL,
            $row['SingerId'], $row['AlbumId'], $row['AlbumTitle']);
    }
}

Python

Utilisez Database.execute_sql pour interroger la base de données.

Afficher sur GitHub

def query_data(instance_id, database_id):
    """Queries sample data from the database using SQL."""
    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 SingerId, AlbumId, AlbumTitle FROM Albums"
        )

        for row in results:
            print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))

Ruby

Utilisez Client#execute pour interroger la base de données.

Afficher sur GitHub

# 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

client.execute("SELECT SingerId, AlbumId, AlbumTitle FROM Albums").rows.each do |row|
  puts "#{row[:SingerId]} #{row[:AlbumId]} #{row[:AlbumTitle]}"
end

Pour créer une instruction SQL, consultez les documentations de référence de SQL sur la Syntaxe des requêtes et les Fonctions et opérateurs.

Effectuer une lecture forte

Pour effectuer une lecture forte de zéro ou plusieurs lignes d'une base de données, procédez comme suit.

SQL standard Google

C++

Le code permettant de lire les données est identique à l'exemple précédent permettant d'interroger Spanner en exécutant une requête SQL.

Afficher sur GitHub

void QueryData(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;

  spanner::SqlStatement select("SELECT SingerId, LastName FROM Singers");
  using RowType = std::tuple<std::int64_t, std::string>;
  auto rows = client.ExecuteQuery(std::move(select));
  for (auto& row : spanner::StreamOf<RowType>(rows)) {
    if (!row) throw std::move(row).status();
    std::cout << "SingerId: " << std::get<0>(*row) << "\t";
    std::cout << "LastName: " << std::get<1>(*row) << "\n";
  }

  std::cout << "Query completed for [spanner_query_data]\n";
}

C#

Le code permettant de lire les données est identique à l'exemple précédent permettant d'interroger Spanner en exécutant une requête SQL.

Afficher sur GitHub

using Google.Cloud.Spanner.Data;
using System.Collections.Generic;
using System.Threading.Tasks;

public class QuerySampleDataAsyncSample
{
    public class Album
    {
        public int SingerId { get; set; }
        public int AlbumId { get; set; }
        public string AlbumTitle { get; set; }
    }

    public async Task<List<Album>> QuerySampleDataAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";

        var albums = new List<Album>();
        using var connection = new SpannerConnection(connectionString);
        using var cmd = connection.CreateSelectCommand("SELECT SingerId, AlbumId, AlbumTitle FROM Albums");

        using var reader = await cmd.ExecuteReaderAsync();
        while (await reader.ReadAsync())
        {
            albums.Add(new Album
            {
                AlbumId = reader.GetFieldValue<int>("AlbumId"),
                SingerId = reader.GetFieldValue<int>("SingerId"),
                AlbumTitle = reader.GetFieldValue<string>("AlbumTitle")
            });
        }
        return albums;
    }
}

Go

Utilisez Client.Single().Read pour lire les lignes de la base de données.

Afficher sur GitHub

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
	"google.golang.org/api/iterator"
)

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

	iter := client.Single().Read(ctx, "Albums", spanner.AllKeys(),
		[]string{"SingerId", "AlbumId", "AlbumTitle"})
	defer iter.Stop()
	for {
		row, err := iter.Next()
		if err == iterator.Done {
			return nil
		}
		if err != nil {
			return err
		}
		var singerID, albumID int64
		var albumTitle string
		if err := row.Columns(&singerID, &albumID, &albumTitle); err != nil {
			return err
		}
		fmt.Fprintf(w, "%d %d %s\n", singerID, albumID, albumTitle)
	}
}

L'exemple utilise la valeur AllKeys pour définir une collection de clés ou de plages de clés à lire.

Java

Utilisez ReadContext.read pour lire les lignes de la base de données.

Afficher sur GitHub

static void read(DatabaseClient dbClient) {
  try (ResultSet resultSet =
      dbClient
          .singleUse()
          .read(
              "Albums",
              KeySet.all(), // Read all rows in a table.
              Arrays.asList("SingerId", "AlbumId", "AlbumTitle"))) {
    while (resultSet.next()) {
      System.out.printf(
          "%d %d %s\n", resultSet.getLong(0), resultSet.getLong(1), resultSet.getString(2));
    }
  }
}

L'exemple utilise la valeur KeySet pour définir une collection de clés ou de plages de clés à lire.

Node.js

Utilisez Table.read pour lire les lignes de la base de données.

Afficher sur GitHub

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

// Reads rows from the Albums table
const albumsTable = database.table('Albums');

const query = {
  columns: ['SingerId', 'AlbumId', 'AlbumTitle'],
  keySet: {
    all: true,
  },
};

try {
  const [rows] = await albumsTable.read(query);

  rows.forEach(row => {
    const json = row.toJSON();
    console.log(
      `SingerId: ${json.SingerId}, AlbumId: ${json.AlbumId}, AlbumTitle: ${json.AlbumTitle}`
    );
  });
} catch (err) {
  console.error('ERROR:', err);
} finally {
  // Close the database when finished.
  await database.close();
}

L'exemple utilise la valeur keySet pour définir une collection de clés ou de plages de clés à lire.

PHP

Utilisez Database::read pour lire les lignes de la base de données.

Afficher sur GitHub

use Google\Cloud\Spanner\SpannerClient;

/**
 * Reads sample data from the database.
 * Example:
 * ```
 * read_data($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function read_data(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $keySet = $spanner->keySet(['all' => true]);
    $results = $database->read(
        'Albums',
        $keySet,
        ['SingerId', 'AlbumId', 'AlbumTitle']
    );

    foreach ($results->rows() as $row) {
        printf('SingerId: %s, AlbumId: %s, AlbumTitle: %s' . PHP_EOL,
            $row['SingerId'], $row['AlbumId'], $row['AlbumTitle']);
    }
}

L'exemple utilise la valeur keySet pour définir une collection de clés ou de plages de clés à lire.

Python

Utilisez Database.read pour lire les lignes de la base de données.

Afficher sur GitHub

def read_data(instance_id, database_id):
    """Reads sample data from the database."""
    spanner_client = spanner.Client()
    instance = spanner_client.instance(instance_id)
    database = instance.database(database_id)

    with database.snapshot() as snapshot:
        keyset = spanner.KeySet(all_=True)
        results = snapshot.read(
            table="Albums", columns=("SingerId", "AlbumId", "AlbumTitle"), keyset=keyset
        )

        for row in results:
            print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))

L'exemple utilise la valeur KeySet pour définir une collection de clés ou de plages de clés à lire.

Ruby

Utilisez Client#read pour lire les lignes de la base de données.

Afficher sur GitHub

# 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

client.read("Albums", [:SingerId, :AlbumId, :AlbumTitle]).rows.each do |row|
  puts "#{row[:SingerId]} #{row[:AlbumId]} #{row[:AlbumTitle]}"
end

Effectuer une lecture non actualisée

L'exemple de code suivant montre comment effectuer une lecture non actualisée de zéro ou plusieurs lignes d'une base de données à l'aide d'une limite d'horodatage d'obsolescence exacte. Pour savoir comment effectuer une lecture non actualisée à l'aide d'un horodatage d'obsolescence limitée, consultez la remarque qui suit l'exemple de code. Pour en savoir plus sur les différents types de limites d'horodatage disponibles, consultez la section Limites d'horodatage.

SQL standard Google

C++

Utilisez ExecuteQuery() avec MakeReadOnlyTransaction() et Transaction::ReadOnlyOptions() pour effectuer une lecture non actualisée.

Afficher sur GitHub

void ReadStaleData(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;
  // The timestamp chosen using the `exact_staleness` parameter is bounded
  // below by the creation time of the database, so the visible state may only
  // include that generated by the `extra_statements` executed atomically with
  // the creation of the database. Here we at least know `Albums` exists.
  auto opts = spanner::Transaction::ReadOnlyOptions(std::chrono::seconds(15));
  auto read_only = spanner::MakeReadOnlyTransaction(std::move(opts));

  spanner::SqlStatement select(
      "SELECT SingerId, AlbumId, AlbumTitle FROM Albums");
  using RowType = std::tuple<std::int64_t, std::int64_t, std::string>;

  auto rows = client.ExecuteQuery(std::move(read_only), std::move(select));
  for (auto& row : spanner::StreamOf<RowType>(rows)) {
    if (!row) throw std::move(row).status();
    std::cout << "SingerId: " << std::get<0>(*row)
              << " AlbumId: " << std::get<1>(*row)
              << " AlbumTitle: " << std::get<2>(*row) << "\n";
  }
}

C#

Interrogez la base de données à l'aide de la méthode BeginReadOnlyTransactionAsync sur une connexion connection en spécifiant la valeur TimestampBound.OfExactStaleness().

Afficher sur GitHub

using Google.Cloud.Spanner.Data;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class ReadStaleDataAsyncSample
{
    public class Album
    {
        public int SingerId { get; set; }
        public int AlbumId { get; set; }
        public long? MarketingBudget { get; set; }
    }

    public async Task<List<Album>> ReadStaleDataAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";

        using var connection = new SpannerConnection(connectionString);
        await connection.OpenAsync();

        var staleness = TimestampBound.OfExactStaleness(TimeSpan.FromSeconds(15));
        using var transaction = await connection.BeginReadOnlyTransactionAsync(staleness);
        using var cmd = connection.CreateSelectCommand("SELECT SingerId, AlbumId, MarketingBudget FROM Albums");
        cmd.Transaction = transaction;

        var albums = new List<Album>();
        using var reader = await cmd.ExecuteReaderAsync();
        while (await reader.ReadAsync())
        {
            albums.Add(new Album
            {
                SingerId = reader.GetFieldValue<int>("SingerId"),
                AlbumId = reader.GetFieldValue<int>("AlbumId"),
                MarketingBudget = reader.IsDBNull(reader.GetOrdinal("MarketingBudget")) ? 0 : reader.GetFieldValue<long>("MarketingBudget")
            });
        }
        return albums;
    }
}

Remarque : Pour utiliser une limite d'horodatage d'obsolescence limitée, spécifiez la valeur TimestampBound.OfMaxStaleness() au lieu de la valeur TimestampBound.OfExactStaleness().

Go

Pour lire les lignes de la base de données à l'aide d'une limite d'horodatage d'obsolescence exacte, exécutez la requête Client.ReadOnlyTransaction().WithTimestampBound() et spécifiez la valeur ExactStaleness.

Afficher sur GitHub

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

	"cloud.google.com/go/spanner"
	"google.golang.org/api/iterator"
)

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

	ro := client.ReadOnlyTransaction().WithTimestampBound(spanner.ExactStaleness(15 * time.Second))
	defer ro.Close()

	iter := ro.Read(ctx, "Albums", spanner.AllKeys(), []string{"SingerId", "AlbumId", "AlbumTitle"})
	defer iter.Stop()
	for {
		row, err := iter.Next()
		if err == iterator.Done {
			return nil
		}
		if err != nil {
			return err
		}
		var singerID int64
		var albumID int64
		var albumTitle string
		if err := row.Columns(&singerID, &albumID, &albumTitle); err != nil {
			return err
		}
		fmt.Fprintf(w, "%d %d %s\n", singerID, albumID, albumTitle)
	}
}

L'exemple utilise la valeur AllKeys pour définir une collection de clés ou de plages de clés à lire.

Remarque:Pour utiliser une limite d'horodatage d'obsolescence limitée, spécifiez la valeur MaxStaleness au lieu de la valeur ExactStaleness.

Java

Pour lire les lignes d'une base de données à l'aide d'une limite d'horodatage d'obsolescence exacte, utilisez la méthode read de ReadContext et spécifiez la valeur TimestampBound.ofExactStaleness().

Afficher sur GitHub

static void readStaleData(DatabaseClient dbClient) {
  try (ResultSet resultSet =
      dbClient
          .singleUse(TimestampBound.ofExactStaleness(15, TimeUnit.SECONDS))
          .read(
              "Albums", KeySet.all(), Arrays.asList("SingerId", "AlbumId", "MarketingBudget"))) {
    while (resultSet.next()) {
      System.out.printf(
          "%d %d %s\n",
          resultSet.getLong(0),
          resultSet.getLong(1),
          resultSet.isNull(2) ? "NULL" : resultSet.getLong("MarketingBudget"));
    }
  }
}

L'exemple utilise la valeur KeySet pour définir une collection de clés ou de plages de clés à lire.

Remarque:Pour utiliser une limite d'horodatage d'obsolescence limitée, spécifiez TimestampBound.ofMaxStaleness au lieu d'un objet TimestampBound.ofExactStaleness().

Node.js

Pour lire les lignes de la base de données à l'aide d'une limite d'horodatage d'obsolescence exacte, utilisez Table.read avec l'option exactStaleness.

Afficher sur GitHub

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

// Reads rows from the Albums table
const albumsTable = database.table('Albums');

const query = {
  columns: ['SingerId', 'AlbumId', 'AlbumTitle', 'MarketingBudget'],
  keySet: {
    all: true,
  },
};

const options = {
  // Guarantees that all writes committed more than 15 seconds ago are visible
  exactStaleness: 15,
};

try {
  const [rows] = await albumsTable.read(query, options);

  rows.forEach(row => {
    const json = row.toJSON();
    const id = json.SingerId;
    const album = json.AlbumId;
    const title = json.AlbumTitle;
    const budget = json.MarketingBudget ? json.MarketingBudget : '';
    console.log(
      `SingerId: ${id}, AlbumId: ${album}, AlbumTitle: ${title}, MarketingBudget: ${budget}`
    );
  });
} catch (err) {
  console.error('ERROR:', err);
} finally {
  // Close the database when finished.
  await database.close();
}

L'exemple utilise la valeur keySet pour définir une collection de clés ou de plages de clés à lire.

Remarque:Pour utiliser une limite d'horodatage d'obsolescence limitée, utilisez l'option maxStaleness au lieu de l'option exactStaleness.

PHP

Pour lire les lignes de la base de données à l'aide d'une limite d'horodatage d'obsolescence exacte, utilisez Database::read en spécifiant la valeur exactStaleness.

Afficher sur GitHub

use Google\Cloud\Spanner\Duration;
use Google\Cloud\Spanner\SpannerClient;

/**
 * Reads sample data from the database.  The data is exactly 15 seconds stale.
 * Guarantees that all writes committed more than 15 seconds ago are visible.
 * Example:
 * ```
 * read_stale_data
 *($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function read_stale_data(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);
    $keySet = $spanner->keySet(['all' => true]);
    $results = $database->read(
        'Albums',
        $keySet,
        ['SingerId', 'AlbumId', 'AlbumTitle'],
        ['exactStaleness' => new Duration(15)]
    );

    foreach ($results->rows() as $row) {
        printf('SingerId: %s, AlbumId: %s, AlbumTitle: %s' . PHP_EOL,
            $row['SingerId'], $row['AlbumId'], $row['AlbumTitle']);
    }
}

L'exemple utilise la valeur keySet pour définir une collection de clés ou de plages de clés à lire.

Remarque:Pour utiliser une limite d'horodatage d'obsolescence limitée, spécifiez la valeur maxStaleness au lieu de la valeur exactStaleness.

Python

Pour lire les lignes d'une base de données à l'aide d'une limite d'horodatage d'obsolescence exacte, utilisez la méthode read de Database snapshot et spécifiez la valeur exact_staleness.

Afficher sur GitHub

def read_stale_data(instance_id, database_id):
    """Reads sample data from the database. The data is exactly 15 seconds
    stale."""
    import datetime

    spanner_client = spanner.Client()
    instance = spanner_client.instance(instance_id)
    database = instance.database(database_id)
    staleness = datetime.timedelta(seconds=15)

    with database.snapshot(exact_staleness=staleness) as snapshot:
        keyset = spanner.KeySet(all_=True)
        results = snapshot.read(
            table="Albums",
            columns=("SingerId", "AlbumId", "MarketingBudget"),
            keyset=keyset,
        )

        for row in results:
            print("SingerId: {}, AlbumId: {}, MarketingBudget: {}".format(*row))

L'exemple utilise la valeur KeySet pour définir une collection de clés ou de plages de clés à lire.

Remarque:Pour utiliser une limite d'horodatage d'obsolescence limitée, spécifiez la valeur max_staleness au lieu de la valeur exact_staleness.

Ruby

Pour lire les lignes d'une base de données à l'aide d'une limite d'horodatage d'obsolescence exacte, utilisez la méthode read de l'instantané Client et spécifiez la valeur staleness (en secondes).

Afficher sur GitHub

# 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

# Perform a read with a data staleness of 15 seconds
client.snapshot staleness: 15 do |snapshot|
  snapshot.read("Albums", [:SingerId, :AlbumId, :AlbumTitle]).rows.each do |row|
    puts "#{row[:SingerId]} #{row[:AlbumId]} #{row[:AlbumTitle]}"
  end
end

Remarque:Pour utiliser une limite d'horodatage d'obsolescence limitée, utilisez l'exemple de code afin d'effectuer une lecture forte, mais spécifiez également un paramètre single_use: avec la valeur {max_staleness: [n seconds]} pour être lu avec une obsolescence de [n seconds].

Effectuer une lecture à l'aide d'un index

Pour lire zéro ou plusieurs lignes d'une base de données à l'aide d'un index, procédez comme suit.

SQL standard Google

C++

Utilisez la fonction Read() pour effectuer une lecture à l'aide d'un index.

Afficher sur GitHub

void ReadDataWithIndex(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;

  auto rows =
      client.Read("Albums", google::cloud::spanner::KeySet::All(),
                  {"AlbumId", "AlbumTitle"},
                  google::cloud::Options{}.set<spanner::ReadIndexNameOption>(
                      "AlbumsByAlbumTitle"));
  using RowType = std::tuple<std::int64_t, std::string>;
  for (auto& row : spanner::StreamOf<RowType>(rows)) {
    if (!row) throw std::move(row).status();
    std::cout << "AlbumId: " << std::get<0>(*row) << "\t";
    std::cout << "AlbumTitle: " << std::get<1>(*row) << "\n";
  }
  std::cout << "Read completed for [spanner_read_data_with_index]\n";
}

C#

Lisez des données à l'aide de l'index en exécutant une requête qui spécifie explicitement l'index :

Afficher sur GitHub

using Google.Cloud.Spanner.Data;
using System.Collections.Generic;
using System.Threading.Tasks;

public class QueryDataWithIndexAsyncSample
{
    public class Album
    {
        public int AlbumId { get; set; }
        public string AlbumTitle { get; set; }
        public long MarketingBudget { get; set; }
    }

    public async Task<List<Album>> QueryDataWithIndexAsync(string projectId, string instanceId, string databaseId,
        string startTitle, string endTitle)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
        using var connection = new SpannerConnection(connectionString);
        using var cmd = connection.CreateSelectCommand(
            "SELECT AlbumId, AlbumTitle, MarketingBudget FROM Albums@ "
            + "{FORCE_INDEX=AlbumsByAlbumTitle} "
            + $"WHERE AlbumTitle >= @startTitle "
            + $"AND AlbumTitle < @endTitle",
            new SpannerParameterCollection
            {
                { "startTitle", SpannerDbType.String, startTitle },
                { "endTitle", SpannerDbType.String, endTitle }
            });

        var albums = new List<Album>();
        using var reader = await cmd.ExecuteReaderAsync();
        while (await reader.ReadAsync())
        {
            albums.Add(new Album
            {
                AlbumId = reader.GetFieldValue<int>("AlbumId"),
                AlbumTitle = reader.GetFieldValue<string>("AlbumTitle"),
                MarketingBudget = reader.IsDBNull(reader.GetOrdinal("MarketingBudget")) ? 0 : reader.GetFieldValue<long>("MarketingBudget")
            });
        }
        return albums;
    }
}

Go

Pour lire les lignes de la base de données à l'aide d'un index, exécutez la requête Client.Single().ReadUsingIndex.

Afficher sur GitHub

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
	"google.golang.org/api/iterator"
)

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

	iter := client.Single().ReadUsingIndex(ctx, "Albums", "AlbumsByAlbumTitle", spanner.AllKeys(),
		[]string{"AlbumId", "AlbumTitle"})
	defer iter.Stop()
	for {
		row, err := iter.Next()
		if err == iterator.Done {
			return nil
		}
		if err != nil {
			return err
		}
		var albumID int64
		var albumTitle string
		if err := row.Columns(&albumID, &albumTitle); err != nil {
			return err
		}
		fmt.Fprintf(w, "%d %s\n", albumID, albumTitle)
	}
}

Java

Pour lire les lignes de la base de données à l'aide d'un index, exécutez la requête ReadContext.readUsingIndex.

Afficher sur GitHub

static void readUsingIndex(DatabaseClient dbClient) {
  try (ResultSet resultSet =
      dbClient
          .singleUse()
          .readUsingIndex(
              "Albums",
              "AlbumsByAlbumTitle",
              KeySet.all(),
              Arrays.asList("AlbumId", "AlbumTitle"))) {
    while (resultSet.next()) {
      System.out.printf("%d %s\n", resultSet.getLong(0), resultSet.getString(1));
    }
  }
}

Node.js

Pour lire les lignes de la base de données à l'aide d'un index, exécutez la requête Table.read en y spécifiant l'index.

Afficher sur GitHub

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

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

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

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

  const albumsTable = database.table('Albums');

  const query = {
    columns: ['AlbumId', 'AlbumTitle'],
    keySet: {
      all: true,
    },
    index: 'AlbumsByAlbumTitle',
  };

  // Reads the Albums table using an index
  try {
    const [rows] = await albumsTable.read(query);

    rows.forEach(row => {
      const json = row.toJSON();
      console.log(`AlbumId: ${json.AlbumId}, AlbumTitle: ${json.AlbumTitle}`);
    });
  } catch (err) {
    console.error('ERROR:', err);
  } finally {
    // Close the database when finished.
    database.close();
  }
}
readDataWithIndex();

PHP

Pour lire les lignes de la base de données à l'aide d'un index, exécutez la requête Database::read en y spécifiant l'index.

Afficher sur GitHub

use Google\Cloud\Spanner\SpannerClient;

/**
 * Reads sample data from the database using an index.
 *
 * The index must exist before running this sample. You can add the index
 * by running the `add_index` sample or by running this DDL statement against
 * your database:
 *
 *     CREATE INDEX AlbumsByAlbumTitle ON Albums(AlbumTitle)
 *
 * Example:
 * ```
 * read_data_with_index($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function read_data_with_index(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $keySet = $spanner->keySet(['all' => true]);
    $results = $database->read(
        'Albums',
        $keySet,
        ['AlbumId', 'AlbumTitle'],
        ['index' => 'AlbumsByAlbumTitle']
    );

    foreach ($results->rows() as $row) {
        printf('AlbumId: %s, AlbumTitle: %s' . PHP_EOL,
            $row['AlbumId'], $row['AlbumTitle']);
    }
}

Python

Pour lire les lignes de la base de données à l'aide d'un index, exécutez la requête Database.read en y spécifiant l'index.

Afficher sur GitHub

def read_data_with_index(instance_id, database_id):
    """Reads sample data from the database using an index.

    The index must exist before running this sample. You can add the index
    by running the `add_index` sample or by running this DDL statement against
    your database:

        CREATE INDEX AlbumsByAlbumTitle ON Albums(AlbumTitle)

    """
    spanner_client = spanner.Client()
    instance = spanner_client.instance(instance_id)
    database = instance.database(database_id)

    with database.snapshot() as snapshot:
        keyset = spanner.KeySet(all_=True)
        results = snapshot.read(
            table="Albums",
            columns=("AlbumId", "AlbumTitle"),
            keyset=keyset,
            index="AlbumsByAlbumTitle",
        )

        for row in results:
            print("AlbumId: {}, AlbumTitle: {}".format(*row))

Ruby

Pour lire les lignes de la base de données à l'aide d'un index, exécutez la requête Client#read en y spécifiant l'index.

Afficher sur GitHub

# 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

result = client.read "Albums", [:AlbumId, :AlbumTitle],
                     index: "AlbumsByAlbumTitle"

result.rows.each do |row|
  puts "#{row[:AlbumId]} #{row[:AlbumTitle]}"
end

Lire des données en parallèle

Lorsque vous effectuez des opérations de lecture ou de requête groupées impliquant de très grandes quantités de données à partir de Spanner, vous pouvez utiliser l'API PartitionQuery pour obtenir des résultats plus rapidement. L'API divise la requête en parties plus petites, ou partitions, en utilisant plusieurs machines pour récupérer les partitions en parallèle. Notez que l'utilisation de l'API PartitionQuery aura une latence plus élevée, car elle n'est destinée qu'aux opérations groupées, telles que l'exportation ou l'analyse de l'intégralité de la base de données.

Vous pouvez effectuer toute opération d'API de lecture en parallèle à l'aide des bibliothèques clientes Spanner. Toutefois, vous ne pouvez partitionner les requêtes SQL que si le premier opérateur du plan d'exécution de la requête est une union distribuée. Pour afficher le plan d'exécution d'une requête SQL en particulier, suivez les instructions de la section Bonnes pratiques relatives aux instructions SQL.

Une fois que vous disposez du plan d'exécution de la requête, assurez-vous que le premier opérateur est une union distribuée.

Remarque : Les exemples suivants fonctionnent avec la définition de table LDD du guide de démarrage rapide.

SQL standard Google

C++

Cet exemple extrait les partitions d'une requête SQL de la table Singers et exécute la requête sur chaque partition en procédant comme suit:

• Créer une transaction par lot Spanner
• Création de partitions pour la requête, afin que les partitions puissent être réparties sur plusieurs nœuds de calcul
• Extraction des résultats de la requête pour chaque partition

Remarque : Par souci de simplicité, l'exemple extrait toutes les partitions de plusieurs tâches parallèles au sein d'un même processus. Dans les cas d'utilisation réels, vous devez répartir les partitions sur les nœuds de calcul de différentes machines pour une efficacité optimale.

Afficher sur GitHub

void UsePartitionQuery(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;
  auto txn = spanner::MakeReadOnlyTransaction();

  spanner::SqlStatement select(
      "SELECT SingerId, FirstName, LastName FROM Singers");
  using RowType = std::tuple<std::int64_t, std::string, std::string>;

  auto partitions =
      client.PartitionQuery(std::move(txn), std::move(select), {});
  if (!partitions) throw std::move(partitions).status();
  int number_of_rows = 0;
  for (auto const& partition : *partitions) {
    auto rows = client.ExecuteQuery(partition);
    for (auto& row : spanner::StreamOf<RowType>(rows)) {
      if (!row) throw std::move(row).status();
      number_of_rows++;
    }
  }
  std::cout << "Number of partitions: " << partitions->size() << "\n"
            << "Number of rows: " << number_of_rows << "\n";
  std::cout << "Read completed for [spanner_batch_client]\n";
}

C#

Cet exemple extrait les partitions d'une requête SQL de la table Singers et exécute la requête sur chaque partition en procédant comme suit:

• Créer une transaction par lot Spanner
• Création de partitions pour la requête, afin que les partitions puissent être réparties sur plusieurs nœuds de calcul
• Extraction des résultats de la requête pour chaque partition

Remarque : Par souci de simplicité, l'exemple extrait toutes les partitions de plusieurs tâches parallèles au sein d'un même processus. Dans les cas d'utilisation réels, vous devez répartir les partitions sur les nœuds de calcul de différentes machines pour une efficacité optimale.

Afficher sur GitHub

using Google.Cloud.Spanner.Data;
using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

public class BatchReadRecordsAsyncSample
{
    private int _rowsRead;
    private int _partitionCount;
    public async Task<(int RowsRead, int Partitions)> BatchReadRecordsAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
        using var connection = new SpannerConnection(connectionString);
        await connection.OpenAsync();

        using var transaction = await connection.BeginReadOnlyTransactionAsync();
        transaction.DisposeBehavior = DisposeBehavior.CloseResources;
        using var cmd = connection.CreateSelectCommand("SELECT SingerId, FirstName, LastName FROM Singers");
        cmd.Transaction = transaction;
        var partitions = await cmd.GetReaderPartitionsAsync();
        var transactionId = transaction.TransactionId;
        await Task.WhenAll(partitions.Select(x => DistributedReadWorkerAsync(x, transactionId)));
        Console.WriteLine($"Done reading!  Total rows read: {_rowsRead:N0} with {_partitionCount} partition(s)");
        return (RowsRead: _rowsRead, Partitions: _partitionCount);
    }

    private async Task DistributedReadWorkerAsync(CommandPartition readPartition, TransactionId id)
    {
        var localId = Interlocked.Increment(ref _partitionCount);
        using var connection = new SpannerConnection(id.ConnectionString);
        using var transaction = connection.BeginReadOnlyTransaction(id);
        using var cmd = connection.CreateCommandWithPartition(readPartition, transaction);
        using var reader = await cmd.ExecuteReaderAsync();
        while (await reader.ReadAsync())
        {
            Interlocked.Increment(ref _rowsRead);
            Console.WriteLine($"Partition ({localId}) "
                + $"{reader.GetFieldValue<int>("SingerId")}"
                + $" {reader.GetFieldValue<string>("FirstName")}"
                + $" {reader.GetFieldValue<string>("LastName")}");
        }
        Console.WriteLine($"Done with single reader {localId}.");
    }
}

Go

Cet exemple extrait les partitions d'une requête SQL de la table Singers et exécute la requête sur chaque partition en procédant comme suit:

• Créer un client Spanner et une transaction
• Création de partitions pour la requête, afin que les partitions puissent être réparties sur plusieurs nœuds de calcul
• Extraction des résultats de la requête pour chaque partition

Remarque : Par souci de simplicité, l'exemple extrait toutes les partitions d'une seule machine et les exécute pour extraire les résultats. Si vous avez plusieurs processeurs disponibles, il est possible d'exécuter les partitions en parallèle. Dans les cas d'utilisation réels, vous devez répartir les partitions sur les nœuds de calcul de différentes machines pour une efficacité optimale.

Afficher sur GitHub

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
	"google.golang.org/api/iterator"
)

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

	txn, err := client.BatchReadOnlyTransaction(ctx, spanner.StrongRead())
	if err != nil {
		return err
	}
	defer txn.Close()

	// Singer represents a row in the Singers table.
	type Singer struct {
		SingerID   int64
		FirstName  string
		LastName   string
		SingerInfo []byte
	}
	stmt := spanner.Statement{SQL: "SELECT SingerId, FirstName, LastName FROM Singers;"}
	partitions, err := txn.PartitionQuery(ctx, stmt, spanner.PartitionOptions{})
	if err != nil {
		return err
	}
	recordCount := 0
	for i, p := range partitions {
		iter := txn.Execute(ctx, p)
		defer iter.Stop()
		for {
			row, err := iter.Next()
			if err == iterator.Done {
				break
			} else if err != nil {
				return err
			}
			var s Singer
			if err := row.ToStruct(&s); err != nil {
				return err
			}
			fmt.Fprintf(w, "Partition (%d) %v\n", i, s)
			recordCount++
		}
	}
	fmt.Fprintf(w, "Total partition count: %v\n", len(partitions))
	fmt.Fprintf(w, "Total record count: %v\n", recordCount)
	return nil
}

Java

Cet exemple extrait les partitions d'une requête SQL de la table Singers et exécute la requête sur chaque partition en procédant comme suit:

• Créer un client par lot Spanner et une transaction
• Création de partitions pour la requête, afin que les partitions puissent être réparties sur plusieurs nœuds de calcul
• Extraction des résultats de la requête pour chaque partition

Remarque : Par souci de simplicité, l'exemple extrait toutes les partitions d'une seule machine en exécutant plusieurs tâches en parallèle si vous disposez de plusieurs processeurs. Dans les cas d'utilisation réels, vous devez répartir les partitions sur les nœuds de calcul de différentes machines pour une efficacité optimale.

Afficher sur GitHub

int numThreads = Runtime.getRuntime().availableProcessors();
ExecutorService executor = Executors.newFixedThreadPool(numThreads);

// Statistics
int totalPartitions;
AtomicInteger totalRecords = new AtomicInteger(0);

try {
  BatchClient batchClient =
      spanner.getBatchClient(DatabaseId.of(options.getProjectId(), instanceId, databaseId));

  final BatchReadOnlyTransaction txn =
      batchClient.batchReadOnlyTransaction(TimestampBound.strong());

  // A Partition object is serializable and can be used from a different process.
  List<Partition> partitions =
      txn.partitionQuery(
          PartitionOptions.getDefaultInstance(),
          Statement.of("SELECT SingerId, FirstName, LastName FROM Singers"));

  totalPartitions = partitions.size();

  for (final Partition p : partitions) {
    executor.execute(
        () -> {
          try (ResultSet results = txn.execute(p)) {
            while (results.next()) {
              long singerId = results.getLong(0);
              String firstName = results.getString(1);
              String lastName = results.getString(2);
              System.out.println("[" + singerId + "] " + firstName + " " + lastName);
              totalRecords.getAndIncrement();
            }
          }
        });
  }
} finally {
  executor.shutdown();
  executor.awaitTermination(1, TimeUnit.HOURS);
  spanner.close();
}

double avgRecordsPerPartition = 0.0;
if (totalPartitions != 0) {
  avgRecordsPerPartition = (double) totalRecords.get() / totalPartitions;
}
System.out.println("totalPartitions=" + totalPartitions);
System.out.println("totalRecords=" + totalRecords);
System.out.println("avgRecordsPerPartition=" + avgRecordsPerPartition);

Node.js

Cet exemple extrait les partitions d'une requête SQL de la table Singers et exécute la requête sur chaque partition en procédant comme suit:

• Créer un client Spanner et un lot
• Création de partitions pour la requête, afin que les partitions puissent être réparties sur plusieurs nœuds de calcul
• Extraction des résultats de la requête pour chaque partition

Remarque : Par souci de simplicité, l'exemple extrait toutes les partitions d'une seule machine en exécutant plusieurs tâches en parallèle si vous disposez de plusieurs processeurs. Dans les cas d'utilisation réels, vous devez répartir les partitions sur les nœuds de calcul de différentes machines pour une efficacité optimale.

Afficher sur GitHub

// 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 [transaction] = await database.createBatchTransaction();

const query = 'SELECT * FROM Singers';

const [partitions] = await transaction.createQueryPartitions(query);
console.log(`Successfully created ${partitions.length} query partitions.`);

let row_count = 0;
const promises = [];
partitions.forEach(partition => {
  promises.push(
    transaction.execute(partition).then(results => {
      const rows = results[0].map(row => row.toJSON());
      row_count += rows.length;
    })
  );
});
Promise.all(promises)
  .then(() => {
    console.log(
      `Successfully received ${row_count} from executed partitions.`
    );
    transaction.close();
  })
  .then(() => {
    database.close();
  });

PHP

Cet exemple extrait les partitions d'une requête SQL de la table Singers et exécute la requête sur chaque partition en procédant comme suit:

• Créer un client Spanner et un lot
• Création de partitions pour la requête, afin que les partitions puissent être réparties sur plusieurs nœuds de calcul
• Extraction des résultats de la requête pour chaque partition

Remarque : Par souci de simplicité, l'exemple extrait toutes les partitions d'une seule machine et les exécute pour extraire les résultats. Si vous avez plusieurs processeurs disponibles, il est possible d'exécuter les partitions en parallèle. Dans les cas d'utilisation réels, vous devez répartir les partitions sur les nœuds de calcul de différentes machines pour une efficacité optimale.

Afficher sur GitHub

use Google\Cloud\Spanner\SpannerClient;

/**
 * Queries sample data from the database using SQL.
 * Example:
 * ```
 * batch_query_data($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function batch_query_data(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $batch = $spanner->batch($instanceId, $databaseId);
    $snapshot = $batch->snapshot();
    $queryString = 'SELECT SingerId, FirstName, LastName FROM Singers';
    $partitions = $snapshot->partitionQuery($queryString);
    $totalPartitions = count($partitions);
    $totalRecords = 0;
    foreach ($partitions as $partition) {
        $result = $snapshot->executePartition($partition);
        $rows = $result->rows();
        foreach ($rows as $row) {
            $singerId = $row['SingerId'];
            $firstName = $row['FirstName'];
            $lastName = $row['LastName'];
            printf('SingerId: %s, FirstName: %s, LastName: %s' . PHP_EOL, $singerId, $firstName, $lastName);
            $totalRecords++;
        }
    }
    printf('Total Partitions: %d' . PHP_EOL, $totalPartitions);
    printf('Total Records: %d' . PHP_EOL, $totalRecords);
    $averageRecordsPerPartition = $totalRecords / $totalPartitions;
    printf('Average Records Per Partition: %f' . PHP_EOL, $averageRecordsPerPartition);
}

Python

Cet exemple extrait les partitions d'une requête SQL de la table Singers et exécute la requête sur chaque partition en procédant comme suit:

• Créer un client Spanner et une transaction par lot
• Création de partitions pour la requête, afin que les partitions puissent être réparties sur plusieurs nœuds de calcul
• Extraction des résultats de la requête pour chaque partition

Remarque : Par souci de simplicité, l'exemple extrait toutes les partitions d'une seule machine en exécutant plusieurs tâches en parallèle si vous disposez de plusieurs processeurs. Dans les cas d'utilisation réels, vous devez répartir les partitions sur les nœuds de calcul de différentes machines pour une efficacité optimale.

Afficher sur GitHub

def run_batch_query(instance_id, database_id):
    """Runs an example batch query."""

    # Expected Table Format:
    # CREATE TABLE Singers (
    #   SingerId   INT64 NOT NULL,
    #   FirstName  STRING(1024),
    #   LastName   STRING(1024),
    #   SingerInfo BYTES(MAX),
    # ) PRIMARY KEY (SingerId);

    spanner_client = spanner.Client()
    instance = spanner_client.instance(instance_id)
    database = instance.database(database_id)

    # Create the batch transaction and generate partitions
    snapshot = database.batch_snapshot()
    partitions = snapshot.generate_read_batches(
        table="Singers",
        columns=("SingerId", "FirstName", "LastName"),
        keyset=spanner.KeySet(all_=True),
    )

    # Create a pool of workers for the tasks
    start = time.time()
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = [executor.submit(process, snapshot, p) for p in partitions]

        for future in concurrent.futures.as_completed(futures, timeout=3600):
            finish, row_ct = future.result()
            elapsed = finish - start
            print("Completed {} rows in {} seconds".format(row_ct, elapsed))

    # Clean up
    snapshot.close()

def process(snapshot, partition):
    """Processes the requests of a query in an separate process."""
    print("Started processing partition.")
    row_ct = 0
    for row in snapshot.process_read_batch(partition):
        print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
        row_ct += 1
    return time.time(), row_ct

Ruby

Cet exemple extrait les partitions d'une requête SQL de la table Singers et exécute la requête sur chaque partition en procédant comme suit:

• Créer un client par lot Spanner
• Création de partitions pour la requête, afin que les partitions puissent être réparties sur plusieurs nœuds de calcul
• Extraction des résultats de la requête pour chaque partition

Remarque : Par souci de simplicité, l'exemple extrait toutes les partitions d'une seule machine en exécutant plusieurs tâches en parallèle si vous disposez de plusieurs processeurs. Dans les cas d'utilisation réels, vous devez répartir les partitions sur les nœuds de calcul de différentes machines pour une efficacité optimale.

Afficher sur GitHub

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

require "google/cloud/spanner"

# Prepare a thread pool with number of processors
processor_count  = Concurrent.processor_count
thread_pool      = Concurrent::FixedThreadPool.new processor_count

# Prepare AtomicFixnum to count total records using multiple threads
total_records = Concurrent::AtomicFixnum.new

# Create a new Spanner batch client
spanner        = Google::Cloud::Spanner.new project: project_id
batch_client   = spanner.batch_client instance_id, database_id

# Get a strong timestamp bound batch_snapshot
batch_snapshot = batch_client.batch_snapshot strong: true

# Get partitions for specified query
partitions       = batch_snapshot.partition_query "SELECT SingerId, FirstName, LastName FROM Singers"
total_partitions = partitions.size

# Enqueue a new thread pool job
partitions.each_with_index do |partition, _partition_index|
  thread_pool.post do
    # Increment total_records per new row
    batch_snapshot.execute_partition(partition).rows.each do |_row|
      total_records.increment
    end
  end
end

# Wait for queued jobs to complete
thread_pool.shutdown
thread_pool.wait_for_termination

# Close the client connection and release resources.
batch_snapshot.close

# Collect statistics for batch query
average_records_per_partition = 0.0
if total_partitions != 0
  average_records_per_partition = total_records.value / total_partitions.to_f
end

puts "Total Partitions: #{total_partitions}"
puts "Total Records: #{total_records.value}"
puts "Average records per Partition: #{average_records_per_partition}"