Criar e gerenciar bancos de dados

Esta página descreve como gerenciar um banco de dados do Spanner, incluindo como criar, modificar e excluir um banco de dados. Para saber como atualizar um esquema de banco de dados, consulte Fazer atualizações de esquema.

Para praticar a criação de um banco de dados e o carregamento dele com dados de amostra, consulte o Codelab "Seu primeiro banco de dados".

Criar um banco de dados

Os exemplos a seguir mostram como criar um banco de dados em uma instância.

Para bancos de dados do dialeto GoogleSQL, você pode definir o banco de dados esquema no momento da criação do banco de dados ou após a criação do banco de dados. Para bancos de dados de dialeto PostgreSQL, você precisa definir o esquema após a criação.

Os esquemas são definidos usando a Linguagem de definição de banco de dados, que é documentada para GoogleSQL e PostgreSQL. Consulte os links a seguir para mais informações sobre como criar e atualizar esquemas:

• Modelo de dados e esquema
• Práticas recomendadas de criação de esquema
• Atualizações de esquema

Depois de criar seu banco de dados, é possível proteger os bancos de dados importantes aos seus aplicativos e serviços ativando a proteção contra exclusão de bancos de dados. Para mais informações, consulte Prevenir a exclusão acidental de bancos de dados.

Console

1. No console do Google Cloud, acesse a página Instâncias do Spanner.

   Acessar instâncias do Spanner

2. Selecione a instância em que o banco de dados será criado.

3. Clique em Criar banco de dados.

4. Digite os seguintes valores:

   • Um nome de banco de dados a ser exibido no console do Google Cloud.
   • O dialeto a ser usado para este banco de dados.
   • Para bancos de dados com dialeto GoogleSQL, forneça um conjunto de instruções DDL que definem o esquema. Use o Modelos DDL para preencher previamente elementos comuns. Se houver erros no suas instruções DDL, o console do Google Cloud retorna um erro quando ao tentar criar o banco de dados.
   • Opcionalmente, selecione uma chave de criptografia gerenciada pelo cliente para usar neste banco de dados.

5. Clique em Criar para criar o banco de dados.

gcloud

Use o comando gcloud spanner databases create.

gcloud spanner databases create DATABASE \
  --instance=INSTANCE \
  [--async] \
  [--database-dialect=DATABASE_DIALECT] \
  [--ddl=DDL] \
  [--ddl-file=DDL_FILE] \
  [--kms-key=KMS_KEY : --kms-keyring=KMS_KEYRING --kms-location=KMS_LOCATION --kms-project=KMS_PROJECT] \
  [GCLOUD_WIDE_FLAG …]

As seguintes opções são obrigatórias:

DATABASE

ID do banco de dados ou identificador totalmente qualificado para o banco de dados. Se você especificar o identificador totalmente qualificado, a sinalização --instance poderá ser omitida.

--instance=INSTANCE

A instância do Spanner para o banco de dados.

As seguintes opções são opcionais:

--async

Retornar imediatamente, sem aguardar a operação em andamento a serem concluídas.

--database-dialect=DATABASE_DIALECT

O dialeto SQL do banco de dados do Spanner. Deve ser uma destas opções: POSTGRESQL ou GOOGLE_STANDARD_SQL.

--ddl=DDL

Instruções de DDL (linguagem de definição de dados) separadas por ponto-e-vírgula para serem executadas no banco de dados recém-criado. Se houver um erro em qualquer o banco de dados não será criado. Essa flag será ignorada se --ddl_file estiver definido. Incompatível com os bancos de dados de dialeto PostgreSQL.

--ddl-file=DDL_FILE

Caminho de um arquivo que contém valores separados por ponto e vírgula instruções DDL (linguagem de definição de dados) que serão executadas na nova no banco de dados criado. Se houver um erro em alguma instrução, o banco de dados será não foi criada. Se --ddl_file for definido, --ddl será ignorada. Não é compatível com bancos de dados de dialeto PostgreSQL.

Se você estiver especificando uma chave do Cloud Key Management Service para usar ao criar o banco de dados, inclua as seguintes opções:

--kms-key=KMS_KEY

ID da chave ou identificador totalmente qualificado para a chave.

