Membaca di luar transaksi

Halaman ini menjelaskan cara melakukan pembacaan di Spanner di luar konteks transaksi hanya baca dan baca-tulis. Jika salah satu hal berikut berlaku, Anda harus membaca halaman Transaksi:

• Jika perlu menulis, bergantung pada nilai satu atau beberapa operasi baca, Anda harus mengeksekusi pembacaan sebagai bagian dari transaksi baca-tulis. Untuk mengetahui informasi selengkapnya, lihat transaksi baca-tulis.

• Jika melakukan beberapa panggilan baca yang memerlukan tampilan data yang konsisten, Anda harus mengeksekusi pembacaan sebagai bagian dari transaksi hanya baca. Untuk informasi selengkapnya, lihat transaksi hanya baca.

Membaca jenis

Spanner memungkinkan Anda menentukan seberapa aktual data saat membaca data dengan menawarkan dua jenis operasi baca:

• Pembacaan kuat adalah pembacaan pada stempel waktu saat ini dan dijamin untuk melihat semua data yang telah di-commit hingga awal pembacaan ini. Secara default, Spanner menggunakan pembacaan yang kuat untuk menyalurkan permintaan baca.
• Pembacaan yang sudah tidak berlaku dibaca pada stempel waktu yang lalu. Jika aplikasi Anda sensitif terhadap latensi tetapi toleran terhadap data tidak berlaku, pembacaan yang sudah tidak berlaku dapat memberikan manfaat bagi performa.

Untuk memilih jenis pembacaan yang Anda inginkan, tetapkan batas stempel waktu pada permintaan baca. Gunakan praktik terbaik berikut saat memilih batas stempel waktu:

• Pilih pembacaan yang kuat jika memungkinkan. Ini adalah stempel waktu default yang terikat untuk pembacaan Spanner, termasuk transaksi hanya baca. Bacaan yang kuat dijamin mengamati efek dari semua transaksi yang dilakukan sebelum dimulainya operasi, terlepas dari replika mana yang menerima bacaan. Oleh karena itu, pembacaan yang kuat membuat kode aplikasi lebih sederhana dan aplikasi lebih tepercaya. Baca selengkapnya tentang properti konsistensi Spanner di TrueTime dan External Consistency.

• Jika latensi membuat pembacaan yang kuat tidak mungkin dilakukan dalam beberapa situasi, gunakan operasi baca yang sudah tidak berlaku (keadaan terikat atau ketinggalan zaman) untuk meningkatkan performa saat Anda tidak memerlukan pembacaan versi terbaru. Seperti yang dijelaskan di halaman Replikasi, 15 detik adalah nilai penghentian yang wajar untuk digunakan demi performa yang baik.

Membaca data dengan peran database

Jika Anda adalah pengguna kontrol akses yang mendetail, Anda harus memilih peran database untuk menjalankan pernyataan dan kueri SQL, serta melakukan operasi baris pada database. Pilihan peran tetap ada sepanjang sesi Anda sampai Anda mengubah peran.

Untuk mengetahui petunjuk cara melakukan pembacaan dengan peran database, lihat Mengakses database dengan kontrol akses yang sangat terperinci.

Metode baca tunggal

Spanner mendukung metode baca tunggal (yaitu, pembacaan di luar konteks transaksi) pada database untuk:

• Mengeksekusi pembacaan sebagai pernyataan kueri SQL atau menggunakan API baca Spanner.
• Melakukan pembacaan yang kuat dari satu baris atau beberapa baris dalam tabel.
• Melakukan pembacaan yang sudah tidak berlaku dari satu atau beberapa baris dalam tabel.
• Membaca dari satu atau beberapa baris dalam indeks sekunder.

Jika Anda ingin merutekan pembacaan tunggal ke replika atau region tertentu dalam konfigurasi instance multi-region atau konfigurasi regional kustom dengan region hanya baca opsional, lihat Pembacaan yang diarahkan.

Bagian berikut menjelaskan cara menggunakan metode baca dengan library klien Spanner.

Menjalankan kueri

Berikut ini cara mengeksekusi pernyataan kueri SQL terhadap database.

GoogleSQL

C++

