Creazione e gestione di database

Questa pagina descrive come creare e gestire i database Spanner:

• Vari metodi per creare un database
• Modifica le opzioni del database
• Eliminare un database

Questa pagina contiene informazioni sia per i database con dialetto GoogleSQL sia per quelli con dialetto PostgreSQL. Per scoprire come aggiornare uno schema del database, consulta Esegui aggiornamenti dello schema. Per saperne di più sulla creazione di un'istanza, consulta Creare e gestire istanze. Puoi creare un database in un'istanza esistente in uno dei seguenti modi:

• Crea un database: puoi creare un nuovo database selezionando il dialetto SQL e definendo lo schema.
• Importa i tuoi dati: puoi importare un file CSV, un dump MySQL o un dump PostgreSQL in un database nuovo o esistente.
• Crea un database con dati di esempio: puoi popolare un database utilizzando uno dei set di dati di esempio disponibili per provare le funzionalità di Spanner.

Crea un database

Puoi creare un nuovo database in un'istanza esistente. Per i database con dialetto GoogleSQL, puoi definire lo schema del database al momento della creazione del database o dopo la sua creazione. Per i database con dialetto PostgreSQL, devi definire lo schema dopo la creazione.

Gli schemi sono definiti utilizzando il linguaggio di definizione del database, documentato per GoogleSQL e PostgreSQL. Per saperne di più sulla creazione e l'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 proteggere quelli importanti per le tue applicazioni e i tuoi servizi attivando la protezione da eliminazione del database. Per maggiori informazioni, vedi Impedire l'eliminazione accidentale del database.

Console Google Cloud

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

   Vai alle istanze Spanner

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

3. Fai clic su Crea database.

4. Inserisci i seguenti valori:

   • Un nome database da visualizzare nella console Google Cloud .
   • Il dialetto da utilizzare per questo database.
   • Per i database con dialetto GoogleSQL, fornisci facoltativamente un insieme di istruzioni DDL che definiscono lo schema. Utilizza i modelli DDL per precompilare gli elementi comuni. Se ci sono 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

Utilizza il comando gcloud spanner databases create.

