Datenbanken erstellen und verwalten

Auf dieser Seite wird beschrieben, wie Sie Spanner-Datenbanken erstellen und verwalten:

• Verschiedene Methoden zum Erstellen einer Datenbank
• Datenbankoptionen ändern
• Datenbank löschen

Diese Seite enthält Informationen zu Datenbanken im GoogleSQL-Dialekt und im PostgreSQL-Dialekt. Informationen zum Aktualisieren eines Datenbankschemas finden Sie unter Schemaaktualisierungen vornehmen. Weitere Informationen zum Erstellen einer Instanz finden Sie unter Instanzen erstellen und verwalten. Sie können eine Datenbank in einer vorhandenen Instanz auf eine der folgenden Arten erstellen:

• Datenbank erstellen: Sie können eine neue Datenbank erstellen, indem Sie den SQL-Dialekt auswählen und Ihr Schema definieren.
• Eigene Daten importieren: Sie können eine CSV-, MySQL-Dump- oder PostgreSQL-Dumpdatei in eine neue oder vorhandene Datenbank importieren.
• Cloud SQL-Datenbank importieren: Sie können eine Cloud SQL for MySQL-Datenbank in Spanner importieren.
• Datenbank mit Beispieldaten erstellen: Sie können eine Datenbank mit einem der verfügbaren Beispiel-Datasets füllen, um die Funktionen von Spanner auszuprobieren.

Datenbank erstellen

Sie können eine neue Datenbank in einer vorhandenen Instanz erstellen. Bei Datenbanken mit GoogleSQL-Dialekt können Sie das Datenbankschema entweder beim Erstellen der Datenbank oder nach dem Erstellen der Datenbank definieren. Bei Datenbanken mit PostgreSQL-Dialekt müssen Sie das Schema nach dem Erstellen definieren.

Schemas werden mit der Database Definition Language definiert, die für GoogleSQL und PostgreSQL dokumentiert ist. Weitere Informationen zum Erstellen und Aktualisieren von Schemas finden Sie unter den folgenden Links:

• Schema und Datenmodell
• Best Practices für Schemadesign
• Schemaaktualisierungen

Nachdem Sie Ihre Datenbank erstellt haben, können Sie Datenbanken, die für Ihre Anwendungen und Dienste wichtig sind, durch Aktivieren des Löschschutzes für Datenbanken schützen. Weitere Informationen finden Sie unter Versehentliches Löschen der Datenbank verhindern.

Google Cloud Console

1. Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

   Zu Spanner-Instanzen

2. Wählen Sie die Instanz aus, in der die Datenbank erstellt werden soll.

3. Klicken Sie auf Datenbank erstellen.

4. Geben Sie die folgenden Werte ein:

   • Einen Datenbanknamen, der in der Google Cloud Console angezeigt werden soll.
   • Der Dialekt, der für diese Datenbank verwendet werden soll.
   • Geben Sie für GoogleSQL-Dialekt-Datenbanken optional eine Reihe von DDL-Anweisungen an, die Ihr Schema definieren. Verwenden Sie die DDL-Vorlagen, um gängige Elemente vorauszufüllen. Wenn Ihre DDL-Anweisungen Fehler enthalten, gibt die Google Cloud Console einen Fehler zurück, wenn Sie versuchen, die Datenbank zu erstellen.
   • Optional können Sie einen kundenverwalteten Verschlüsselungsschlüssel für diese Datenbank auswählen.

5. Klicken Sie auf Erstellen, um die Datenbank zu erstellen.

gcloud

Führen Sie den Befehl gcloud spanner databases create aus.

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

Folgende Optionen sind erforderlich:

DATABASE

ID der Datenbank oder voll qualifizierte Kennung für die Datenbank. Wenn Sie die voll qualifizierte Kennung angeben, kann das Flag --instance weggelassen werden.

--instance=INSTANCE

Die Spanner-Instanz für die Datenbank.

Folgende Optionen sind optional:

--async

Sofort zurückkehren, ohne auf den Abschluss des laufenden Vorgangs zu warten.

--database-dialect=DATABASE_DIALECT

Der SQL-Dialekt der Spanner-Datenbank. Muss einer der folgenden Werte sein: POSTGRESQL, GOOGLE_STANDARD_SQL.

--ddl=DDL