Gunakan ExecuteQuery() untuk menjalankan pernyataan kueri SQL terhadap database.

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#

Gunakan ExecuteReaderAsync() untuk membuat kueri database.

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

Gunakan Client.Single().Query untuk membuat kueri database.

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

Gunakan ReadContext.executeQuery untuk membuat kueri database.

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

Gunakan Database.run untuk membuat kueri database.

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

Gunakan Database::execute untuk membuat kueri database.

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

Gunakan Database.execute_sql untuk membuat kueri database.

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

Gunakan Client#execute untuk membuat kueri database.

# 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

Lihat referensi Sintaksis Kueri serta Fungsi dan Operator SQL saat membuat pernyataan SQL.

Lakukan pembacaan yang kuat

Berikut ini cara melakukan pembacaan yang kuat terhadap nol atau beberapa baris dari suatu database.

GoogleSQL

C++

Kode untuk membaca data sama dengan contoh sebelumnya untuk membuat kueri Spanner dengan mengeksekusi kueri SQL.

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#

Kode untuk membaca data sama dengan contoh sebelumnya untuk membuat kueri Spanner dengan mengeksekusi kueri SQL.

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

Gunakan Client.Single().Read untuk membaca baris dari database.

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

Contoh ini menggunakan AllKeys untuk menentukan kumpulan kunci atau rentang kunci yang akan dibaca.

Java

Gunakan ReadContext.read untuk membaca baris dari database.

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

Contoh ini menggunakan KeySet untuk menentukan kumpulan kunci atau rentang kunci yang akan dibaca.

Node.js

Gunakan Table.read untuk membaca baris dari database.

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

Contoh ini menggunakan keySet untuk menentukan kumpulan kunci atau rentang kunci yang akan dibaca.

PHP

Gunakan Database::read untuk membaca baris dari database.

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

Contoh ini menggunakan keySet untuk menentukan kumpulan kunci atau rentang kunci yang akan dibaca.

Python

Gunakan Database.read untuk membaca baris dari database.

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

Contoh ini menggunakan KeySet untuk menentukan kumpulan kunci atau rentang kunci yang akan dibaca.

Ruby

Gunakan Client#read untuk membaca baris dari database.

# 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

Melakukan pembacaan yang sudah tidak berlaku

Kode contoh berikut menunjukkan cara melakukan pembacaan yang sudah tidak berlaku terhadap nol atau beberapa baris dari database menggunakan batas stempel waktu persis-slateness. Untuk petunjuk cara melakukan pembacaan yang sudah tidak berlaku menggunakan batas stempel waktu bounded-staleness, lihat catatan setelah kode contoh. Lihat Batas stempel waktu untuk informasi selengkapnya tentang berbagai jenis batas stempel waktu yang tersedia.

GoogleSQL

C++

Gunakan ExecuteQuery() dengan MakeReadOnlyTransaction() dan Transaction::ReadOnlyOptions() untuk melakukan pembacaan yang sudah tidak berlaku.

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#

Gunakan metode BeginReadOnlyTransactionAsync pada connection dengan nilai TimestampBound.OfExactStaleness() yang ditentukan untuk membuat kueri database.

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

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

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

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

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

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

Catatan: Untuk menggunakan batas stempel waktu terikatan masa berlaku, tentukan nilai TimestampBound.OfMaxStaleness(), bukan nilai TimestampBound.OfExactStaleness().

Go

Gunakan Client.ReadOnlyTransaction().WithTimestampBound() dan tentukan nilai ExactStaleness untuk melakukan pembacaan baris dari database menggunakan batasan stempel waktu yang persis sama.

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

Contoh ini menggunakan AllKeys untuk menentukan kumpulan kunci atau rentang kunci yang akan dibaca.

Catatan: Untuk menggunakan batas stempel waktu terikat-lama, tentukan nilai MaxStaleness, bukan nilai ExactStaleness.

Java

Gunakan metode read dari ReadContext yang memiliki TimestampBound.ofExactStaleness() yang ditentukan untuk melakukan pembacaan baris dari database menggunakan terikat stempel waktu masa berlaku yang sama persis.

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

