Lesevorgänge außerhalb von Transaktionen

Auf dieser Seite wird beschrieben, wie Sie in Spanner Lesevorgänge außerhalb des Kontexts von schreibgeschützten Transaktionen und Lese-Schreib-Transaktionen ausführen. Wenn eine der folgenden Situationen zutrifft, lesen Sie stattdessen die Seite „Transaktionen“:

• Wenn Sie einen Schreibvorgang ausführen müssen, der vom Wert von einem oder mehreren Lesevorgängen abhängt, sollten Sie den Lesevorgang als Bestandteil einer Lese-Schreib-Transaktion ausführen. Weitere Informationen finden Sie unter Lese-Schreib-Transaktionen.

• Wenn Sie mehrere Leseaufrufe durchführen, für die eine konsistente Datensicht erforderlich ist, sollten Sie die Lesevorgänge als Bestandteil einer schreibgeschützten Transaktion ausführen. Weitere Informationen finden Sie unter schreibgeschützte Transaktionen.

Lesetypen

Spanner bietet Ihnen zwei Typen von Lesevorgängen, um festzulegen, wie aktuell die Daten beim Lesen sein sollen:

• Ein starker Lesevorgang ist ein Lesevorgang zu einem aktuellen Zeitstempel, der garantiert alle Daten erfasst, die bis zum Beginn dieses Lesevorgangs mit einem Commit festgeschrieben wurden. Spanner verwendet standardmäßig starke Lesevorgänge, um Leseanfragen zu bedienen.
• Ein veralteter Lesevorgang erfasst Daten an einem Zeitpunkt (Zeitstempel) in der Vergangenheit. Wenn Ihre Anwendung latenzabhängig ist, aber veraltete Daten toleriert, können veraltete Lesevorgänge Leistungsvorteile bieten.

Legen Sie eine Zeitstempelgrenze für die Leseanforderung fest, um die gewünschte Art von Lesevorgang auszuwählen. Beachten Sie bei der Auswahl einer Zeitstempelgrenze die folgenden Best Practices:

• Wählen Sie nach Möglichkeit starke Lesevorgänge. Dies ist die standardmäßige Zeitstempelgrenze für Spanner-Lesevorgänge, einschließlich schreibgeschützter Transaktionen. Starke Lesevorgänge berücksichtigen garantiert die Auswirkungen aller Transaktionen, die vor dem Start des Lesevorgangs durchgeführt wurden, unabhängig davon, bei welchem Replikat der Lesevorgang eingeht. Aus diesem Grund machen starke Lesevorgänge Anwendungscode einfacher und Anwendungen vertrauenswürdiger. Weitere Informationen zu den Konsistenzeigenschaften von Spanner finden Sie unter TrueTime und externe Konsistenz.

• Wenn die Latenz in manchen Situationen starke Lesevorgänge verhindert, verwenden Sie veraltete Lesevorgänge (begrenzte Veralterung oder exakte Veralterung), um die Leistung zu verbessern, sofern die Lesevorgänge nicht ganz aktuell sein müssen. Wie auf der Seite Replikation beschrieben, sind 15 Sekunden ein angemessener Veralterungswert für eine gute Leistung.

Daten mit einer Datenbankrolle lesen

Wenn Sie die detaillierte Zugriffssteuerung verwenden, müssen Sie eine Datenbankrolle auswählen, um SQL-Anweisungen und ‑Abfragen auszuführen und Zeilenvorgänge in einer Datenbank auszuführen. Die Rollenauswahl bleibt während der gesamten Sitzung bestehen, bis Sie die Rolle ändern.

Eine Anleitung zum Lesen mit einer Datenbankrolle finden Sie unter Mit der detaillierten Zugriffssteuerung auf eine Datenbank zugreifen.

Einzelne Leseaufrufe

Spanner unterstützt Methoden für einzelne Leseaufrufe (d. h. einen Leseaufruf außerhalb des Kontexts einer Transaktion) für eine Datenbank so:

• Lesevorgang als SQL-Abrufanweisung oder über die Lese-API von Spanner ausführen
• Starken Lesevorgang aus einer einzelnen Zeile oder mehreren Zeilen in einer Tabelle durchführen
• Veralteten Lesevorgang aus einer einzelnen Zeile oder mehreren Zeilen in einer Tabelle durchführen
• Aus einer einzelnen Zeile oder mehreren Zeilen in einem sekundären Index lesen