Durch Semikolons getrennte DDL-Anweisungen (Datendefinitionssprache), die in der neu erstellten Datenbank ausgeführt werden sollen. Wenn in einer Anweisung ein Fehler auftritt, wird die Datenbank nicht erstellt. Dieses Flag wird ignoriert, wenn --ddl_file festgelegt ist. Wird von Datenbanken im PostgreSQL-Dialekt nicht unterstützt.

--ddl-file=DDL_FILE

: Pfad einer Datei, die durch Semikolons getrennte DDL-Anweisungen (Datendefinitionssprache) enthält, die in der neu erstellten Datenbank ausgeführt werden sollen. Wenn in einer Anweisung ein Fehler auftritt, wird die Datenbank nicht erstellt. Wenn --ddl_file festgelegt ist, wird --ddl ignoriert. Wird von Datenbanken im PostgreSQL-Dialekt nicht unterstützt.

Wenn Sie einen Cloud Key Management Service-Schlüssel angeben, der beim Erstellen der Datenbank verwendet werden soll, fügen Sie die folgenden Optionen hinzu:

--kms-key=KMS_KEY

ID des Schlüssels oder voll qualifizierte Kennung für den Schlüssel.

Dieses Flag muss angegeben werden, wenn eines der anderen Argumente in dieser Gruppe angegeben ist. Die anderen Argumente können weggelassen werden, wenn die voll qualifizierte Kennzeichnung angegeben wird.

--kms-keyring=KMS_KEYRING

Cloud KMS-Schlüsselbund-ID des Schlüssels.

--kms-location=KMS_LOCATION

Google Cloud Speicherort für den Schlüssel.

--kms-project=KMS_PROJECT

Google Cloud Projekt-ID für den Schlüssel.

Client (GoogleSQL)

C++

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Hinweis: Die alten Codebeispiele für die Clientbibliotheksschnittstelle für Java sind auf GitHub archiviert.

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Hinweis: Die alten Codebeispiele für die Clientbibliotheksschnittstelle für Node.js sind in GitHub archiviert.

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Hinweis: Die alten Codebeispiele für die Clientbibliotheksschnittstelle für PHP sind in GitHub archiviert.

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Hinweis: Die alten Codebeispiele für die Clientbibliotheksschnittstelle für Python sind auf GitHub archiviert.

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Client (PostgreSQL)

C++

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

void CreateDatabase(google::cloud::spanner_admin::DatabaseAdminClient client,
                    google::cloud::spanner::Database const& database) {
  google::spanner::admin::database::v1::CreateDatabaseRequest request;
  request.set_parent(database.instance().FullName());
  request.set_create_statement("CREATE DATABASE \"" + database.database_id() +
                               "\"");
  request.set_database_dialect(
      google::spanner::admin::database::v1::DatabaseDialect::POSTGRESQL);
  auto db = client.CreateDatabase(request).get();
  if (!db) throw std::move(db).status();
  std::cout << "Database " << db->name() << " created.\n";
}

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

// pgCreateDatabase shows how to create a Spanner database that uses the
// PostgreSQL dialect.
func pgCreateDatabase(ctx context.Context, w io.Writer, db string) error {
	// db := "projects/my-project/instances/my-instance/databases/my-database"
	matches := regexp.MustCompile("^(.*)/databases/(.*)$").FindStringSubmatch(db)
	if matches == nil || len(matches) != 3 {
		return fmt.Errorf("invalid database id %v", db)
	}

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

	// Databases with PostgreSQL dialect do not support extra DDL statements in the `CreateDatabase` call.
	req := &adminpb.CreateDatabaseRequest{
		Parent:          matches[1],
		DatabaseDialect: adminpb.DatabaseDialect_POSTGRESQL,
		// Note that PostgreSQL uses double quotes for quoting identifiers. This also
		// includes database names in the CREATE DATABASE statement.
		CreateStatement: `CREATE DATABASE "` + matches[2] + `"`,
	}
	opCreate, err := adminClient.CreateDatabase(ctx, req)
	if err != nil {
		return err
	}
	if _, err := opCreate.Wait(ctx); err != nil {
		return err
	}
	updateReq := &adminpb.UpdateDatabaseDdlRequest{
		Database: db,
		Statements: []string{
			`CREATE TABLE Singers (
				SingerId   bigint NOT NULL PRIMARY KEY,
				FirstName  varchar(1024),
				LastName   varchar(1024),
				SingerInfo bytea
			)`,
			`CREATE TABLE Albums (
				AlbumId      bigint NOT NULL,
				SingerId     bigint NOT NULL REFERENCES Singers (SingerId),
				AlbumTitle   text,
                PRIMARY KEY(SingerId, AlbumId)
			)`,
			`CREATE TABLE Venues (
				VenueId  bigint NOT NULL PRIMARY KEY,
				Name     varchar(1024) NOT NULL
			)`,
		},
	}
	opUpdate, err := adminClient.UpdateDatabaseDdl(ctx, updateReq)
	if err != nil {
		return err
	}
	if err := opUpdate.Wait(ctx); err != nil {
		return err
	}
	fmt.Fprintf(w, "Created Spanner PostgreSQL database [%v]\n", db)
	return nil
}

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