Esta sinalização deve ser especificada se qualquer um dos outros argumentos nesta grupo for especificado. Os outros argumentos podem ser omitidos se o um identificador totalmente qualificado.

--kms-keyring=KMS_KEYRING

ID do keyring do Cloud KMS da chave.

--kms-location=KMS_LOCATION

Local do Google Cloud para a chave.

--kms-project=KMS_PROJECT

ID do projeto do Google Cloud para a chave.

Cliente (GoogleSQL)

C++

Para saber como instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

void CreateDatabase(google::cloud::spanner_admin::DatabaseAdminClient client,
                    std::string const& project_id,
                    std::string const& instance_id,
                    std::string const& database_id) {
  google::cloud::spanner::Database database(project_id, instance_id,
                                            database_id);
  google::spanner::admin::database::v1::CreateDatabaseRequest request;
  request.set_parent(database.instance().FullName());
  request.set_create_statement("CREATE DATABASE `" + database.database_id() +
                               "`");
  request.add_extra_statements(R"""(
      CREATE TABLE Singers (
          SingerId   INT64 NOT NULL,
          FirstName  STRING(1024),
          LastName   STRING(1024),
          SingerInfo BYTES(MAX),
          FullName   STRING(2049)
              AS (ARRAY_TO_STRING([FirstName, LastName], " ")) STORED
      ) PRIMARY KEY (SingerId))""");
  request.add_extra_statements(R"""(
      CREATE TABLE Albums (
          SingerId     INT64 NOT NULL,
          AlbumId      INT64 NOT NULL,
          AlbumTitle   STRING(MAX)
      ) PRIMARY KEY (SingerId, AlbumId),
          INTERLEAVE IN PARENT Singers ON DELETE CASCADE)""");
  auto db = client.CreateDatabase(request).get();
  if (!db) throw std::move(db).status();
  std::cout << "Database " << db->name() << " created.\n";
}

Go

Para saber como instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import (
	"context"
	"fmt"
	"io"
	"regexp"

	database "cloud.google.com/go/spanner/admin/database/apiv1"
	adminpb "cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
)

func createDatabase(ctx context.Context, w io.Writer, db string) error {
	matches := regexp.MustCompile("^(.*)/databases/(.*)$").FindStringSubmatch(db)
	if matches == nil || len(matches) != 3 {
		return fmt.Errorf("Invalid database id %s", db)
	}

	adminClient, err := database.NewDatabaseAdminClient(ctx)
	if err != nil {
		return err
	}
	defer adminClient.Close()

	op, err := adminClient.CreateDatabase(ctx, &adminpb.CreateDatabaseRequest{
		Parent:          matches[1],
		CreateStatement: "CREATE DATABASE `" + matches[2] + "`",
		ExtraStatements: []string{
			`CREATE TABLE Singers (
				SingerId   INT64 NOT NULL,
				FirstName  STRING(1024),
				LastName   STRING(1024),
				SingerInfo BYTES(MAX),
				FullName   STRING(2048) AS (
					ARRAY_TO_STRING([FirstName, LastName], " ")
				) STORED
			) PRIMARY KEY (SingerId)`,
			`CREATE TABLE Albums (
				SingerId     INT64 NOT NULL,
				AlbumId      INT64 NOT NULL,
				AlbumTitle   STRING(MAX)
			) PRIMARY KEY (SingerId, AlbumId),
			INTERLEAVE IN PARENT Singers ON DELETE CASCADE`,
		},
	})
	if err != nil {
		return err
	}
	if _, err := op.Wait(ctx); err != nil {
		return err
	}
	fmt.Fprintf(w, "Created database [%s]\n", db)
	return nil
}

Java