Wenn Sie einzelne Lesevorgänge an ein bestimmtes Replikat oder eine bestimmte Region innerhalb einer multiregionalen Instanzkonfiguration oder einer benutzerdefinierten regionalen Konfiguration mit optionalen schreibgeschützten Regionen weiterleiten möchten, lesen Sie den Hilfeartikel Weitergeleitete Lesevorgänge.

In den folgenden Abschnitten wird beschrieben, wie Lesemethoden mit Spanner-Clientbibliotheken verwendet werden.

Abfrage ausführen

Im Folgenden wird gezeigt, wie eine SQL-Abrufanweisung für eine Datenbank ausgeführt wird.

GoogleSQL

C++

Führen Sie mit ExecuteQuery() eine SQL-Abfrageanweisung für eine Datenbank aus.

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#

Verwenden Sie ExecuteReaderAsync(), um die Datenbank abzufragen.

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

Verwenden Sie Client.Single().Query, um die Datenbank abzufragen.

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

Verwenden Sie ReadContext.executeQuery, um die Datenbank abzufragen.

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

Verwenden Sie Database.run, um die Datenbank abzufragen.

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

Verwenden Sie Database::execute, um die Datenbank abzufragen.

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

Verwenden Sie Database.execute_sql, um die Datenbank abzufragen.

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

Verwenden Sie Client#execute, um die Datenbank abzufragen.

# 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

Achten Sie beim Erstellen einer SQL-Anweisung auf die SQL-Referenzinformationen zur SQL-Abfragesyntax sowie zu Funktionen und Operatoren.

Starken Lesevorgang durchführen

Im Folgenden wird gezeigt, wie ein starker Lesevorgang für null oder mehr Zeilen aus einer Datenbank durchgeführt wird.

GoogleSQL

C++

Der Code zum Lesen von Daten unterscheidet sich nicht von dem Code im vorherigen Beispiel zum Abfragen von Spanner durch die Ausführung einer SQL-Abfrage.

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#

Der Code zum Lesen von Daten unterscheidet sich nicht von dem Code im vorherigen Beispiel zum Abfragen von Spanner durch die Ausführung einer SQL-Abfrage.

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

Verwenden Sie Client.Single().Read, um Zeilen aus der Datenbank zu lesen.

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

In diesem Beispiel wird mit AllKeys eine Sammlung von Schlüsseln oder Schlüsselbereichen definiert, die gelesen werden sollen.

Java

Verwenden Sie ReadContext.read, um Zeilen aus der Datenbank zu lesen.

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

In diesem Beispiel wird mit KeySet eine Sammlung von Schlüsseln oder Schlüsselbereichen definiert, die gelesen werden sollen.

Node.js

Verwenden Sie Table.read, um Zeilen aus der Datenbank zu lesen.

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

In diesem Beispiel wird mit keySet eine Sammlung von Schlüsseln oder Schlüsselbereichen definiert, die gelesen werden sollen.

PHP

Verwenden Sie Database::read, um Zeilen aus der Datenbank zu lesen.

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']);
    }
}

In diesem Beispiel wird mit keySet eine Sammlung von Schlüsseln oder Schlüsselbereichen definiert, die gelesen werden sollen.

Python

Verwenden Sie Database.read, um Zeilen aus der Datenbank zu lesen.

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

In diesem Beispiel wird mit KeySet eine Sammlung von Schlüsseln oder Schlüsselbereichen definiert, die gelesen werden sollen.

Ruby

Verwenden Sie Client#read, um Zeilen aus der Datenbank zu lesen.

# 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

Veralteten Lesevorgang durchführen

Der folgende Beispielcode zeigt, wie ein veralteter Lesevorgang von null oder mehr Zeilen aus einer Datenbank unter Verwendung einer Zeitstempelgrenze des Typs exakte Veralterung durchgeführt wird. Anweisungen zur Durchführung eines veralteten Lesevorgangs mit einer Zeitstempelgrenze vom Typ begrenzte Veralterung finden Sie im Hinweis nach dem Beispielcode. Weitere Informationen über die verschiedenen verfügbaren Arten von Zeitstempelgrenzen finden Sie unter Zeitstempelgrenzen.

GoogleSQL

C++

Verwenden Sie ExecuteQuery() mit MakeReadOnlyTransaction() und Transaction::ReadOnlyOptions(), um einen veralteten Lesevorgang durchzuführen.

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#