static void createPostgreSqlDatabase(
    DatabaseAdminClient dbAdminClient, String projectId, String instanceId, String databaseId) {
  final CreateDatabaseRequest request =
      CreateDatabaseRequest.newBuilder()
          .setCreateStatement("CREATE DATABASE \"" + databaseId + "\"")
          .setParent(InstanceName.of(projectId, instanceId).toString())
          .setDatabaseDialect(DatabaseDialect.POSTGRESQL).build();

  try {
    // Initiate the request which returns an OperationFuture.
    Database db = dbAdminClient.createDatabaseAsync(request).get();
    System.out.println("Created database [" + db.getName() + "]");
  } 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);
  }
}
static void createTableUsingDdl(DatabaseAdminClient dbAdminClient, DatabaseName databaseName) {
  try {
    // Initiate the request which returns an OperationFuture.
    dbAdminClient.updateDatabaseDdlAsync(
        databaseName,
        Arrays.asList(
            "CREATE TABLE Singers ("
                + "  SingerId   bigint NOT NULL,"
                + "  FirstName  character varying(1024),"
                + "  LastName   character varying(1024),"
                + "  SingerInfo bytea,"
                + "  FullName character varying(2048) GENERATED "
                + "  ALWAYS AS (FirstName || ' ' || LastName) STORED,"
                + "  PRIMARY KEY (SingerId)"
                + ")",
            "CREATE TABLE Albums ("
                + "  SingerId     bigint NOT NULL,"
                + "  AlbumId      bigint NOT NULL,"
                + "  AlbumTitle   character varying(1024),"
                + "  PRIMARY KEY (SingerId, AlbumId)"
                + ") INTERLEAVE IN PARENT Singers ON DELETE CASCADE")).get();
    System.out.println("Created Singers & Albums tables in database: [" + databaseName + "]");
  } catch (ExecutionException e) {
    // If the operation failed during execution, expose the cause.
    throw SpannerExceptionFactory.asSpannerException(e);
  } 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);
  }
}

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const instanceId = 'my-instance';
// const databaseId = 'my-database';
// const projectId = 'my-project-id';

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

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

const databaseAdminClient = spanner.getDatabaseAdminClient();

async function createPgDatabase() {
  // Creates a PostgreSQL database. PostgreSQL create requests may not contain any additional
  // DDL statements. We need to execute these separately after the database has been created.
  const [operationCreate] = await databaseAdminClient.createDatabase({
    createStatement: 'CREATE DATABASE "' + databaseId + '"',
    parent: databaseAdminClient.instancePath(projectId, instanceId),
    databaseDialect:
      protos.google.spanner.admin.database.v1.DatabaseDialect.POSTGRESQL,
  });

  console.log(`Waiting for operation on ${databaseId} to complete...`);
  await operationCreate.promise();
  const [metadata] = await databaseAdminClient.getDatabase({
    name: databaseAdminClient.databasePath(projectId, instanceId, databaseId),
  });
  console.log(
    `Created database ${databaseId} on instance ${instanceId} with dialect ${metadata.databaseDialect}.`,
  );

  // Create a couple of tables using a separate request. We must use PostgreSQL style DDL as the
  // database has been created with the PostgreSQL dialect.
  const statements = [
    `CREATE TABLE Singers 
      (SingerId   bigint NOT NULL,
      FirstName   varchar(1024),
      LastName    varchar(1024),
      SingerInfo  bytea,
      FullName    character varying(2048) GENERATED ALWAYS AS (FirstName || ' ' || LastName) STORED,
      PRIMARY KEY (SingerId)
      );
      CREATE TABLE Albums 
      (AlbumId    bigint NOT NULL,
      SingerId    bigint NOT NULL REFERENCES Singers (SingerId),
      AlbumTitle  text,
      PRIMARY KEY (AlbumId)
      );`,
  ];
  const [operationUpdateDDL] = await databaseAdminClient.updateDatabaseDdl({
    database: databaseAdminClient.databasePath(
      projectId,
      instanceId,
      databaseId,
    ),
    statements: [statements],
  });
  await operationUpdateDDL.promise();
  console.log('Updated schema');
}
createPgDatabase();

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