Contoh ini menggunakan KeySet untuk menentukan kumpulan kunci atau rentang kunci yang akan dibaca.

Catatan: Untuk menggunakan batas stempel waktu bounded-staleness, tentukan TimestampBound.ofMaxStaleness, bukan TimestampBound.ofExactStaleness().

Node.js

Gunakan Table.read dengan opsi exactStaleness untuk melakukan pembacaan baris dari database menggunakan terikat stempel waktu masa berlaku yang sama persis.

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

Contoh ini menggunakan keySet untuk menentukan kumpulan kunci atau rentang kunci yang akan dibaca.

Catatan: Untuk menggunakan batas stempel waktu terbatas-masa berlaku, gunakan opsi maxStaleness, bukan opsi exactStaleness.

PHP

Gunakan Database::read dengan nilai exactStaleness yang ditentukan untuk melakukan pembacaan baris dari database menggunakan batas stempel waktu yang sama persis.

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

Contoh ini menggunakan keySet untuk menentukan kumpulan kunci atau rentang kunci yang akan dibaca.

Catatan: Untuk menggunakan batas stempel waktu terikat-lama, tentukan nilai maxStaleness, bukan nilai exactStaleness.

Python

Gunakan metode read dari Database snapshot yang memiliki nilai exact_staleness yang telah ditentukan untuk melakukan pembacaan baris dari database menggunakan batasan stempel waktu masa berlaku yang tepat.

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

Contoh ini menggunakan KeySet untuk menentukan kumpulan kunci atau rentang kunci yang akan dibaca.

Catatan: Untuk menggunakan batas stempel waktu bounded-staleness, tentukan nilai max_staleness, bukan nilai exact_staleness.

Ruby

Gunakan metode read dari Client snapshot yang memiliki nilai staleness yang ditentukan (dalam detik) untuk melakukan pembacaan baris dari database menggunakan batas stempel waktu masa berlaku yang tepat.

# 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

Catatan: Untuk menggunakan batas stempel waktu terikat waktu yang lama, gunakan kode contoh untuk melakukan pembacaan yang kuat, tetapi juga menentukan parameter single_use: dengan nilai {max_staleness: [n seconds]} untuk dibaca dengan nilai usang [n seconds].

Melakukan pembacaan menggunakan indeks

Berikut cara membaca nol atau beberapa baris dari database menggunakan indeks:

GoogleSQL

C++

Gunakan fungsi Read() untuk melakukan pembacaan menggunakan indeks.

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#

Baca data menggunakan indeks dengan mengeksekusi kueri yang secara eksplisit menentukan indeks:

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

Gunakan Client.Single().ReadUsingIndex untuk membaca baris dari database menggunakan indeks.

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

Gunakan ReadContext.readUsingIndex untuk membaca baris dari database menggunakan indeks.

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

Gunakan Table.read dan tentukan indeks dalam kueri untuk membaca baris dari database menggunakan indeks.

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

Gunakan Database::read dan tentukan indeks untuk membaca baris dari database menggunakan indeks.

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

Gunakan Database.read dan tentukan indeks untuk membaca baris dari database menggunakan indeks.

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

Gunakan Client#read dan tentukan indeks untuk membaca baris dari database menggunakan indeks.

# 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

Membaca data secara paralel

Saat melakukan operasi kueri atau baca massal yang melibatkan data dalam jumlah yang sangat besar dari Spanner, Anda dapat menggunakan PartitionQuery API untuk mendapatkan hasil yang lebih cepat. API membagi kueri menjadi beberapa batch, atau partisi, dengan menggunakan beberapa mesin untuk mengambil partisi secara paralel. Perlu diingat bahwa penggunaan PartitionQuery API akan menyebabkan latensi yang lebih tinggi karena hanya ditujukan untuk operasi massal seperti mengekspor atau memindai seluruh database.

Anda dapat menjalankan operasi API baca apa pun secara paralel menggunakan library klien Spanner. Namun, Anda hanya dapat mempartisi kueri SQL jika kueri dapat dipartisi di root. Agar kueri dapat dipartisi di root, paket kueri harus memenuhi salah satu kondisi berikut:

• Operator pertama dalam rencana eksekusi kueri adalah gabungan terdistribusi dan rencana eksekusi kueri hanya berisi satu gabungan terdistribusi (tidak termasuk Local Distribution Union). Paket kueri Anda tidak dapat berisi operator terdistribusi lainnya, seperti penerapan silang terdistribusi.

• Tidak ada operator terdistribusi dalam paket kueri.

PartitionQuery API menjalankan kueri dalam mode batch. Spanner dapat memilih rencana eksekusi kueri yang membuat kueri dapat dipartisi root saat dijalankan dalam mode batch. Akibatnya, PartitionQuery API dan Spanner Studio mungkin menggunakan rencana eksekusi kueri yang berbeda untuk kueri yang sama. Anda mungkin tidak bisa mendapatkan rencana eksekusi kueri yang digunakan oleh PartitionQuery API di Spanner Studio.

Untuk kueri terpartisi seperti ini, Anda dapat memilih untuk mengaktifkan Spanner Data Boost. Dengan Data Boost, Anda dapat menjalankan kueri analisis besar dengan dampak nyaris nol terhadap beban kerja yang ada di instance Spanner yang disediakan. Contoh kode C++, Go, Java, Node.js, dan Python di halaman ini menunjukkan cara mengaktifkan Data Boost.

Untuk mengetahui informasi selengkapnya tentang Data Boost, lihat Ringkasan Data Boost.

Catatan: Contoh berikut dapat digunakan dengan definisi tabel DDL yang ada di Panduan Memulai.

GoogleSQL

C++

Contoh ini mengambil partisi kueri SQL dari tabel Singers dan mengeksekusi kueri pada setiap partisi melalui langkah-langkah berikut:

• Membuat transaksi batch Spanner.
• Membuat partisi untuk kueri, sehingga partisi dapat didistribusikan ke beberapa pekerja.
• Mengambil hasil kueri untuk setiap partisi.

Catatan: Demi kemudahan, contoh tersebut mengambil semua partisi dari beberapa tugas paralel dalam satu proses. Untuk kasus penggunaan nyata, Anda harus mendistribusikan partisi ke pekerja di mesin yang berbeda untuk meningkatkan efisiensi.

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#

Contoh ini mengambil partisi kueri SQL dari tabel Singers dan mengeksekusi kueri pada setiap partisi melalui langkah-langkah berikut:

• Membuat transaksi batch Spanner.
• Membuat partisi untuk kueri, sehingga partisi dapat didistribusikan ke beberapa pekerja.
• Mengambil hasil kueri untuk setiap partisi.

Catatan: Demi kemudahan, contoh tersebut mengambil semua partisi dari beberapa tugas paralel dalam satu proses. Untuk kasus penggunaan nyata, Anda harus mendistribusikan partisi ke pekerja di mesin yang berbeda untuk meningkatkan efisiensi.

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

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

        using var transaction = await connection.BeginReadOnlyTransactionAsync();
        transaction.DisposeBehavior = DisposeBehavior.CloseResources;
        using var cmd = connection.CreateSelectCommand("SELECT SingerId, FirstName, LastName FROM Singers");
        cmd.Transaction = transaction;

        // 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 = connection.BeginReadOnlyTransaction(id);
        using var cmd = connection.CreateCommandWithPartition(readPartition, transaction);
        using var reader = await cmd.ExecuteReaderAsync();
        while (await reader.ReadAsync())
        {
            Interlocked.Increment(ref _rowsRead);
            Console.WriteLine($"Partition ({localId}) "
                + $"{reader.GetFieldValue<int>("SingerId")}"
                + $" {reader.GetFieldValue<string>("FirstName")}"
                + $" {reader.GetFieldValue<string>("LastName")}");
        }
        Console.WriteLine($"Done with single reader {localId}.");
    }
}

Go

Contoh ini mengambil partisi kueri SQL dari tabel Singers dan mengeksekusi kueri pada setiap partisi melalui langkah-langkah berikut:

• Membuat klien Spanner dan transaksi.
• Membuat partisi untuk kueri, sehingga partisi dapat didistribusikan ke beberapa pekerja.
• Mengambil hasil kueri untuk setiap partisi.