Verwenden Sie die Methode BeginReadOnlyTransactionAsync für eine connection mit einem angegebenen Wert für TimestampBound.OfExactStaleness(), um die Datenbank abzufragen.

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.BeginTransactionAsync(SpannerTransactionCreationOptions.ForTimestampBoundReadOnly(staleness), cancellationToken: default);
        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;
    }
}

Hinweis: Geben Sie zur Verwendung einer Zeitstempelgrenze mit begrenzter Veralterung einen Wert für TimestampBound.OfMaxStaleness() anstelle eines Werts für TimestampBound.OfExactStaleness() an.

Go

Verwenden Sie Client.ReadOnlyTransaction().WithTimestampBound() und geben Sie einen Wert für ExactStaleness an, um mithilfe einer Zeitstempelgrenze mit exakter Veralterung einen Lesevorgang für Zeilen aus der Datenbank durchzuführen.

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

In diesem Beispiel wird mit AllKeys eine Sammlung von Schlüsseln oder Schlüsselbereichen definiert, die gelesen werden sollen.

Hinweis: Geben Sie zur Verwendung einer Zeitstempelgrenze mit begrenzter Veralterung einen Wert für MaxStaleness anstelle eines Werts für ExactStaleness an.

Java

Verwenden Sie die Methode read eines Elements ReadContext, das einen festgelegten Parameter TimestampBound.ofExactStaleness() enthält, um unter Verwendung einer Zeitstempelgrenze vom Typ "exakte Veralterung" einen Lesevorgang für Zeilen aus der Datenbank durchzuführen.

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

In diesem Beispiel wird mit KeySet eine Sammlung von Schlüsseln oder Schlüsselbereichen definiert, die gelesen werden sollen.

Hinweis: Geben Sie zur Verwendung einer Zeitstempelgrenze mit begrenzter Veralterung einen Wert für TimestampBound.ofMaxStaleness anstelle eines Werts für TimestampBound.ofExactStaleness() an.

Node.js

Verwenden Sie Table.read mit der Option exactStaleness, um Zeilen mit einer Zeitstempelgrenze vom Typ "exakte Veralterung" aus der Datenbank zu lesen.

// 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 15000 milliseconds ago are visible
  exactStaleness: 15000,
};

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

In diesem Beispiel wird mit keySet eine Sammlung von Schlüsseln oder Schlüsselbereichen definiert, die gelesen werden sollen.

Hinweis: Geben Sie zur Verwendung einer Zeitstempelgrenze mit begrenzter Veralterung die Option maxStaleness anstelle der Option exactStaleness an.

PHP

Verwenden Sie Database::read mit einem angegebenen Wert für exactStaleness, um Zeilen mit einer Zeitstempelgrenze vom Typ "exakte Veralterung" aus der Datenbank zu lesen.

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']);
    }
}

In diesem Beispiel wird mit keySet eine Sammlung von Schlüsseln oder Schlüsselbereichen definiert, die gelesen werden sollen.

Hinweis: Geben Sie zur Verwendung einer Zeitstempelgrenze mit begrenzter Veralterung einen Wert für maxStaleness anstelle eines Werts für exactStaleness an.

Python

Verwenden Sie die Methode read eines Elements Database snapshot mit einem angegebenen Wert für exact_staleness, um Zeilen mit einer Zeitstempelgrenze vom Typ "exakte Veralterung" aus der Datenbank zu lesen.

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

In diesem Beispiel wird mit KeySet eine Sammlung von Schlüsseln oder Schlüsselbereichen definiert, die gelesen werden sollen.

Hinweis: Geben Sie zur Verwendung einer Zeitstempelgrenze mit begrenzter Veralterung einen Wert für max_staleness anstelle eines Werts für exact_staleness an.

Ruby

Verwenden Sie die Methode read eines Snapshots Client mit einem in Sekunden angegebenen Wert für staleness, um Zeilen mit einer Zeitstempelgrenze vom Typ "exakte Veralterung" aus der Datenbank zu lesen.

# 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

Hinweis: Nutzen Sie den Beispielcode zum Ausführen eines starken Lesevorgangs, um eine Zeitstempelgrenze mit begrenzter Veralterung zu verwenden. Geben Sie dabei zusätzlich den Parameter single_use: mit dem Wert {max_staleness: [n seconds]} an, um den Lesevorgang mit einer Veralterung von [n seconds][n Sekunden] durchzuführen.

Lesevorgang mit einem Index ausführen

Im Folgenden wird gezeigt, wie Sie mit einem Index null oder mehr Zeilen aus einer Datenbank auslesen:

GoogleSQL

C++

Verwenden Sie die Funktion Read(), um einen Lesevorgang mit einem Index durchzuführen.

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#

Lesen Sie Daten mit dem Index aus, indem Sie eine Abfrage ausführen, in der der Index explizit angegeben wird:

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

Verwenden Sie Client.Single().ReadUsingIndex, um Zeilen mit einem Index aus der Datenbank zu lesen.

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

Verwenden Sie ReadContext.readUsingIndex, um Zeilen mit einem Index aus der Datenbank zu lesen.

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

Verwenden Sie Table.read und geben Sie den Index in der Abfrage an, um Zeilen mit einem Index aus der Datenbank zu lesen.

/**
 * 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

Verwenden Sie Database::read und geben Sie den Index an, um Zeilen mit einem Index aus der Datenbank zu lesen.

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

Verwenden Sie Database.read und geben Sie den Index an, um Zeilen mit einem Index aus der Datenbank zu lesen.

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

Verwenden Sie Client#read und geben Sie den Index an, um Zeilen mit einem Index aus der Datenbank zu lesen.

# 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

Daten gleichzeitig lesen

Wenn Sie Bulk-Lese- oder Abfragevorgänge mit sehr großen Datenmengen aus Spanner ausführen, können Sie die PartitionQuery API verwenden, um schnellere Ergebnisse zu erzielen. Die API unterteilt die Abfrage in Batches oder Partitionen und verwendet mehrere Maschinen, um die Partitionen parallel abzurufen. Die Verwendung der PartitionQuery API führt zu einer höheren Latenz, da sie nur für Bulk-Vorgänge wie den Export oder das Scannen der gesamten Datenbank vorgesehen ist.

Mithilfe der Spanner-Clientbibliotheken können Sie API-Vorgänge gleichzeitig ausführen. SQL-Abfragen lassen sich jedoch nur partitionieren, wenn sie mandantenübergreifend partitioniert werden können. Damit eine Abfrage auf die Stammpartition angewendet werden kann, muss der Abfrageplan eine der folgenden Bedingungen erfüllen:

• Der erste Operator im Abfrageausführungsplan ist eine Distributed Union und der Abfrageausführungsplan enthält nur eine Distributed Union (ausgenommen Local Distribution Unions). Der Abfrageplan darf keine anderen verteilten Operatoren enthalten, z. B. Distributed Cross Apply.

• Der Anfrageplan enthält keine verteilten Operatoren.

Die PartitionQuery API führt die Abfragen im Batchmodus aus. Spanner kann einen Abfrageausführungsplan auswählen, der die Abfragen im Batchmodus mandantenübergreifend partitionierbar macht. Daher werden für dieselbe Abfrage möglicherweise unterschiedliche Abfrageausführungspläne von der PartitionQuery API und Spanner Studio verwendet. Möglicherweise können Sie den Abfrageausführungsplan, der von der PartitionQuery API in Spanner Studio verwendet wird, nicht abrufen.

Für solche partitionierten Abfragen können Sie Spanner Data Boost aktivieren. Mit Data Boost können Sie umfangreiche Analyseabfragen nahezu ohne Auswirkungen auf vorhandene Arbeitslasten auf der bereitgestellten Spanner-Instanz ausführen. In den Codebeispielen für C++, Go, Java, Node.js und Python auf dieser Seite wird gezeigt, wie Sie den Daten-Boost aktivieren.

Weitere Informationen zu Data Boost finden Sie unter Data Boost-Übersicht.

Hinweis: In den folgenden Beispielen wird die DDL-Tabellendefinition aus der Kurzanleitung verwendet.

GoogleSQL

C++

In diesem Beispiel werden Partitionen einer SQL-Abfrage der Tabelle Singers abgerufen und die Abfrage wird anhand folgender Schritte über jede Partition ausgeführt:

• Erstellen einer Spanner-Batchtransaktion
• Erstellen von Partitionen für die Abfrage, damit die Partitionen auf mehrere Worker verteilt werden können.
• Abrufen der Abfrageergebnisse für jede Partition.

Hinweis: Zur Vereinfachung werden im Beispiel alle Partitionen aus mehreren parallelen Aufgaben innerhalb eines einzelnen Prozesses abgerufen. Bei realen Anwendungsfällen sollten Sie die Partitionen auf Worker verteilen, die sich auf verschiedenen Rechnern befinden. So können Sie die Effizienz verbessern.

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),
      google::cloud::Options{}.set<spanner::PartitionDataBoostOption>(true));
  if (!partitions) throw std::move(partitions).status();

  // You would probably choose to execute these partitioned queries in
  // separate threads/processes, or on a different machine.
  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#

In diesem Beispiel werden Partitionen einer SQL-Abfrage der Tabelle Singers abgerufen und die Abfrage wird anhand folgender Schritte über jede Partition ausgeführt:

• Erstellen einer Spanner-Batchtransaktion
• Erstellen von Partitionen für die Abfrage, damit die Partitionen auf mehrere Worker verteilt werden können.
• Abrufen der Abfrageergebnisse für jede Partition.

Hinweis: Zur Vereinfachung werden im Beispiel alle Partitionen aus mehreren parallelen Aufgaben innerhalb eines einzelnen Prozesses abgerufen. Bei realen Anwendungsfällen sollten Sie die Partitionen auf Worker verteilen, die sich auf verschiedenen Rechnern befinden. So können Sie die Effizienz verbessern.

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.BeginTransactionAsync(SpannerTransactionCreationOptions.ReadOnly.WithIsDetached(true), cancellationToken: default);
        transaction.DisposeBehavior = DisposeBehavior.CloseResources;
        using var cmd = connection.CreateSelectCommand("SELECT SingerId, FirstName, LastName FROM Singers");
        cmd.Transaction = transaction;

        // A CommandPartition object is serializable and can be used from a different process.
        // If data boost is enabled, partitioned read and query requests will be executed
        // using Spanner independent compute resources.
        var partitions = await cmd.GetReaderPartitionsAsync(PartitionOptions.Default.WithDataBoostEnabled(true));

        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 = await connection.BeginTransactionAsync(SpannerTransactionCreationOptions.FromReadOnlyTransactionId(id), cancellationToken: default);
        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

In diesem Beispiel werden Partitionen einer SQL-Abfrage der Tabelle Singers abgerufen und die Abfrage wird anhand folgender Schritte über jede Partition ausgeführt:

• Erstellen eines Spanner-Clients und einer Transaktion.
• Erstellen von Partitionen für die Abfrage, damit die Partitionen auf mehrere Worker verteilt werden können.
• Abrufen der Abfrageergebnisse für jede Partition.

Hinweis: Zur Vereinfachung werden im Beispiel alle Partitionen von einem einzigen Rechner abgerufen und zum Abrufen der Ergebnisse werden die Partitionen ausgeführt. Wenn Ihnen mehr als ein Prozessor zur Verfügung steht, können die Ausführungen auch gleichzeitig erfolgen. Bei realen Anwendungsfällen sollten Sie die Partitionen auf Worker verteilen, die sich auf verschiedenen Rechnern befinden. So können Sie die Effizienz verbessern.

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;"}
	// A Partition object is serializable and can be used from a different process.
	// DataBoost option is an optional parameter which can also be used for partition read
	// and query to execute the request via spanner independent compute resources.
	partitions, err := txn.PartitionQueryWithOptions(ctx, stmt, spanner.PartitionOptions{}, spanner.QueryOptions{DataBoostEnabled: true})
	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

In diesem Beispiel werden Partitionen einer SQL-Abfrage der Tabelle Singers abgerufen und die Abfrage wird anhand folgender Schritte über jede Partition ausgeführt:

• Erstellen eines Spanner-Batch-Clients und einer Transaktion.
• Erstellen von Partitionen für die Abfrage, damit die Partitionen auf mehrere Worker verteilt werden können.
• Abrufen der Abfrageergebnisse für jede Partition.

Hinweis: Zur Vereinfachung werden im Beispiel alle Partitionen von einem einzigen Rechner abgerufen und mehrere Jobs gleichzeitig ausgeführt, sofern Ihnen mehrere Prozessoren zur Verfügung stehen. Bei realen Anwendungsfällen sollten Sie die Partitionen auf Worker verteilen, die sich auf verschiedenen Rechnern befinden. So können Sie die Effizienz verbessern.

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.
  // DataBoost option is an optional parameter which can be used for partition read
  // and query to execute the request via spanner independent compute resources.

  List<Partition> partitions =
      txn.partitionQuery(
          PartitionOptions.getDefaultInstance(),
          Statement.of("SELECT SingerId, FirstName, LastName FROM Singers"),
          // Option to enable data boost for a given request
          Options.dataBoostEnabled(true));

  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

In diesem Beispiel werden Partitionen einer SQL-Abfrage der Tabelle Singers abgerufen und die Abfrage wird anhand folgender Schritte über jede Partition ausgeführt:

• Erstellen eines Spanner-Clients und eines Batches.
• Erstellen von Partitionen für die Abfrage, damit die Partitionen auf mehrere Worker verteilt werden können.
• Abrufen der Abfrageergebnisse für jede Partition.

Hinweis: Zur Vereinfachung werden im Beispiel alle Partitionen von einem einzigen Rechner abgerufen und mehrere Jobs gleichzeitig ausgeführt, sofern Ihnen mehrere Prozessoren zur Verfügung stehen. Bei realen Anwendungsfällen sollten Sie die Partitionen auf Worker verteilen, die sich auf verschiedenen Rechnern befinden. So können Sie die Effizienz verbessern.

// 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 = {
  sql: 'SELECT * FROM Singers',
  // DataBoost option is an optional parameter which can also be used for partition read
  // and query to execute the request via spanner independent compute resources.
  dataBoostEnabled: true,
};

// A Partition object is serializable and can be used from a different process.
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

In diesem Beispiel werden Partitionen einer SQL-Abfrage der Tabelle Singers abgerufen und die Abfrage wird anhand folgender Schritte über jede Partition ausgeführt:

• Erstellen eines Spanner-Clients und eines Batches.
• Erstellen von Partitionen für die Abfrage, damit die Partitionen auf mehrere Worker verteilt werden können.
• Abrufen der Abfrageergebnisse für jede Partition.

Hinweis: Zur Vereinfachung werden im Beispiel alle Partitionen von einem einzigen Rechner abgerufen und zum Abrufen der Ergebnisse werden die Partitionen ausgeführt. Wenn Ihnen mehr als ein Prozessor zur Verfügung steht, können die Ausführungen auch gleichzeitig erfolgen. Bei realen Anwendungsfällen sollten Sie die Partitionen auf Worker verteilen, die sich auf verschiedenen Rechnern befinden. So können Sie die Effizienz verbessern.

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, [
        // This is an optional parameter which can be used for partition
        // read and query to execute the request via spanner independent
        // compute resources.
        'dataBoostEnabled' => true
    ]);
    $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

In diesem Beispiel werden Partitionen einer SQL-Abfrage der Tabelle Singers abgerufen und die Abfrage wird anhand folgender Schritte über jede Partition ausgeführt:

• Erstellen eines Spanner-Clients und einer Batch-Transaktion.
• Erstellen von Partitionen für die Abfrage, damit die Partitionen auf mehrere Worker verteilt werden können.
• Abrufen der Abfrageergebnisse für jede Partition.

Hinweis: Zur Vereinfachung werden im Beispiel alle Partitionen von einem einzigen Rechner abgerufen und mehrere Jobs gleichzeitig ausgeführt, sofern Ihnen mehrere Prozessoren zur Verfügung stehen. Bei realen Anwendungsfällen sollten Sie die Partitionen auf Worker verteilen, die sich auf verschiedenen Rechnern befinden. So können Sie die Effizienz verbessern.

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),
        # A Partition object is serializable and can be used from a different process.
        # DataBoost option is an optional parameter which can also be used for partition read
        # and query to execute the request via spanner independent compute resources.
        data_boost_enabled=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

In diesem Beispiel werden Partitionen einer SQL-Abfrage der Tabelle Singers abgerufen und die Abfrage wird anhand folgender Schritte über jede Partition ausgeführt:

• Erstellen eines Spanner-Batch-Clients.
• Erstellen von Partitionen für die Abfrage, damit die Partitionen auf mehrere Worker verteilt werden können.
• Abrufen der Abfrageergebnisse für jede Partition.

Hinweis: Zur Vereinfachung werden im Beispiel alle Partitionen von einem einzigen Rechner abgerufen und mehrere Jobs gleichzeitig ausgeführt, sofern Ihnen mehrere Prozessoren zur Verfügung stehen. Bei realen Anwendungsfällen sollten Sie die Partitionen auf Worker verteilen, die sich auf verschiedenen Rechnern befinden. So können Sie die Effizienz verbessern.

# 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
# data_boost_enabled option is an optional parameter which can be used for partition read
# and query to execute the request via spanner independent compute resources.
partitions       = batch_snapshot.partition_query "SELECT SingerId, FirstName, LastName FROM Singers", data_boost_enabled: true
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}"