Creazione e gestione di database

Questa pagina descrive come gestire un database Spanner, nonché come creare un database, modificare le opzioni del database ed eliminarlo. Per scoprire come aggiornare uno schema di database, consulta Eseguire aggiornamenti dello schema.

Per esercitarti a creare un database e a caricarlo con dati di esempio, consulta il codelab per il tuo primo database.

Crea un database

Gli esempi seguenti mostrano come creare un database in un'istanza esistente.

Per i database dialetti SQL, puoi definire lo schema di database al momento della creazione o dopo la creazione del database. Per i database dialetti PostgreSQL devi definire lo schema dopo la creazione.

Gli schemi vengono definiti utilizzando il Database Definition Language, che è documentato per GoogleSQL e PostgreSQL. Consulta i seguenti link per saperne di più sulla creazione e sull'aggiornamento degli schemi:

• Schema e modello dei dati
• Best practice per la progettazione degli schemi
• Aggiornamenti dello schema

Dopo aver creato il database, puoi salvaguardare i database importanti per le tue applicazioni e i tuoi servizi abilitando la protezione da eliminazione del database. Per ulteriori informazioni, consulta Impedire l'eliminazione accidentale del database.

Console

1. Vai alla pagina Istanze nella console Google Cloud.

   Istanze

2. Seleziona l'istanza in cui creare il database.

3. Fai clic su Crea database.

4. Inserisci i seguenti valori:

   • Un nome del database da visualizzare nella console Google Cloud.
   • Il dialetto da utilizzare per questo database.
   • Per i database dialetti GoogleSQL, puoi fornire facoltativamente un insieme di istruzioni DDL che definiscono il tuo schema. Utilizza i modelli DDL per precompilare gli elementi comuni. Se si verificano errori nelle istruzioni DDL, la console Google Cloud restituisce un errore quando provi a creare il database.
   • (Facoltativo) Seleziona una chiave di crittografia gestita dal cliente da utilizzare per questo database.

5. Fai clic su Crea per creare il database.

gcloud

Usa il 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 …]

Le opzioni sono obbligatorie:

DATABASE

ID del database o identificatore completo del database. Se specifichi l'identificatore completo, il flag --instance può essere omesso.

--instance=INSTANCE

L'istanza Spanner per il database.

Le seguenti opzioni sono facoltative:

--async

Restituisci immediatamente, senza attendere il completamento dell'operazione in corso.

--database-dialect=DATABASE_DIALECT

Il dialetto SQL del database Spanner. Deve essere uno dei seguenti: POSTGRESQL, GOOGLE_STANDARD_SQL.

--ddl=DDL

Istruzioni DDL (DataDefinition Language) (DDL) separate da punto e virgola da eseguire all'interno del database appena creato. Se è presente un errore in un'istruzione, il database non viene creato. Questo flag viene ignorato se viene impostato --ddl_file. Non supportata dai database dialetti PostgreSQL.

--ddl-file=DDL_FILE

Percorso di un file contenente istruzioni DDL (DataDefinition Language) separate da punto e virgola da eseguire all'interno del database appena creato. Se è presente un errore in un'istruzione, il database non viene creato. Se --ddl_file è impostato, --ddl viene ignorato. Non supportata dai database dialetti PostgreSQL.

Se stai specificando una chiave Cloud Key Management Service da utilizzare durante la creazione del database, includi le seguenti opzioni:

--kms-key=KMS_KEY

ID della chiave o identificatore completo della chiave.

È necessario specificare questo flag se uno qualsiasi degli altri argomenti in questo gruppo è specificato. Gli altri argomenti possono essere omessi se viene fornito l'identificatore completo.

--kms-keyring=KMS_KEYRING

ID del keyring Cloud KMS della chiave.

--kms-location=KMS_LOCATION

Località Google Cloud per la chiave.

--kms-project=KMS_PROJECT

ID progetto Google Cloud della chiave.

Client (GoogleSQL)

C++

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta librerie client di Spanner.

Per eseguire l'autenticazione su Spanner, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta librerie client di Spanner.

Per eseguire l'autenticazione su Spanner, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

	database "cloud.google.com/go/spanner/admin/database/apiv1"
	adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
)

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

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta librerie client di Spanner.

Per eseguire l'autenticazione su Spanner, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Nota: gli esempi di codice dell'interfaccia della libreria client precedente per Java vengono archiviati in GitHub.

Node.js

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta librerie client di Spanner.

Per eseguire l'autenticazione su Spanner, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Nota: gli esempi di codice dell'interfaccia della libreria client precedente per Node.js vengono archiviati in GitHub.

PHP

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta librerie client di Spanner.

Per eseguire l'autenticazione su Spanner, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Nota: gli esempi di codice dell'interfaccia della libreria client precedente per PHP vengono archiviati in GitHub.

Python

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta librerie client di Spanner.

Per eseguire l'autenticazione su Spanner, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Nota: gli esempi di codice dell'interfaccia della libreria client precedente per Python vengono archiviati in GitHub.

Ruby

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta librerie client di Spanner.

Per eseguire l'autenticazione su Spanner, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Aggiorna lo schema o le opzioni del database

Puoi aggiornare lo schema e le opzioni del database utilizzando le istruzioni DDL.

Ad esempio, per aggiungere una colonna a una tabella, utilizza la seguente istruzione DDL:

GoogleSQL

ALTER TABLE Songwriters ADD COLUMN Publisher STRING(10);

PostgreSQL

