Leituras fora das transações

Esta página descreve como executar leituras no Spanner fora do contexto de transações de leitura e leitura/escrita. Se alguma das seguintes situações se aplicar, deve ler a página Transações:

• Se precisar de escrever, consoante o valor de uma ou mais leituras, deve executar a leitura como parte de uma transação de leitura/escrita. Para mais informações, consulte transações de leitura/escrita.

• Se estiver a fazer várias chamadas de leitura que exijam uma vista consistente dos seus dados, deve executar as leituras como parte de uma transação de leitura exclusiva. Para mais informações, consulte o artigo sobre as transações só de leitura.

Tipos de leitura

O Spanner permite-lhe determinar a atualidade dos dados quando lê dados, oferecendo dois tipos de leituras:

• Uma leitura forte é uma leitura numa data/hora atual e garante que vê todos os dados que foram confirmados até ao início desta leitura. O Spanner usa por predefinição leituras fortes para publicar pedidos de leitura.
• Uma leitura desatualizada é lida numa data/hora no passado. Se a sua aplicação for sensível à latência, mas tolerante a dados desatualizados, as leituras desatualizadas podem oferecer vantagens de desempenho.

Para escolher o tipo de leitura que quer, defina um limite de data/hora no pedido de leitura. Use as seguintes práticas recomendadas quando escolher um limite de tempo:

• Escolha leituras fortes sempre que possível. Esta é a data/hora predefinida para leituras do Spanner, incluindo transações só de leitura. As leituras fortes garantem a observação dos efeitos de todas as transações que foram confirmadas antes do início da operação, independentemente da réplica que recebe a leitura. Por este motivo, as leituras fortes simplificam o código da aplicação e tornam as aplicações mais fiáveis. Leia mais sobre as propriedades de consistência do Spanner em TrueTime e consistência externa.

  Opcionalmente, para reduzir a latência de leitura para transações só de leitura que requerem consistência forte, pode conceder às regiões não principais, de leitura/escrita ou só de leitura o estado de região de concessão de leitura. Para o fazer, use concessões de leitura do Spanner. As regiões de concessão de leitura ajudam a sua base de dados a reduzir a latência de leitura forte em instâncias de duas regiões ou várias regiões. No entanto, as escritas têm uma latência mais elevada quando usa a concessão de leitura.

• Se a latência tornar as leituras fortes inviáveis em algumas situações, use leituras desatualizadas (desatualização limitada ou desatualização exata) para melhorar o desempenho em locais onde não precisa que as leituras sejam o mais recentes possível. Conforme descrito na página Replicação, 15 segundos é um valor de desatualização razoável para usar para um bom desempenho.

Ler dados com uma função de base de dados

Se for um utilizador do controlo de acesso detalhado, tem de selecionar uma função de base de dados para executar declarações e consultas SQL, e para realizar operações de linhas numa base de dados. A seleção da função persiste durante toda a sessão até alterar a função.

Para ver instruções sobre como executar uma leitura com uma função de base de dados, consulte o artigo Aceda a uma base de dados com controlo de acesso detalhado.

Métodos de leitura única

O Spanner suporta métodos de leitura única (ou seja, uma leitura fora do contexto de uma transação) numa base de dados para:

• Executar a leitura como uma declaração de consulta SQL ou usar a API read do Spanner.
• Executar uma leitura forte a partir de uma única linha ou de várias linhas numa tabela.
• Executar uma leitura desatualizada de uma única linha ou várias linhas numa tabela.
• Ler a partir de uma única linha ou de várias linhas num índice secundário.

Se quiser encaminhar leituras únicas para uma réplica ou uma região específica numa configuração de instância multirregional ou numa configuração regional personalizada com regiões só de leitura opcionais, consulte Leituras direcionadas.

As secções seguintes descrevem como usar métodos de leitura com as bibliotecas cliente do Spanner.

Execute uma consulta

O exemplo seguinte mostra como executar uma declaração de consulta SQL numa base de dados.

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

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

import (