/**
 * Creates a database that uses Postgres dialect
 *
 * @param string $projectId The Google Cloud project ID.
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function pg_create_database(string $projectId, string $instanceId, string $databaseId): void
{
    $databaseAdminClient = new DatabaseAdminClient();
    $instance = $databaseAdminClient->instanceName($projectId, $instanceId);
    $databaseName = $databaseAdminClient->databaseName($projectId, $instanceId, $databaseId);

    $table1Query = 'CREATE TABLE Singers (
        SingerId   bigint NOT NULL PRIMARY KEY,
        FirstName  varchar(1024),
        LastName   varchar(1024),
        SingerInfo bytea,
        FullName character varying(2048) GENERATED
        ALWAYS AS (FirstName || \' \' || LastName) STORED
    )';
    $table2Query = 'CREATE TABLE Albums (
        AlbumId      bigint NOT NULL,
        SingerId     bigint NOT NULL REFERENCES Singers (SingerId),
        AlbumTitle   text,
        PRIMARY KEY(SingerId, AlbumId)
    )';

    $operation = $databaseAdminClient->createDatabase(
        new CreateDatabaseRequest([
            'parent' => $instance,
            'create_statement' => sprintf('CREATE DATABASE "%s"', $databaseId),
            'extra_statements' => [],
            'database_dialect' => DatabaseDialect::POSTGRESQL
        ])
    );

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

    $request = new UpdateDatabaseDdlRequest([
        'database' => $databaseName,
        'statements' => [$table1Query, $table2Query]
    ]);

    $operation = $databaseAdminClient->updateDatabaseDdl($request);
    $operation->pollUntilComplete();

    $database = $databaseAdminClient->getDatabase(
        new GetDatabaseRequest(['name' => $databaseAdminClient->databaseName($projectId, $instanceId, $databaseId)])
    );
    $dialect = DatabaseDialect::name($database->getDatabaseDialect());

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

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

def create_database(instance_id, database_id):
    """Creates a PostgreSql 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}"',
        database_dialect=DatabaseDialect.POSTGRESQL,
    )

    operation = database_admin_api.create_database(request=request)

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

    create_table_using_ddl(database.name)
    print("Created database {} on instance {}".format(database_id, instance_id))


def create_table_using_ddl(database_name):
    from google.cloud.spanner_admin_database_v1.types import spanner_database_admin

    spanner_client = spanner.Client()
    request = spanner_database_admin.UpdateDatabaseDdlRequest(
        database=database_name,
        statements=[
            """CREATE TABLE Singers (
  SingerId   bigint NOT NULL,
  FirstName  character varying(1024),
  LastName   character varying(1024),
  SingerInfo bytea,
  FullName   character varying(2048)
    GENERATED ALWAYS AS (FirstName || ' ' || LastName) STORED,
  PRIMARY KEY (SingerId)
  )""",
            """CREATE TABLE Albums (
  SingerId     bigint NOT NULL,
  AlbumId      bigint NOT NULL,
  AlbumTitle   character varying(1024),
  PRIMARY KEY (SingerId, AlbumId)
  ) INTERLEAVE IN PARENT Singers ON DELETE CASCADE""",
        ],
    )
    operation = spanner_client.database_admin_api.update_database_ddl(request)
    operation.result(OPERATION_TIMEOUT_SECONDS)

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

def postgresql_create_database project_id:, instance_id:, database_id:
  # project_id  = "Your Google Cloud project ID"
  # instance_id = "Your Spanner instance ID"
  # database_id = "Your Spanner database ID"

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

  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}\"",
                                              database_dialect: :POSTGRESQL

  puts "Waiting for create database operation to complete"

  job.wait_until_done!

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

Importieren Sie eigene Daten

Sie können Ihre eigenen Daten mithilfe einer CSV-Datei, einer MySQL-Dumpdatei oder einer PostgreSQL-Dumpdatei in eine Cloud Spanner-Datenbank importieren. Sie können eine lokale Datei mit Cloud Storage oder direkt aus einem Cloud Storage-Bucket hochladen. Für das Hochladen einer lokalen Datei mit Cloud Storage können Gebühren anfallen.

Wenn Sie eine CSV-Datei verwenden, müssen Sie auch eine separate JSON-Datei hochladen, die das Datenbankschema enthält.

Google Cloud Console

1. Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

   Zu Spanner-Instanzen

2. Wählen Sie die Instanz aus, in der die Datenbank erstellt werden soll.

3. Klicken Sie auf Eigene Daten importieren.

4. Geben Sie die folgenden Werte ein:

   • Wählen Sie den Dateityp aus.

   • Laden Sie die Datei von Ihrem Computer hoch oder wählen Sie einen Cloud Storage-Bucket-Pfad zur Datei aus.

   • (Optional) Wenn Sie eine CSV-Datei verwenden, müssen Sie auch eine separate JSON-Datei mit dem Datenbankschema hochladen. Die JSON-Datei muss die folgende Struktur verwenden, um das Schema zu definieren:

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

     Ersetzen Sie Folgendes:

     • COLUMN_NAME: der Name der Spalte in der Tabelle.

     • TYPE: der Datentyp der Spalte.

     • (Optional) NOT_NULL_VALUE: Gibt an, ob die Spalte Nullwerte speichern kann oder nicht. Gültige Eingaben sind true oder false. Die Standardeinstellung ist false.

     • (Optional): PRIMARY_KEY_ORDER: Bestimmt die Reihenfolge der Primärschlüssel. Legen Sie den Wert für eine Spalte, die kein Primärschlüssel ist, auf 0 fest. Legen Sie den Wert auf eine Ganzzahl fest, z. B. 1 für eine Primärschlüsselspalte. Spalten mit niedrigeren Nummern werden in einem zusammengesetzten Primärschlüssel früher angezeigt.

     In der CSV-Datei wird standardmäßig ein Komma als Feldtrennzeichen und ein Zeilenumbruch als Zeilentrennzeichen erwartet. Weitere Informationen zur Verwendung benutzerdefinierter Trennzeichen finden Sie in der Referenz zu gcloud alpha spanner databases import.

   • Wählen Sie eine neue oder vorhandene Datenbank als Ziel aus.

5. Klicken Sie auf Importieren.

6. Cloud Spanner öffnet Cloud Shell und füllt einen Befehl aus, der das Cloud Spanner-Migrationstool installiert und den Befehl gcloud alpha spanner databases import ausführt. Drücken Sie die Taste ENTER, um Daten in Ihre Datenbank zu importieren.

Datenbank aus Cloud SQL importieren

Wenn Sie Cloud SQL for MySQL verwenden und Spanner testen möchten, können Sie Daten aus Ihrer Cloud SQL for MySQL-Instanz in Spanner importieren. Mit dieser Funktion wird das MySQL-Schema konvertiert und ein entsprechendes Spanner-Schema generiert. Anschließend werden Daten aus der Cloud SQL for MySQL-Datenbank in Cloud Spanner geladen.

Mit dieser Funktion wird nur ein einmaliger Bulk-Datenladevorgang ausgeführt. Das Erfassen von Live-Datenänderungen oder ein Fallback von Spanner auf Ihre Quelldatenbank wird nicht unterstützt.

Weitere Informationen finden Sie unter Aus Cloud SQL in Cloud Spanner importieren.

Beispiel-Dataset verwenden

Wenn Sie Spanner Graph, die Vektorsuche oder das relationale Modell ausprobieren möchten, können Sie eine neue Datenbank erstellen, die mit einem Beispieldataset vorab ausgefüllt ist. Die verfügbaren Beispieldatasets hängen vom ausgewählten Datenbankdialekt (GoogleSQL oder PostgreSQL) ab.

1. Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

   Zu Spanner-Instanzen

2. Wählen Sie die Instanz aus, in der die Datenbank erstellt werden soll.

3. Klicken Sie auf Datasets ansehen.

4. Wählen Sie je nach Datenbankdialekt ein Dataset aus:

   GoogleSQL

   • Finanzdiagramm: Mit diesem Dataset können Sie die Diagramm- und relationalen Datenbankfunktionen von Spanner kennenlernen.
   • Onlinebanking: Mit diesem Dataset können Sie die Volltextsuche und die Vektorsuche von Cloud Spanner kennenlernen.
   • Online-Gaming: Mit diesem Dataset können Sie die Funktionen der relationalen Datenbank von Spanner kennenlernen.
   • Einzelhandel: Verwenden Sie dieses Dataset, um die Funktionen von Cloud Spanner für Graphen, Volltextsuche und Vektorsuche kennenzulernen.

   PostgreSQL

   • Onlinebanking: Mit diesem Dataset können Sie die Volltextsuche von Cloud Spanner kennenlernen.
   • Online-Gaming: Mit diesem Dataset können Sie die Funktionen der relationalen Datenbank von Spanner kennenlernen.
   • Einzelhandel: Mit diesem Dataset können Sie die Funktionen von Cloud Spanner für die Volltextsuche und die Vektorsuche kennenlernen.

5. Klicken Sie auf Datenbank erstellen.

Datenbankschema oder ‑optionen aktualisieren

Sie können Ihr Datenbankschema und Ihre Optionen mit DDL-Anweisungen aktualisieren.

Wenn Sie beispielsweise einer Tabelle eine Spalte hinzufügen möchten, verwenden Sie die folgende DDL-Anweisung:

GoogleSQL

ALTER TABLE Songwriters ADD COLUMN Publisher STRING(10);

PostgreSQL

ALTER TABLE Songwriters ADD COLUMN Publisher VARCHAR(10);

Verwenden Sie die folgende DDL-Anweisung, um die Version des Abfrageoptimierers zu aktualisieren:

GoogleSQL

ALTER DATABASE Music SET OPTIONS(optimizer_version=null);

PostgreSQL

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

Weitere Informationen zu unterstützten Optionen finden Sie in der ALTER DATABASE-DDL-Referenz für GoogleSQL oder PostgreSQL.

Informationen zu Schemaaktualisierungen finden Sie unter Schemaaktualisierungen vornehmen.

Google Cloud Console

1. Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

   Zu Spanner-Instanzen

2. Wählen Sie die Instanz mit der Datenbank aus, die Sie ändern möchten.

3. Wählen Sie die Datenbank aus.

4. Klicken Sie auf Spanner Studio.

5. Klicken Sie auf Neuer Tab oder verwenden Sie den leeren Editor-Tab. Geben Sie dann die anzuwendenden DDL-Anweisungen ein.

6. Klicken Sie auf Ausführen, um die Änderungen zu übernehmen. Wenn Ihre DDL Fehler enthält, gibt die Google Cloud Console einen Fehler zurück und die Datenbank wird nicht geändert.

gcloud

Wenn Sie eine Datenbank mit dem gcloud-Befehlszeilentool ändern möchten, verwenden Sie gcloud spanner databases ddl update.

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

Weitere Informationen zu den verfügbaren Optionen finden Sie in der Referenz zu gcloud.

Übergeben Sie die Datenbankaktualisierungen mit dem Flag --ddl oder dem Flag --ddl-file an den Befehl. Wenn eine DDL-Datei angegeben ist, wird das Flag --ddl ignoriert.

Informationen zu den einzuschließenden DDL-Anweisungen finden Sie in der ALTER DATABASE-DDL-Referenz für GoogleSQL oder PostgreSQL.

DDL

Weitere Informationen finden Sie in der ALTER DATABASE-DDL-Referenz für GoogleSQL oder PostgreSQL.

Fortschritt von Schemaupdatevorgängen prüfen

Wählen Sie eine der folgenden Methoden aus, um den Fortschritt der Schemaupdates zu prüfen:

Google Cloud Console

1. Wählen Sie im Spanner-Navigationsmenü den Tab Vorgänge aus. Auf der Seite Vorgänge wird eine Liste der aktiven laufenden Vorgänge angezeigt.

2. Suchen Sie in der Liste nach dem Schemavorgang. Wenn der Vorgang noch läuft, wird in der Fortschrittsanzeige in der Spalte Endzeit der Prozentsatz des abgeschlossenen Vorgangs angezeigt, wie in der folgenden Abbildung dargestellt:

gcloud

Verwenden Sie gcloud spanner operations describe, um den Fortschritt eines Vorgangs zu prüfen.

1. Rufen Sie die Vorgangs-ID ab:

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

   Ersetzen Sie Folgendes:

   • INSTANCE-NAME durch den Namen der Cloud Spanner-Instanz.
   • DATABASE-NAME durch den Namen der Datenbank.

2. Führen Sie gcloud spanner operations describe aus.

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

   Ersetzen Sie Folgendes:

   • OPERATION-ID: Die Vorgangs-ID des zu prüfenden Vorgangs.
   • INSTANCE-NAME: Der Name der Spanner-Instanz.
   • DATABASE-NAME: Der Name der Spanner-Datenbank.

   Im Abschnitt progress wird in der Ausgabe der Prozentsatz des abgeschlossenen Vorgangs angezeigt. Die Ausgabe sieht dann ungefähr so aus:

   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 Version 1

1. Rufen Sie die Vorgangs-ID ab:

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

   Ersetzen Sie Folgendes:

   • INSTANCE-NAME durch den Namen der Cloud Spanner-Instanz.
   • DATABASE-NAME durch den Datenbanknamen.

2. Prüfen Sie den Fortschritt des Vorgangs.

   Ersetzen Sie diese Werte in den folgenden Anfragedaten:

   • PROJECT-ID: Projekt-ID.
   • INSTANCE-ID: Instanz-ID.
   • DATABASE-ID: die Datenbank-ID.
   • OPERATION-ID: die Vorgangs-ID.

   HTTP-Methode und URL:

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

   Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

   curl (Linux, macOS oder Cloud Shell)

   Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto in der gcloud-Befehlszeile angemeldet haben, indem Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt haben, die Sie automatisch in der gcloud-Befehlszeile anmeldet. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

   Führen Sie folgenden Befehl aus:

   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)

   Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto in der gcloud-Befehlszeile angemeldet haben, indem Sie gcloud init oder gcloud auth login ausgeführt haben. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

   Führen Sie folgenden Befehl aus:

   $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

   Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

   {
   ...
       "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"
     }
   }
   
   

Wenn der Vorgang zu lange dauert, können Sie ihn abbrechen. Weitere Informationen finden Sie unter Datenbankvorgang mit langer Ausführungszeit abbrechen.

Spanner erkennt auch automatisch Möglichkeiten, Best Practices für das Schemadesign anzuwenden. Wenn Empfehlungen für eine Datenbank verfügbar sind, können Sie sie auf der Seite Spanner Studio für diese Datenbank aufrufen. Weitere Informationen finden Sie unter Best Practices für das Schemadesign ansehen.

Datenbank löschen

Durch das Löschen einer Datenbank werden die Datenbank und alle zugehörigen Daten endgültig entfernt. Das Löschen einer Datenbank kann nicht rückgängig gemacht werden. Wenn der Löschschutz für Datenbanken für eine Datenbank aktiviert ist, können Sie diese Datenbank erst löschen, wenn Sie den Löschschutz deaktiviert haben.

Vorhandene Sicherungen werden nicht gelöscht, wenn eine Datenbank gelöscht wird. Weitere Informationen finden Sie unter Sichern und wiederherstellen.

Google Cloud Console

1. Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

   Zu Spanner-Instanzen

2. Wählen Sie die Instanz aus, die die zu löschende Datenbank enthält.

3. Wählen Sie die Datenbank aus.

4. Klicken Sie auf Datenbank löschen. Eine Bestätigung wird angezeigt.

5. Geben Sie den Datenbanknamen ein und klicken Sie auf Löschen.

gcloud

Verwenden Sie gcloud spanner databases delete, um eine Datenbank mit dem gcloud-Befehlszeilentool zu löschen.

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

Folgende Optionen sind erforderlich:

DATABASE

ID der Datenbank oder voll qualifizierte Kennung für die Datenbank. Wenn die voll qualifizierte Kennung angegeben wird, sollte das Flag --instance weggelassen werden.

--instance=INSTANCE

Die Spanner-Instanz für die Datenbank.

Weitere Informationen finden Sie in der Referenz zu gcloud.

DDL

DDL unterstützt keine Syntax zum Löschen von Datenbanken.

Nächste Schritte

• Datenbank erstellen und mit Beispieldaten laden
• GoogleSQL-DDL-Referenz
• Weitere Informationen zur PostgreSQL-DDL-Referenz
• Datenbank sichern und wiederherstellen
• Versehentliches Löschen von Datenbanken verhindern
• Informationen zum Aktualisieren von Schemas