Para saber como instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import com.google.cloud.spanner.SpannerException;
import com.google.cloud.spanner.SpannerExceptionFactory;
import com.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;
import com.google.common.collect.ImmutableList;
import com.google.spanner.admin.database.v1.CreateDatabaseRequest;
import com.google.spanner.admin.database.v1.Database;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class CreateDatabaseWithDefaultLeaderSample {

  static void createDatabaseWithDefaultLeader() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    final String instanceName = "projects/my-project/instances/my-instance-id";
    final String databaseId = "my-database-name";
    final String defaultLeader = "my-default-leader";
    createDatabaseWithDefaultLeader(instanceName, databaseId, defaultLeader);
  }

  static void createDatabaseWithDefaultLeader(String instanceName, String databaseId,
      String defaultLeader) throws IOException {
    try (DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.create()) {
      Database createdDatabase =
          databaseAdminClient.createDatabaseAsync(
              CreateDatabaseRequest.newBuilder()
                  .setParent(instanceName)
                  .setCreateStatement("CREATE DATABASE `" + databaseId + "`")
                  .addAllExtraStatements(
                      ImmutableList.of("CREATE TABLE Singers ("
                              + "  SingerId   INT64 NOT NULL,"
                              + "  FirstName  STRING(1024),"
                              + "  LastName   STRING(1024),"
                              + "  SingerInfo BYTES(MAX)"
                              + ") PRIMARY KEY (SingerId)",
                          "CREATE TABLE Albums ("
                              + "  SingerId     INT64 NOT NULL,"
                              + "  AlbumId      INT64 NOT NULL,"
                              + "  AlbumTitle   STRING(MAX)"
                              + ") PRIMARY KEY (SingerId, AlbumId),"
                              + "  INTERLEAVE IN PARENT Singers ON DELETE CASCADE",
                          "ALTER DATABASE " + "`" + databaseId + "`"
                              + " SET OPTIONS ( default_leader = '" + defaultLeader + "' )"))
                  .build()).get();
      System.out.println("Created database [" + createdDatabase.getName() + "]");
      System.out.println("\tDefault leader: " + createdDatabase.getDefaultLeader());
    } catch (ExecutionException e) {
      // If the operation failed during execution, expose the cause.
      throw (SpannerException) e.getCause();
    } catch (InterruptedException e) {
      // Throw when a thread is waiting, sleeping, or otherwise occupied,
      // and the thread is interrupted, either before or during the activity.
      throw SpannerExceptionFactory.propagateInterrupt(e);
    }
  }
}

Observação: os exemplos de código de interface da biblioteca de cliente antiga para Java estão arquivados em GitHub:

Node.js

Para aprender a instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance-id';
// const databaseId = 'my-database-id';
// const defaultLeader = 'my-default-leader'; example: 'asia-northeast1'

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

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

// Gets a reference to a Cloud Spanner Database Admin Client object
const databaseAdminClient = spanner.getDatabaseAdminClient();

async function createDatabaseWithDefaultLeader() {
  // Create a new database with an extra statement which will alter the
  // database after creation to set the default leader.
  console.log(
    `Creating database ${databaseAdminClient.databasePath(
      projectId,
      instanceId,
      databaseId
    )}.`
  );
  const createSingersTableStatement = `
    CREATE TABLE Singers (
      SingerId   INT64 NOT NULL,
      FirstName  STRING(1024),
      LastName   STRING(1024),
      SingerInfo BYTES(MAX)
    ) PRIMARY KEY (SingerId)`;
  const createAlbumsStatement = `
    CREATE TABLE Albums (
      SingerId     INT64 NOT NULL,
      AlbumId      INT64 NOT NULL,
      AlbumTitle   STRING(MAX)
    ) PRIMARY KEY (SingerId, AlbumId),
      INTERLEAVE IN PARENT Singers ON DELETE CASCADE`;

  // Default leader is one of the possible values in the leaderOptions field of the
  // instance config of the instance where the database is created.
  const setDefaultLeaderStatement = `
    ALTER DATABASE \`${databaseId}\`
    SET OPTIONS (default_leader = '${defaultLeader}')`;

  const [operation] = await databaseAdminClient.createDatabase({
    createStatement: 'CREATE DATABASE `' + databaseId + '`',
    extraStatements: [
      createSingersTableStatement,
      createAlbumsStatement,
      setDefaultLeaderStatement,
    ],
    parent: databaseAdminClient.instancePath(projectId, instanceId),
  });

  console.log(`Waiting for creation of ${databaseId} to complete...`);
  await operation.promise();
  console.log(
    `Created database ${databaseId} with default leader ${defaultLeader}.`
  );
}
createDatabaseWithDefaultLeader();

Observação: os exemplos de código de interface da biblioteca de cliente antiga para Node.js estão arquivados em GitHub:

