Lecture

Cette page décrit le processus de lecture dans Cloud Spanner hors du contexte des transactions en lecture seule et en 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

Cloud 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. Cloud Spanner se sert par défaut des lectures fortes pour répondre aux 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. Pour déterminer cette limite, suivez les bonnes pratiques ci-dessous :

• Choisissez des lectures fortes autant que possible. Il s'agit de la limite d'horodatage par défaut pour les lectures Cloud 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 Cloud 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

Cloud Spanner propose des méthodes de lecture unique (lecture hors du contexte d'une transaction) sur une base de données pour :

• exécuter la lecture sous forme d'une instruction de requête SQL ou à l'aide de l'API de lecture de Cloud 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 :

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

string connectionString =
$"Data Source=projects/{projectId}/instances/"
+ $"{instanceId}/databases/{databaseId}";
// Create connection to Cloud Spanner.
using (var connection = new SpannerConnection(connectionString))
{
    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

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($instanceId, $databaseId)
{
    $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(u"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.

C++

Le code permettant de lire les données est identique à l'exemple précédent sur l'interrogation de Cloud Spanner à l'aide d'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 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 << "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 sur l'interrogation de Cloud Spanner à l'aide d'une requête SQL.

Afficher sur GitHub

string connectionString =
$"Data Source=projects/{projectId}/instances/"
+ $"{instanceId}/databases/{databaseId}";
// Create connection to Cloud Spanner.
using (var connection = new SpannerConnection(connectionString))
{
    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

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($instanceId, $databaseId)
{
    $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(u"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.

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;
  auto opts = spanner::Transaction::ReadOnlyOptions(std::chrono::seconds(15));
  auto read_only = spanner::MakeReadOnlyTransaction(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(read_only, select);
  for (auto const& row : spanner::StreamOf<RowType>(rows)) {
    if (!row) throw std::runtime_error(row.status().message());
    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

string connectionString =
    $"Data Source=projects/{projectId}/instances/{instanceId}"
    + $"/databases/{databaseId}";

// Create connection to Cloud Spanner.
using (var connection = new SpannerConnection(connectionString))
{
    await connection.OpenAsync();

    // Open a new read only transaction.
    var staleness = TimestampBound.OfExactStaleness(
        TimeSpan.FromSeconds(15));
    using (var transaction =
        await connection.BeginReadOnlyTransactionAsync(staleness))
    {
        var cmd = connection.CreateSelectCommand(
            "SELECT SingerId, AlbumId, AlbumTitle FROM Albums");
        cmd.Transaction = transaction;

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

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 la valeur TimestampBound.ofMaxStaleness au lieu de la valeur 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, spécifiez 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($instanceId, $databaseId)
{
    $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(u"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, servez-vous de l'exemple de code pour effectuer une lecture forte, en y ajoutant un paramètre single_use: avec une valeur de {max_staleness: [n seconds]} en vue d'une lecture 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.

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;

  spanner::ReadOptions read_options;
  read_options.index_name = "AlbumsByAlbumTitle";
  auto rows = client.Read("Albums", google::cloud::spanner::KeySet::All(),
                          {"AlbumId", "AlbumTitle"}, read_options);
  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 << "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

string connectionString =
$"Data Source=projects/{projectId}/instances/{instanceId}"
+ $"/databases/{databaseId}";
// Create connection to Cloud Spanner.
using (var connection = new SpannerConnection(connectionString))
{
    var cmd = connection.CreateSelectCommand(
        "SELECT AlbumId, AlbumTitle, MarketingBudget FROM Albums@ "
        + "{FORCE_INDEX=AlbumsByAlbumTitle} "
        + $"WHERE AlbumTitle >= @startTitle "
        + $"AND AlbumTitle < @endTitle",
        new SpannerParameterCollection {
            {"startTitle", SpannerDbType.String},
            {"endTitle", SpannerDbType.String} });
    cmd.Parameters["startTitle"].Value = startTitle;
    cmd.Parameters["endTitle"].Value = endTitle;
    using (var reader = await cmd.ExecuteReaderAsync())
    {
        while (await reader.ReadAsync())
        {
            var marketingBudget = reader.IsDBNull(
                reader.GetOrdinal("MarketingBudget")) ?
                "" :
                reader.GetFieldValue<string>("MarketingBudget");
            Console.WriteLine("AlbumId : "
            + reader.GetFieldValue<string>("AlbumId")
            + " AlbumTitle : "
            + reader.GetFieldValue<string>("AlbumTitle")
            + " MarketingBudget : "
            + marketingBudget);
        }
    }
}

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

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

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($instanceId, $databaseId)
{
    $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 d'interrogation groupées impliquant de très grandes quantités de données issues de Cloud 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. Sachez que l'utilisation de l'API PartitionQuery offre une latence plus élevée, car elle n'est conçue que pour les opérations groupées, par exemple pour l'exportation ou l'analyse de la base de données entière.

Vous pouvez effectuer n'importe quelle opération d'API de lecture en parallèle à l'aide des bibliothèques clientes de Cloud Spanner. Cependant, vous ne pouvez partitionner les requêtes SQL que dans le cas où 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 des requêtes, assurez-vous que le premier opérateur qu'il contient est une union distribuée.

Remarque : Les exemples suivants fonctionnent avec la définition de table DDL disponible dans le guide de démarrage rapide.

C++

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

• Création d'une transaction par lots Cloud 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), select, {});
  if (!partitions) throw std::runtime_error(partitions.status().message());
  int number_of_rows = 0;
  for (auto const& partition : *partitions) {
    auto rows = client.ExecuteQuery(partition);
    for (auto const& row : spanner::StreamOf<RowType>(rows)) {
      if (!row) throw std::runtime_error(row.status().message());
      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 dans la table Singers et exécute la requête sur chaque partition en procédant comme suit :

• Création d'une transaction par lots Cloud 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

private static int s_partitionId;
private static int s_rowsRead;
public static object BatchReadRecords(string projectId,
     string instanceId, string databaseId)
{
    var responseTask =
        DistributedReadAsync(projectId, instanceId, databaseId);
    Console.WriteLine("Waiting for operation to complete...");
    responseTask.Wait();
    Console.WriteLine($"Operation status: {responseTask.Status}");
    return ExitCode.Success;
}

private static async Task DistributedReadAsync(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())
        using (var cmd =
            connection.CreateSelectCommand(
                "SELECT SingerId, FirstName, LastName FROM Singers"))
        {
            transaction.DisposeBehavior =
                DisposeBehavior.CloseResources;
            cmd.Transaction = transaction;
            var partitions = await cmd.GetReaderPartitionsAsync();
            var transactionId = transaction.TransactionId;
            await Task.WhenAll(partitions.Select(
                    x => DistributedReadWorkerAsync(x, transactionId)))
                        .ConfigureAwait(false);
        }
        Console.WriteLine($"Done reading!  Total rows read: "
            + $"{s_rowsRead:N0} with {s_partitionId} partition(s)");
    }
}

private static async Task DistributedReadWorkerAsync(
    CommandPartition readPartition, TransactionId id)
{
    var localId = Interlocked.Increment(ref s_partitionId);
    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().ConfigureAwait(false))
            {
                while (await reader.ReadAsync())
                {
                    Interlocked.Increment(ref s_rowsRead);
                    Console.WriteLine($"Partition ({localId}) "
                        + $"{reader.GetFieldValue<string>("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 dans la table Singers et exécute la requête sur chaque partition en procédant comme suit :

• Création d'un client Cloud Spanner et d'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 dans la table Singers et exécute la requête sur chaque partition en procédant comme suit :

• Création d'un client par lots Cloud Spanner et d'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 dans la table Singers et exécute la requête sur chaque partition en procédant comme suit :

• Création d'un client Cloud Spanner et d'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 dans la table Singers et exécute la requête sur chaque partition en procédant comme suit :

• Création d'un client Cloud Spanner et d'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($instanceId, $databaseId)
{
    $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 dans la table Singers et exécute la requête sur chaque partition en procédant comme suit :

• Création d'un client Cloud Spanner et d'une transaction par lots
• 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(u"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(u"SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
        row_ct += 1
    return time.time(), row_ct

Ruby

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

• Création d'un client par lots Cloud 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}"