Creazione e gestione di database

Questa pagina descrive come gestire un database Spanner, inclusa la creazione, la modifica e l'eliminazione di un database. Per scoprire come aggiornare lo schema di un database, consulta Eseguire aggiornamenti dello schema.

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

Crea un database

Gli esempi riportati di seguito mostrano come creare un database in un'istanza esistente.

Per i database in dialetto GoogleSQL, puoi definire lo schema del database al momento della creazione o dopo la creazione. Per i database in dialetto PostgreSQL, devi definire lo schema dopo la creazione.

Gli schemi vengono definiti utilizzando il linguaggio di definizione del database, la cui documentazione è disponibile per GoogleSQL e PostgreSQL. Per maggiori informazioni sulla creazione e sull'aggiornamento degli schemi, consulta i seguenti link:

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

Dopo aver creato il database, puoi salvaguardare i database importanti per le tue applicazioni e i tuoi servizi attivando la protezione dell'eliminazione dei database. Per maggiori informazioni, consulta Impedire l'eliminazione accidentale dei database.

Console

1. Nella console Google Cloud , vai alla pagina Istanze Spanner.

   Vai a Istanze Spanner

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 in dialetto GoogleSQL, fornisci facoltativamente un insieme di istruzioni DDL che definiscono lo schema. Utilizza i modelli DDL per precompilare gli elementi comuni. Se sono presenti errori nelle tue istruzioni DDL, la console Google Cloud restituisce un errore quando provi a creare il database.
   • Se vuoi, seleziona una chiave di crittografia gestita dal cliente da utilizzare per questo database.

5. Fai clic su Crea per creare il database.

gcloud

Utilizza 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 …]

Sono richieste le seguenti opzioni:

DATABASE

ID del database o identificatore completo per il 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

Torna immediatamente senza attendere il completamento dell'operazione in corso.

--database-dialect=DATABASE_DIALECT

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

--ddl=DDL

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

--ddl-file=DDL_FILE

Percorso di un file contenente istruzioni DDL (Data Definition 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 supportato dai database in dialetto PostgreSQL.

Se specifichi una chiave Cloud Key Management Service da utilizzare quando crei il database, includi le seguenti opzioni:

--kms-key=KMS_KEY

ID della chiave o identificatore completo della chiave.

Questo flag deve essere specificato se sono specificati uno o più degli altri argomenti di questo gruppo. Gli altri argomenti possono essere omessi se viene fornito l'identificatore completo.

--kms-keyring=KMS_KEYRING

ID della raccolta di chiavi Cloud KMS della chiave.

--kms-location=KMS_LOCATION

La posizione della chiave in

Google Cloud .

--kms-project=KMS_PROJECT

L'ID progetto

Google Cloud per la chiave.

Client (GoogleSQL)

C++

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

Per autenticarti a Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori 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";
}

Vai

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

Per autenticarti a Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori 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 "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

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

Per autenticarti a Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori 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 vecchia libreria client per Java sono archiviati su GitHub.

Node.js

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

Per autenticarti a Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori 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 vecchia libreria client per Node.js sono archiviati su GitHub.

PHP

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

Per autenticarti a Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori 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 vecchia libreria client per PHP sono archiviati su GitHub.

Python

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

Per autenticarti a Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori 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 vecchia libreria client per Python sono archiviati su GitHub.

Ruby

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

Per autenticarti a Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori 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 ulteriori informazioni sulle opzioni supportate, consulta la documentazione di riferimento ALTER DATABASE DDL per GoogleSQL o PostgreSQL.

Per informazioni sugli aggiornamenti dello schema, consulta Eseguire 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 editor vuota. Quindi, inserisci le istruzioni DDL da applicare.

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

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] \

Per dettagli sulle opzioni disponibili, consulta la documentazione di riferimento di gcloud.

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

Consulta la ALTER DATABASEdocumentazione di riferimento DDL per GoogleSQL o PostgreSQL per conoscere gli statement DDL da includere.

DDL

Per maggiori dettagli, consulta la documentazione di riferimento ALTER DATABASE DDL 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 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 controllare 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. Esegui gcloud spanner operations describe:

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

   Sostituisci quanto segue:

   • OPERATION-ID: l'ID operazione dell'operazione da controllare.
   • INSTANCE-NAME: il 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 l'avanzamento dell'operazione.

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

   • PROJECT-ID: l'ID progetto.
   • INSTANCE-ID: l'ID istanza.
   • DATABASE-ID: l'ID 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 seguente comando 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 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 alla CLI 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 ulteriori informazioni, consulta Annullare un'operazione di database di lunga durata.

Eliminare 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 la protezione dall'eliminazione del database è abilitata su un database, non puoi eliminarlo finché non disattivi la protezione dall'eliminazione.

I backup esistenti non vengono eliminati quando viene eliminato un database. Per ulteriori informazioni, consulta Eseguire il backup e il 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 visualizzata una 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)

Sono richieste le seguenti opzioni:

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 ulteriori dettagli, consulta il riferimento gcloud.

DDL

DDL non supporta la sintassi di eliminazione del database.

Passaggi successivi

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