```sh
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 del database. Se specifichi l'identificatore completo, puoi omettere il flag --instance.

--instance=INSTANCE

L'istanza Spanner per il database.

Le seguenti opzioni sono facoltative:

--async

Restituisce 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 un'istruzione contiene un errore, il database non viene creato. Questo flag viene ignorato se è impostato --ddl_file. Non supportato dai database con 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 si verifica un errore in un'istruzione, il database non viene creato. Se --ddl_file è impostato, --ddl viene ignorato. Non supportato dai database con 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 uno qualsiasi degli altri argomenti di 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

Google Cloud per la chiave.

--kms-project=KMS_PROJECT

Google Cloud ID progetto per la chiave.

Client (GoogleSQL)

C++

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

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta 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 la sezione Librerie client Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta 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 la sezione Librerie client Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta 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:i vecchi esempi di codice dell'interfaccia della libreria client per Java sono archiviati su GitHub.

Node.js

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

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta 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:i vecchi esempi di codice dell'interfaccia della libreria client per Node.js sono archiviati su GitHub.

PHP

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

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta 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:i vecchi esempi di codice dell'interfaccia della libreria client per PHP sono archiviati su GitHub.

Python

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

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta 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:i vecchi esempi di codice dell'interfaccia della libreria client per Python sono archiviati in GitHub.

Ruby

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

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta 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}"

Importa i tuoi dati

Puoi importare i tuoi dati in un database Spanner utilizzando un file CSV, un file di dump MySQL o un file di dump PostgreSQL. Puoi caricare un file locale utilizzando Cloud Storage o direttamente da un bucket Cloud Storage. Il caricamento di un file locale utilizzando Cloud Storage potrebbe comportare costi.

Se scegli di utilizzare un file CSV, devi anche caricare un file JSON separato che contiene lo schema del database.

Console Google Cloud

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

   Vai alle istanze Spanner

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

3. Fai clic su Importa i miei dati.

4. Inserisci i seguenti valori:

   • Seleziona il Tipo di file.

   • Carica il file dal computer o seleziona un percorso del bucket Cloud Storage al file.

   • (Facoltativo) Se scegli di utilizzare un file CSV, devi anche caricare un file JSON separato contenente lo schema del database. Il file JSON deve utilizzare la seguente struttura per definire lo schema:

     {
       "name": "COLUMN_NAME",
       "type": "TYPE",
       "notNull": NOT_NULL_VALUE,
       "primaryKeyOrder": PRIMARY_KEY_ORDER
     }

     Sostituisci quanto segue:

     • COLUMN_NAME: il nome della colonna nella tabella.

     • TYPE: il tipo di dati della colonna.

     • (Facoltativo) NOT_NULL_VALUE: indica se la colonna può memorizzare valori nulli o meno. Gli input validi sono true o false. Il valore predefinito è false.

     • (Facoltativo): PRIMARY_KEY_ORDER: determina l'ordine della chiave primaria. Imposta il valore su 0 per una colonna della chiave non primaria. Imposta il valore su un numero intero, ad esempio 1 per una colonna della chiave primaria. Le colonne con numeri più bassi vengono visualizzate prima in una chiave primaria composta.

     Per impostazione predefinita, il file CSV prevede una virgola come delimitatore di campo e una nuova riga come delimitatore di riga. Per ulteriori informazioni sull'utilizzo di delimitatori personalizzati, consulta il riferimento gcloud alpha spanner databases import.

   • Seleziona un database nuovo o esistente come destinazione.

5. Fai clic su Importa.

6. Spanner apre Cloud Shell e compila un comando che installa lo strumento di migrazione di Spanner ed esegue il comando gcloud alpha spanner databases import. Premi il tasto ENTER per importare i dati nel database.

Utilizzare un set di dati di esempio

Puoi popolare nuovi database in un'istanza esistente con set di dati di esempio che ti aiutano a esplorare le funzionalità di Spanner, come il modello relazionale, la ricerca a testo intero o la ricerca vettoriale.

Console Google Cloud

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

   Vai alle istanze Spanner

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

3. Fai clic su Esplora i set di dati.

4. Seleziona uno dei seguenti set di dati:

   • Grafico finanziario: utilizza questo set di dati per esplorare le funzionalità grafiche di Spanner.
   • Online banking: utilizza questo set di dati per esplorare le funzionalità di ricerca a testo intero di Spanner.
   • Giochi online: utilizza questo set di dati per esplorare le funzionalità del database relazionale di Spanner.
   • Vendita al dettaglio: utilizza questo set di dati per esplorare le funzionalità di grafico e di ricerca a testo intero di Spanner.

5. Fai clic su Crea database.

Aggiornare 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 il riferimento DDL per GoogleSQL o PostgreSQL.ALTER DATABASE

Per informazioni sugli aggiornamenti dello schema, vedi Esegui aggiornamenti dello schema.

Console Google Cloud

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

   Vai alle istanze Spanner

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

Per informazioni dettagliate sulle opzioni disponibili, consulta il riferimento gcloud.

Trasferisci 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.

Consulta il ALTER DATABASEriferimento DDL per GoogleSQL o PostgreSQL per le istruzioni DDL da includere.

DDL

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

Controllare l'avanzamento delle operazioni di aggiornamento dello schema

Console Google Cloud

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

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

gcloud

Utilizza gcloud spanner operations describe per controllare 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 il nome dell'istanza Spanner.
   • DATABASE-NAME con il nome del database.

2. Corsa 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 che vuoi controllare.
   • INSTANCE-NAME: il nome dell'istanza Spanner.
   • DATABASE-NAME: il nome del database Spanner.

   La sezione progress nell'output mostra la percentuale di completamento dell'operazione. 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 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 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 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 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 saperne di più, consulta Annullare un'operazione di database a esecuzione prolungata.

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

I backup esistenti non vengono eliminati quando viene eliminato un database. Per ulteriori informazioni, vedi Backup e ripristino.

Console Google Cloud

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

   Vai alle istanze Spanner

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 maggiori 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ù sul riferimento DDL di PostgreSQL.
• Scopri come eseguire il backup e il ripristino di un database.
• Scopri come prevenire l'eliminazione accidentale del database.
• Scopri come eseguire aggiornamenti dello schema.