Creazione e gestione di database

Questa pagina descrive come gestire uno Spanner database, incluse le istruzioni per creare un database, modificare ed eliminare un database. Per scoprire come aggiornare lo schema di un database, consulta Eseguire aggiornamenti dello schema.

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

Crea un database

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

Per i database di dialetti GoogleSQL, puoi definire il database schema al momento della creazione del database oppure una volta creato il database. Per i database di dialetti PostgreSQL, devi per definire lo schema dopo la creazione.

Gli schemi vengono definiti utilizzando il linguaggio di definizione dei database, documentato per GoogleSQL e PostgreSQL. Consulta i seguenti link per scopri 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 alle tue applicazioni e ai tuoi servizi abilitando la protezione da eliminazione dei database. Per Per saperne di più, 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 di dialetti GoogleSQL, facoltativamente fornire un set di istruzioni DDL che definisci il tuo schema. Utilizza la Modelli DDL per precompilare gli elementi comuni. In caso di errori in le istruzioni DDL, la console Google Cloud restituisce un errore provi a creare il database.
   • Facoltativamente, 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 …]

Sono necessarie le seguenti opzioni:

DATABASE

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

--instance=INSTANCE

L'istanza di Spanner per il database.

Le seguenti opzioni sono facoltative:

--async

Restituisci subito, senza attendere l'operazione in corso per completare l'operazione.

--database-dialect=DATABASE_DIALECT

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

--ddl=DDL

Istruzioni DDL (Data Definition Language) separate da punto e virgola da eseguire all'interno del database appena creato. In caso di errori in una , il database non viene creato. Questo flag viene ignorato se Impostazione --ddl_file impostata. Non supportato dai database di dialetti PostgreSQL.

--ddl-file=DDL_FILE

Percorso di un file contenente valori separati da punto e virgola Istruzioni DDL (Data Definition Language) da eseguire all'interno appena creato. Se c'è un errore in un'istruzione, il database viene non è stato creato. Se il criterio --ddl_file viene impostato, il valore --ddl è ignorato. Non supportato dai database di dialetti 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 uno degli altri argomenti in questo gruppo specificato. Gli altri argomenti possono essere omessi se venga fornito un identificatore completo.

--kms-keyring=KMS_KEYRING

ID del keyring di Cloud KMS della chiave.

--kms-location=KMS_LOCATION

Posizione Google Cloud della chiave.

--kms-project=KMS_PROJECT

ID progetto Google Cloud per la 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 Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 di Spanner.

Per eseguire l'autenticazione su Spanner, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 di Spanner.

Per eseguire l'autenticazione su Spanner, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 sono 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 Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 sono 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 Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 sono 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 Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 sono 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 Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 tuo 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 il DDL ALTER DATABASE di riferimento per GoogleSQL o PostgreSQL.

Per informazioni sugli aggiornamenti dello schema, consulta Aggiorna lo 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 il riquadro dell'editor. Quindi, inserisci le istruzioni DDL da applicare.

6. Fai clic su Esegui per applicare gli aggiornamenti. Se il DDL contiene errori, la console Google Cloud restituisce un errore e il database non modificata.

gcloud

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

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

Consulta le Riferimento gcloud per informazioni dettagliate sulle opzioni disponibili.

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

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

DDL

Fai riferimento al riferimento DDL ALTER DATABASE per GoogleSQL oppure PostgreSQL per i dettagli.

Verificare l'avanzamento delle operazioni di aggiornamento dello schema

Console

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

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

gcloud

Utilizza gcloud spanner operations describe lo stato di 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 l'istanza Spanner nome.
   • DATABASE-NAME con il nome del database.

2. Corsa di 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 da eseguire verifica.
   • INSTANCE-NAME: il nome dell'istanza Spanner.
   • DATABASE-NAME: il nome del database Spanner.

   La sezione progress nell'output mostra la percentuale dell'operazione completato. 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 l'istanza Spanner nome.
   • DATABASE-NAME con il nome del database.

2. Verifica 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 delle seguenti opzioni:

   curl (Linux, macOS o Cloud Shell)

   Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'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 di Google. 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 a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login di Google. 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, vedi Annulla 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. Database l'eliminazione non può essere annullata. Se la protezione da eliminazione del database se è abilitato su un database, non puoi eliminarlo finché non disattivi il relativo e protezione da eliminazione.

I backup esistenti non vengono eliminati quando viene eliminato un database. Per maggiori informazioni informazioni, vedi 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)

Sono necessarie le seguenti opzioni:

DATABASE

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

--instance=INSTANCE

L'istanza di Spanner per il database.

Per ulteriori dettagli, consulta Riferimento 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.