ALTER TABLE Songwriters ADD COLUMN Publisher VARCHAR(10);

Per aggiornare la versione dello strumento di ottimizzazione delle query, utilizza la seguente istruzione DDL:

GoogleSQL

ALTER DATABASE Music SET OPTIONS(optimizer_version=null);

PostgreSQL

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

Per saperne di più sulle opzioni supportate, consulta la documentazione di riferimento DDL di ALTER DATABASE per GoogleSQL o PostgreSQL.

Per informazioni sugli aggiornamenti dello schema, consulta Effettuare aggiornamenti dello schema.

Console

1. Vai alla pagina Istanze nella console Google Cloud.

   Istanze

2. Seleziona l'istanza contenente il database da modificare.

3. Seleziona il database.

4. Fai clic su Spanner Studio.

5. Fai clic su Nuova scheda o utilizza la scheda dell'editor vuota. Quindi, inserisci le istruzioni DDL da applicare.

6. Fai clic su Esegui per applicare gli aggiornamenti. Se si verificano errori nel DDL, la console Google Cloud restituisce un errore e il database non viene modificato.

gcloud

Per modificare un database con lo strumento a riga di comando gcloud, utilizza gcloud spanner databases ddl update.

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

Consulta la documentazione di riferimento di gcloud per i dettagli sulle opzioni disponibili.

Passa gli aggiornamenti del database al comando con il flag --ddl o il flag --ddl-file. Se viene specificato un file DDL, il flag --ddl viene ignorato.

Fai riferimento al riferimento DDL ALTER DATABASE per GoogleSQL o PostgreSQL per le istruzioni DDL da includere.

DDL

Per maggiori dettagli, consulta il riferimento DDL ALTER DATABASE per GoogleSQL o PostgreSQL.

Controllare l'avanzamento delle operazioni di aggiornamento dello schema

Console

1. Nel menu di navigazione di Spanner, seleziona la scheda Operazioni. La pagina Operazioni mostra un elenco delle operazioni attualmente in esecuzione.

2. Trova l'operazione dello schema nell'elenco. Se è ancora in esecuzione, la barra di avanzamento nella colonna Ora di fine mostra la percentuale dell'operazione completata, come mostrato nell'immagine seguente:

gcloud

Utilizza gcloud spanner operations describe per verificare l'avanzamento di un'operazione.

1. Recupera l'ID operazione:

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

   Sostituisci quanto segue:

   • INSTANCE-NAME con il nome dell'istanza Spanner.
   • DATABASE-NAME con il nome del database.

2. Esecuzione gcloud spanner operations describe:

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

   Sostituisci quanto segue:

   • OPERATION-ID: l'ID dell'operazione che vuoi controllare.
   • INSTANCE-NAME: nome dell'istanza Spanner.
   • DATABASE-NAME: il nome del database Spanner.

   La sezione progress nell'output mostra la percentuale dell'operazione completata. L'output è simile al seguente:

   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. Recupera l'ID operazione:

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

   Sostituisci quanto segue:

   • INSTANCE-NAME con il nome dell'istanza Spanner.
   • DATABASE-NAME con il nome del database.

2. Controlla lo stato di avanzamento dell'operazione.

   Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

   • project-id: l'ID progetto.
   • instance-id: l'ID istanza.
   • database-id: l'ID del database.
   • operation-id: l'ID operazione.

   Metodo HTTP e URL:

   GET https://spanner.googleapis.com/v1/projects/project-id/instances/instance-id/databases/database-id/operations/operation-id

   Per inviare la richiesta, espandi una di queste opzioni:

   curl (Linux, macOS o Cloud Shell)

   Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

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

   Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

   Esegui questo 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

   Dovresti ricevere una risposta JSON simile alla seguente:

   {
   ...
       "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 l'operazione richiede troppo tempo, puoi annullarla. Per maggiori informazioni, consulta Annullare un'operazione di database a lunga esecuzione.

Elimina un database

L'eliminazione di un database determina la rimozione permanente di tale database e di tutti i suoi dati. L'eliminazione del database non può essere annullata. Se su un database è abilitata la protezione da eliminazione del database, non puoi eliminare il database finché non ne disabiliti la protezione da eliminazione.

I backup esistenti non vengono eliminati con l'eliminazione di un database. Per ulteriori informazioni, consulta Backup e ripristino.

Console

1. Vai alla pagina Istanze nella console Google Cloud.

   Istanze

2. Seleziona l'istanza contenente il database da eliminare.

3. Seleziona il database.

4. Fai clic su Elimina database. Viene visualizzato un messaggio di conferma.

5. Digita il nome del database e fai clic su Elimina.

gcloud

Per eliminare un database con lo strumento a riga di comando gcloud, utilizza gcloud spanner databases delete.

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

Le opzioni sono obbligatorie:

DATABASE

ID del database o identificatore completo del database. Se viene fornito l'identificatore completo, il flag --instance deve essere omesso.

--instance=INSTANCE

L'istanza Spanner per il database.

Per maggiori dettagli, consulta la documentazione di riferimento di gcloud.

DDL

Il DDL non supporta la sintassi di eliminazione dei database.

Passaggi successivi

• Crea un database e caricalo con dati di esempio.
• Scopri di più sul riferimento DDL di GoogleSQL.
• Scopri di più sul riferimento DDL di PostgreSQL.
• Scopri come eseguire il backup e il ripristino di un database.
• Scopri come impedire l'eliminazione accidentale del database.
• Scopri come eseguire aggiornamenti dello schema.