PHP

Para aprender a instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;
use Google\Cloud\Spanner\Admin\Database\V1\CreateDatabaseRequest;

/**
 * Creates a database and tables for sample data.
 * Example:
 * ```
 * create_database($instanceId, $databaseId);
 * ```
 *
 * @param string $projectId The Google Cloud project ID.
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function create_database(string $projectId, string $instanceId, string $databaseId): void
{
    $databaseAdminClient = new DatabaseAdminClient();
    $instance = $databaseAdminClient->instanceName($projectId, $instanceId);

    $operation = $databaseAdminClient->createDatabase(
        new CreateDatabaseRequest([
            'parent' => $instance,
            'create_statement' => sprintf('CREATE DATABASE `%s`', $databaseId),
            'extra_statements' => [
                'CREATE TABLE Singers (' .
                'SingerId     INT64 NOT NULL,' .
                'FirstName    STRING(1024),' .
                'LastName     STRING(1024),' .
                'SingerInfo   BYTES(MAX),' .
                'FullName     STRING(2048) AS' .
                '(ARRAY_TO_STRING([FirstName, LastName], " ")) STORED' .
                ') PRIMARY KEY (SingerId)',
                'CREATE TABLE Albums (' .
                    'SingerId     INT64 NOT NULL,' .
                    'AlbumId      INT64 NOT NULL,' .
                    'AlbumTitle   STRING(MAX)' .
                ') PRIMARY KEY (SingerId, AlbumId),' .
                'INTERLEAVE IN PARENT Singers ON DELETE CASCADE'
            ]
        ])
    );

    print('Waiting for operation to complete...' . PHP_EOL);
    $operation->pollUntilComplete();

    printf('Created database %s on instance %s' . PHP_EOL,
        $databaseId, $instanceId);
}

Observação: os exemplos de código de interface da biblioteca de cliente antiga para PHP estão arquivados em GitHub:

Python

Para aprender a instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

def create_database(instance_id, database_id):
    """Creates a database and tables for sample data."""
    from google.cloud.spanner_admin_database_v1.types import \
        spanner_database_admin

    spanner_client = spanner.Client()
    database_admin_api = spanner_client.database_admin_api

    request = spanner_database_admin.CreateDatabaseRequest(
        parent=database_admin_api.instance_path(spanner_client.project, instance_id),
        create_statement=f"CREATE DATABASE `{database_id}`",
        extra_statements=[
            """CREATE TABLE Singers (
            SingerId     INT64 NOT NULL,
            FirstName    STRING(1024),
            LastName     STRING(1024),
            SingerInfo   BYTES(MAX),
            FullName   STRING(2048) AS (
                ARRAY_TO_STRING([FirstName, LastName], " ")
            ) STORED
        ) PRIMARY KEY (SingerId)""",
            """CREATE TABLE Albums (
            SingerId     INT64 NOT NULL,
            AlbumId      INT64 NOT NULL,
            AlbumTitle   STRING(MAX)
        ) PRIMARY KEY (SingerId, AlbumId),
        INTERLEAVE IN PARENT Singers ON DELETE CASCADE""",
        ],
    )

    operation = database_admin_api.create_database(request=request)

    print("Waiting for operation to complete...")
    database = operation.result(OPERATION_TIMEOUT_SECONDS)

    print(
        "Created database {} on instance {}".format(
            database.name,
            database_admin_api.instance_path(spanner_client.project, instance_id),
        )
    )

Observação: os exemplos de código de interface da biblioteca de cliente antiga para Python estão arquivados em GitHub:

Ruby

Para aprender a instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

require "google/cloud/spanner"
require "google/cloud/spanner/admin/database"

database_admin_client = Google::Cloud::Spanner::Admin::Database.database_admin

instance_path = database_admin_client.instance_path project: project_id, instance: instance_id

job = database_admin_client.create_database parent: instance_path,
                                            create_statement: "CREATE DATABASE `#{database_id}`",
                                            extra_statements: [
                                              "CREATE TABLE Singers (
      SingerId     INT64 NOT NULL,
      FirstName    STRING(1024),
      LastName     STRING(1024),
      SingerInfo   BYTES(MAX)
    ) PRIMARY KEY (SingerId)",

                                              "CREATE TABLE Albums (
      SingerId     INT64 NOT NULL,
      AlbumId      INT64 NOT NULL,
      AlbumTitle   STRING(MAX)
    ) PRIMARY KEY (SingerId, AlbumId),
    INTERLEAVE IN PARENT Singers ON DELETE CASCADE"
                                            ]

puts "Waiting for create database operation to complete"

job.wait_until_done!

puts "Created database #{database_id} on instance #{instance_id}"

Atualizar o esquema ou as opções do banco de dados

É possível atualizar o esquema e as opções do banco de dados usando instruções DDL.

Por exemplo, para adicionar uma coluna a uma tabela, use a seguinte instrução DDL:

GoogleSQL

ALTER TABLE Songwriters ADD COLUMN Publisher STRING(10);

PostgreSQL

ALTER TABLE Songwriters ADD COLUMN Publisher VARCHAR(10);

Para atualizar a versão do otimizador de consultas, use a seguinte instrução DDL:

GoogleSQL

ALTER DATABASE Music SET OPTIONS(optimizer_version=null);

PostgreSQL

ALTER DATABASE DB-NAME SET spanner.optimizer_version TO DEFAULT;

Para mais informações sobre as opções compatíveis, consulte a referência de DDL ALTER DATABASE do GoogleSQL ou do PostgreSQL.

Para informações sobre atualizações de esquema, consulte Fazer atualizações de esquema.

Console

1. Acesse a página Instâncias no console do Google Cloud.

   Instâncias

2. Selecione a instância que contém o banco de dados a ser alterado.

3. Selecione o banco de dados.

4. Clique em Spanner Studio.

5. Clique em Nova guia ou use a guia do editor vazia. Em seguida, insira as instruções DDL a serem aplicadas.

6. Clique em Executar para aplicar as atualizações. Se houver erros no DDL, o console do Google Cloud retorna um erro e o banco de dados alterados.

gcloud

Para alterar um banco de dados com a ferramenta de linha de comando gcloud, use gcloud spanner databases ddl update.

gcloud spanner databases ddl update \
(DATABASE : --instance=INSTANCE) \
[--async] \
[--ddl=DDL] \
[--ddl-file=DDL_FILE] \

Consulte a referência de gcloud para detalhes sobre as opções disponíveis.

Transmita as atualizações do banco de dados para o comando com a flag --ddl ou a --ddl-file. Se um arquivo DDL for especificado, a sinalização --ddl será ignorada.

Consulte a referência da DDL ALTER DATABASE para GoogleSQL ou PostgreSQL para que as instruções DDL sejam incluídas.

DDL

Consulte a referência DDL ALTER DATABASE do GoogleSQL ou do PostgreSQL para mais detalhes.

Verificar o progresso das operações de atualização do esquema

Console

1. No menu de navegação do Spanner, selecione a guia Operações. A página Operações mostra uma lista das operações em execução.

2. Encontre a operação de esquema na lista. Se ainda estiver em execução, a barra de progresso na coluna End time vai mostrar a porcentagem da operação que foi concluída, conforme mostrado na imagem a seguir:

gcloud

Usar gcloud spanner operations describe para verificar o progresso de uma operação.

1. Consiga o ID da operação:

   gcloud spanner operations list --instance=INSTANCE-NAME \
   --database=DATABASE-NAME --type=DATABASE_UPDATE_DDL

   Substitua:

   • INSTANCE-NAME com o nome da instância do Spanner.
   • DATABASE-NAME pelo nome do banco de dados.

2. Execute gcloud spanner operations describe:

   gcloud spanner operations describe OPERATION_ID\
   --instance=INSTANCE-NAME \
   --database=DATABASE-NAME

   Substitua:

   • OPERATION-ID: o ID da operação que você quer verificação.
   • INSTANCE-NAME: o nome da instância do Spanner.
   • DATABASE-NAME: o nome do banco de dados do Spanner.

   A seção progress na saída mostra a porcentagem da operação que está completa. A saída será assim:

   done: true
   metadata:
   ...
     progress:
     - endTime: '2022-03-01T00:28:06.691403Z'
       progressPercent: 100
       startTime: '2022-03-01T00:28:04.221401Z'
     - endTime: '2022-03-01T00:28:17.624588Z'
       startTime: '2022-03-01T00:28:06.691403Z'
       progressPercent: 100
   ...

REST v1

1. Consiga o ID da operação:

   gcloud spanner operations list --instance=INSTANCE-NAME \
   --database=DATABASE-NAME --type=DATABASE_UPDATE_DDL

   Substitua:

   • INSTANCE-NAME pela instância do Spanner nome.
   • DATABASE-NAME pelo nome do banco de dados.

2. Verifique o progresso da operação.

   Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

   • PROJECT-ID: o ID do projeto.
   • INSTANCE-ID: o ID da instância
   • DATABASE-ID: o ID do banco de dados.
   • OPERATION-ID: o ID da operação.

   Método HTTP e URL:

   GET https://spanner.googleapis.com/v1/projects/PROJECT-ID/instances/INSTANCE-ID/databases/DATABASE-ID/operations/OPERATION-ID

   Para enviar a solicitação, expanda uma destas opções:

   curl (Linux, macOS ou Cloud Shell)

   Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . É possível verificar a conta ativa atual executando gcloud auth list.

   execute o seguinte comando:

   curl -X GET \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        "https://spanner.googleapis.com/v1/projects/PROJECT-ID/instances/INSTANCE-ID/databases/DATABASE-ID/operations/OPERATION-ID"

   PowerShell (Windows)

   Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

   execute o seguinte comando:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method GET `
       -Headers $headers `
       -Uri "https://spanner.googleapis.com/v1/projects/PROJECT-ID/instances/INSTANCE-ID/databases/DATABASE-ID/operations/OPERATION-ID" | Select-Object -Expand Content

   Você receberá uma resposta JSON semelhante a esta:

   {
   ...
       "progress": [
         {
           "progressPercent": 100,
           "startTime": "2023-05-27T00:52:27.366688Z",
           "endTime": "2023-05-27T00:52:30.184845Z"
         },
         {
           "progressPercent": 100,
           "startTime": "2023-05-27T00:52:30.184845Z",
           "endTime": "2023-05-27T00:52:40.750959Z"
         }
       ],
   ...
     "done": true,
     "response": {
       "@type": "type.googleapis.com/google.protobuf.Empty"
     }
   }
   
   

Se a operação demorar muito, você pode cancelá-la. Para mais informações, consulte Cancelar uma operação de banco de dados de longa duração.

Excluir um banco de dados

A exclusão de um banco de dados remove permanentemente o banco de dados e todos os respectivos dados. Não é possível desfazer a exclusão do banco de dados. Se a proteção contra exclusão do banco de dados estiver ativado em um banco de dados, ele não pode ser excluído até que você desative seus proteção contra exclusão.

Os backups atuais não são excluídos quando um banco de dados é excluído. Para mais informações, consulte Backup e restauração.

Console

1. Acesse a página Instâncias no console do Google Cloud.

   Instâncias

2. Selecione a instância que contém o banco de dados a ser excluído.

3. Selecione o banco de dados.

4. Clique em Excluir banco de dados. Uma confirmação vai aparecer.

5. Digite o nome do banco de dados e clique em Excluir.

gcloud

Para excluir um banco de dados com a ferramenta de linha de comando gcloud, use gcloud spanner databases delete.

gcloud spanner databases delete \
  (DATABASE : --instance=INSTANCE)

As seguintes opções são obrigatórias:

DATABASE

ID do banco de dados ou identificador totalmente qualificado para o banco de dados. Se o identificador totalmente qualificado for fornecido, o --instance a sinalização deve ser omitida.

--instance=INSTANCE

A instância do Spanner para o banco de dados.

Para mais detalhes, consulte a referência gcloud.

DDL

A DDL não oferece suporte à sintaxe de exclusão de banco de dados.

A seguir

• Crie um banco de dados e o carregue com dados de amostra.
• Saiba mais sobre a referência de DDL do GoogleSQL.
• Saiba mais sobre a referência da DDL do PostgreSQL.
• Saiba como fazer backup e restaurar um banco de dados.
• Saiba como evitar a exclusão acidental de bancos de dados.
• Saiba como fazer atualizações de esquema.