Catatan: Agar lebih praktis, contoh ini mengambil semua partisi dari satu komputer dan mengeksekusi partisi untuk mengambil hasilnya. Jika Anda memiliki lebih dari satu prosesor, eksekusi juga dapat dijalankan secara paralel. Untuk kasus penggunaan nyata, Anda harus mendistribusikan partisi ke pekerja di komputer yang berbeda untuk meningkatkan efisiensi.

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

Contoh ini mengambil partisi kueri SQL dari tabel Singers dan mengeksekusi kueri pada setiap partisi melalui langkah-langkah berikut:

• Membuat klien batch dan transaksi Spanner.
• Membuat partisi untuk kueri, sehingga partisi dapat didistribusikan ke beberapa pekerja.
• Mengambil hasil kueri untuk setiap partisi.

Catatan: Demi kemudahan, contoh ini mengambil semua partisi dari satu komputer, menjalankan beberapa tugas secara paralel jika Anda memiliki lebih dari satu prosesor yang tersedia. Untuk kasus penggunaan nyata, Anda harus mendistribusikan partisi ke pekerja di mesin yang berbeda untuk meningkatkan efisiensi.

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

Contoh ini mengambil partisi kueri SQL dari tabel Singers dan mengeksekusi kueri pada setiap partisi melalui langkah-langkah berikut:

• Membuat klien Spanner dan batch.
• Membuat partisi untuk kueri, sehingga partisi dapat didistribusikan ke beberapa pekerja.
• Mengambil hasil kueri untuk setiap partisi.

Catatan: Demi kemudahan, contoh ini mengambil semua partisi dari satu komputer, menjalankan beberapa tugas secara paralel jika Anda memiliki lebih dari satu prosesor yang tersedia. Untuk kasus penggunaan nyata, Anda harus mendistribusikan partisi ke pekerja di mesin yang berbeda untuk meningkatkan efisiensi.

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

Contoh ini mengambil partisi kueri SQL dari tabel Singers dan mengeksekusi kueri pada setiap partisi melalui langkah-langkah berikut:

• Membuat klien Spanner dan batch.
• Membuat partisi untuk kueri, sehingga partisi dapat didistribusikan ke beberapa pekerja.
• Mengambil hasil kueri untuk setiap partisi.

Catatan: Agar lebih praktis, contoh ini mengambil semua partisi dari satu komputer dan mengeksekusi partisi untuk mengambil hasilnya. Jika Anda memiliki lebih dari satu prosesor, eksekusi juga dapat dijalankan secara paralel. Untuk kasus penggunaan nyata, Anda harus mendistribusikan partisi ke pekerja di komputer yang berbeda untuk meningkatkan efisiensi.

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

Contoh ini mengambil partisi kueri SQL dari tabel Singers dan mengeksekusi kueri pada setiap partisi melalui langkah-langkah berikut:

• Membuat klien Spanner dan transaksi batch.
• Membuat partisi untuk kueri, sehingga partisi dapat didistribusikan ke beberapa pekerja.
• Mengambil hasil kueri untuk setiap partisi.

Catatan: Agar lebih praktis, contoh ini mengambil semua partisi dari satu komputer, menjalankan beberapa tugas secara paralel jika Anda memiliki lebih dari satu prosesor yang tersedia. Untuk kasus penggunaan nyata, Anda harus mendistribusikan partisi ke pekerja di mesin yang berbeda untuk meningkatkan efisiensi.

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

Contoh ini mengambil partisi kueri SQL dari tabel Singers dan mengeksekusi kueri pada setiap partisi melalui langkah-langkah berikut:

• Membuat klien batch Spanner.
• Membuat partisi untuk kueri, sehingga partisi dapat didistribusikan ke beberapa pekerja.
• Mengambil hasil kueri untuk setiap partisi.

Catatan: Demi kemudahan, contoh ini mengambil semua partisi dari satu komputer, menjalankan beberapa tugas secara paralel jika Anda memiliki lebih dari satu prosesor yang tersedia. Untuk kasus penggunaan nyata, Anda harus mendistribusikan partisi ke pekerja di mesin yang berbeda untuk meningkatkan efisiensi.

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