יצירה וניהול של מסדי נתונים

בדף הזה מוסבר איך ליצור ולנהל מסדי נתונים של Spanner:

• שיטות שונות ליצירת מסד נתונים
• שינוי אפשרויות מסד הנתונים
• מחיקה של מסד נתונים

בדף הזה יש מידע על מסדי נתונים של GoogleSQL ושל PostgreSQL. במאמר ביצוע עדכונים בסכימה מוסבר איך לעדכן סכימת מסד נתונים. מידע נוסף על יצירת מופע זמין במאמר בנושא יצירה וניהול של מופעים. אפשר ליצור מסד נתונים במופע קיים באחת מהדרכים הבאות:

• יצירת מסד נתונים: אפשר ליצור מסד נתונים חדש על ידי בחירת ניב SQL והגדרת הסכימה.
• ייבוא נתונים משלכם: אתם יכולים לייבא קובץ CSV, קובץ dump של MySQL או קובץ dump של PostgreSQL למסד נתונים חדש או קיים.
• יצירת מסד נתונים עם נתונים לדוגמה: אתם יכולים לאכלס מסד נתונים באמצעות אחד ממערכי הנתונים לדוגמה שזמינים כדי לנסות את היכולות של Spanner.

יצירת מסד נתונים

אפשר ליצור מסד נתונים חדש במופע קיים. במסדי נתונים של GoogleSQL, אפשר להגדיר את הסכימה של מסד הנתונים בזמן יצירת מסד הנתונים או אחרי שהוא נוצר. במסדי נתונים עם ניב PostgreSQL, צריך להגדיר את הסכימה אחרי היצירה.

סכימות מוגדרות באמצעות שפת הגדרת מסד נתונים (DDL), שמתועדת ב-GoogleSQL וב-PostgreSQL. בקישורים הבאים מפורט מידע נוסף על יצירה ועדכון של סכימות:

• סכימה ומודל נתונים
• שיטות מומלצות לעיצוב סכימה
• עדכוני סכימה

אחרי שיוצרים את מסד הנתונים, אפשר להפעיל הגנה מפני מחיקה כדי להגן על מסדי נתונים שחשובים לאפליקציות ולשירותים. מידע נוסף זמין במאמר בנושא מניעת מחיקה לא מכוונת של מסד נתונים.

מסוף Google Cloud

1. נכנסים לדף Spanner instances במסוף Google Cloud .

   כניסה לדף Spanner instances

2. בוחרים את המופע שבו רוצים ליצור את מסד הנתונים.

3. לוחצים על יצירת מסד נתונים.

4. מזינים את הערכים הבאים:

   • שם מסד נתונים שיוצג במסוף Google Cloud .
   • הדיאלקט שבו יש להשתמש במסד הנתונים הזה.
   • במסדי נתונים של ניב GoogleSQL, אפשר לספק קבוצה של הצהרות DDL שמגדירות את הסכימה. אפשר להשתמש בתבניות DDL כדי למלא מראש רכיבים נפוצים. אם יש שגיאות בהצהרות DDL, המסוף מחזיר שגיאה כשמנסים ליצור את מסד הנתונים. Google Cloud
   • אופציונלי: בוחרים מפתח הצפנה בניהול הלקוח לשימוש במסד הנתונים הזה.

5. לוחצים על יצירה כדי ליצור את מסד הנתונים.

gcloud

משתמשים בפקודה 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 …]
```

חובה לציין את האפשרויות הבאות:

DATABASE

המזהה של מסד הנתונים או מזהה מוגדר במלואו של מסד הנתונים. אם מציינים את המזהה המוגדר במלואו, אפשר להשמיט את הדגל --instance.

--instance=INSTANCE

המכונה של Spanner למסד הנתונים.

האפשרויות הבאות הן אופציונליות:

--async

‫

חזרה מיידית, בלי המתנה שהפעולה תסתיים.

--database-dialect=DATABASE_DIALECT

דיאלקט ה-SQL של מסד הנתונים Spanner. צריך להשתמש באחד מהערכים הבאים: POSTGRESQL, GOOGLE_STANDARD_SQL.

--ddl=DDL

הצהרות DDL (שפת הגדרת נתונים) מופרדות באמצעות נקודה-פסיק להפעלה בתוך מסד הנתונים החדש שנוצר. אם יש שגיאה באחת מההצהרות, מסד הנתונים לא נוצר. המערכת מתעלמת מהדגל הזה אם הדגל --ddl_file מוגדר. לא נתמך במסדי נתונים של ניב PostgreSQL.

--ddl-file=DDL_FILE

‫

הנתיב של קובץ שמכיל הצהרות DDL (שפת הגדרת נתונים) שמופרדות באמצעות נקודה-פסיק, להרצה במסד הנתונים החדש שנוצר. אם יש שגיאה באחת מההצהרות, מסד הנתונים לא נוצר. אם המדיניות --ddl_file מוגדרת, המערכת מתעלמת מהמדיניות --ddl. לא נתמך במסדי נתונים של ניב PostgreSQL.

אם מציינים מפתח Cloud Key Management Service לשימוש בזמן יצירת מסד הנתונים, צריך לכלול את האפשרויות הבאות:

--kms-key=KMS_KEY

‫

ID of the key או מזהה מוגדר במלואו של המפתח.

חובה לציין את הדגל הזה אם מציינים אחד או יותר מהארגומנטים האחרים בקבוצה הזו. אפשר להשמיט את הארגומנטים האחרים אם מספקים את המזהה המוגדר במלואו.

--kms-keyring=KMS_KEYRING

‫

מזהה אוסף המפתחות של המפתח ב-Cloud KMS.

--kms-location=KMS_LOCATION

Google Cloud המיקום של המפתח.

--kms-project=KMS_PROJECT

Google Cloud מזהה הפרויקט של המפתח.

לקוח (GoogleSQL)

C++‎

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

הערה: דוגמאות הקוד של הממשק הישן של ספריית הלקוח ל-Java מאוחסנות בארכיון ב-GitHub.

Node.js

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

הערה: דוגמאות הקוד של הממשק הישן של ספריית הלקוח ל-Node.js מאוחסנות בארכיון ב-GitHub.

PHP

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

הערה: דוגמאות הקוד של הממשק הישן של ספריית הלקוח ל-PHP מאוחסנות בארכיון ב-GitHub.

Python

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

הערה: דוגמאות הקוד של הממשק הישן של ספריית הלקוח ל-Python מאוחסנות בארכיון ב-GitHub.

Ruby

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

לקוח (PostgreSQL)

C++‎

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

/**
 * 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

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

מידע על התקנת ספריית הלקוח של Spanner ושימוש בה מופיע במאמר ספריות הלקוח של Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

ייבאו נתונים משלכם

אפשר לייבא נתונים משלכם למסד נתונים של Spanner באמצעות קובץ CSV, קובץ dump של MySQL או קובץ dump של PostgreSQL. אתם יכולים להעלות קובץ מקומי באמצעות Cloud Storage או ישירות מקטגוריה של Cloud Storage. יכול להיות שיהיו חיובים על העלאה של קובץ מקומי באמצעות Cloud Storage.

אם בחרתם להשתמש בקובץ CSV, תצטרכו גם להעלות קובץ JSON נפרד שמכיל את סכימת מסד הנתונים.

מסוף Google Cloud

1. נכנסים לדף Spanner Instances במסוף Google Cloud .

   כניסה לדף Spanner instances

2. בוחרים את המופע שבו רוצים ליצור את מסד הנתונים.

3. לוחצים על ייבוא הנתונים שלי.

4. מזינים את הערכים הבאים:

   • בוחרים את סוג הקובץ.

   • מעלים את הקובץ מהמחשב או בוחרים נתיב לקובץ בקטגוריה של Cloud Storage.

   • (אופציונלי) אם בוחרים להשתמש בקובץ CSV, צריך גם להעלות קובץ JSON נפרד שמכיל את סכימת מסד הנתונים. קובץ ה-JSON צריך להיות מובנה בפורמט הבא כדי להגדיר את הסכימה:

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

     מחליפים את מה שכתוב בשדות הבאים:

     • ‫COLUMN_NAME: שם העמודה בטבלה.

     • ‫TYPE: סוג הנתונים של העמודה.

     • (אופציונלי) NOT_NULL_VALUE: האם אפשר לאחסן בעמודה ערכי null. הערכים הקבילים הם true או false. ברירת המחדל היא false.

     • (אופציונלי): PRIMARY_KEY_ORDER: קובע את סדר המפתח הראשי. הערך מוגדר כ-0 בעמודה של מפתח שאינו ראשי. מגדירים את הערך כמספר שלם, לדוגמה, 1 לעמודה של מפתח ראשי. עמודות עם מספרים נמוכים יותר מופיעות מוקדם יותר במפתח ראשי מורכב.

     כברירת מחדל, קובץ ה-CSV מצפה לפסיק כמפריד השדות ולשורה חדשה כמפריד השורות. מידע נוסף על השימוש בתווים מותאמים אישית להפרדה בין ערכים זמין במאמר בנושא gcloud alpha spanner databases import.

   • בוחרים מסד נתונים חדש או קיים כיעד.

5. לוחצים על Import.

6. מערכת Spanner פותחת את Cloud Shell ומאכלסת פקודה שמתקינה את כלי ההעברה של Spanner ומריצה את הפקודה gcloud alpha spanner databases import. לוחצים על המקש ENTER כדי לייבא נתונים למסד הנתונים.

שימוש במערך נתונים לדוגמה

אתם יכולים לאכלס מסדי נתונים חדשים במופע קיים מתוך מערכי נתונים לדוגמה, שיעזרו לכם לבדוק את היכולות של Spanner, כמו המודל הרלציוני, חיפוש טקסט מלא או חיפוש וקטורי.

מסוף Google Cloud

1. נכנסים לדף Spanner instances במסוף Google Cloud .

   כניסה לדף Spanner instances

2. בוחרים את המופע שבו רוצים ליצור את מסד הנתונים.

3. לוחצים על סקירת מערכי הנתונים.

4. בוחרים באחד ממערכי הנתונים הבאים:

   • תרשים פיננסי: אפשר להשתמש במערך הנתונים הזה כדי לבחון את תכונות התרשים של Spanner.
   • בנקאות דיגיטלית: אפשר להשתמש במערך הנתונים הזה כדי לבדוק את התכונות של חיפוש טקסט מלא ב-Spanner.
   • משחקים אונליין: אפשר להשתמש במערך הנתונים הזה כדי לבחון את התכונות של מסד הנתונים הרלציוני של Spanner.
   • קמעונאות: אפשר להשתמש במערך הנתונים הזה כדי לבדוק את התכונות של Spanner: גרף וחיפוש טקסט מלא.

5. לוחצים על יצירת מסד נתונים.

עדכון הסכימה או האפשרויות של מסד הנתונים

אפשר לעדכן את סכימת מסד הנתונים ואת האפשרויות באמצעות הצהרות DDL.

לדוגמה, כדי להוסיף עמודה לטבלה, משתמשים בהצהרת ה-DDL הבאה:

GoogleSQL

ALTER TABLE Songwriters ADD COLUMN Publisher STRING(10);

PostgreSQL

ALTER TABLE Songwriters ADD COLUMN Publisher VARCHAR(10);

כדי לעדכן את הגרסה של אופטימיזציית השאילתות, משתמשים בהצהרת ה-DDL הבאה:

GoogleSQL

ALTER DATABASE Music SET OPTIONS(optimizer_version=null);

PostgreSQL

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

למידע נוסף על האפשרויות הנתמכות, אפשר לעיין בהפניה ל-ALTER DATABASE DDL ל-GoogleSQL או ל-PostgreSQL.

מידע על עדכוני סכימה זמין במאמר ביצוע עדכוני סכימה.

מסוף Google Cloud

1. נכנסים לדף Spanner instances במסוף Google Cloud .

   כניסה לדף Spanner instances

2. בוחרים את המופע שמכיל את מסד הנתונים שרוצים לשנות.

3. בוחרים את מסד הנתונים.

4. לוחצים על Spanner Studio.

5. לוחצים על כרטיסייה חדשה או משתמשים בכרטיסיית העריכה הריקה. לאחר מכן מזינים את הצהרות ה-DDL שרוצים להחיל.

6. לוחצים על הפעלה כדי להחיל את העדכונים. אם יש שגיאות ב-DDL, המסוף Google Cloud מחזיר שגיאה ומסד הנתונים לא משתנה.

gcloud

כדי לשנות מסד נתונים באמצעות כלי שורת הפקודה gcloud, משתמשים בפקודה gcloud spanner databases ddl update.

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

אפשר לעיין בהפניה ל-gcloud כדי לקבל פרטים על האפשרויות הזמינות.

מעבירים את העדכונים במסד הנתונים לפקודה עם הדגל --ddl או הדגל --ddl-file. אם מציינים קובץ DDL, המערכת מתעלמת מהדגל --ddl.

אפשר לעיין בהפניה ל-DDL של GoogleSQL או של PostgreSQL כדי לראות אילו הצהרות DDL צריך לכלול.ALTER DATABASE

DDL

פרטים נוספים זמינים ALTER DATABASE בהפניה ל-DDL עבור GoogleSQL או PostgreSQL.

בדיקת ההתקדמות של פעולות עדכון הסכימה

כדי לבדוק את התקדמות הפעולות של עדכון הסכימה, בוחרים באחת מהשיטות הבאות:

מסוף Google Cloud

1. בתפריט הניווט של Spanner, בוחרים בכרטיסייה Operations (פעולות). בדף Operations מוצגת רשימה של פעולות פעילות שמתבצעות.

2. מחפשים ברשימה את פעולת הסכימה. אם הפעולה עדיין פועלת, סרגל ההתקדמות בעמודה שעת סיום מציג את אחוז הפעולה שהושלם, כמו שמוצג בתמונה הבאה:

gcloud

כדי לבדוק את התקדמות הפעולה, משתמשים ב-gcloud spanner operations describe.

1. קבלת מזהה הפעולה:

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

   מחליפים את מה שכתוב בשדות הבאים:

   • ‫INSTANCE-NAME בשם של מכונת Spanner.
   • DATABASE-NAME בשם של מסד הנתונים.

2. מריצים את gcloud spanner operations describe:

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

   מחליפים את מה שכתוב בשדות הבאים:

   • ‫OPERATION-ID: מזהה הפעולה שרוצים לבדוק.
   • ‫INSTANCE-NAME: שם מכונת Spanner.
   • ‫DATABASE-NAME: שם מסד הנתונים של Spanner.

   בקטע progress בפלט מוצג האחוז של הפעולה שהושלמה. הפלט אמור להיראות כך:

   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. קבלת מזהה הפעולה:

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

   מחליפים את מה שכתוב בשדות הבאים:

   • ‫INSTANCE-NAME בשם של מכונת Spanner.
   • ‫DATABASE-NAME בשם מסד הנתונים.

2. בודקים את התקדמות הפעולה.

   לפני שמשתמשים בנתוני הבקשה, צריך להחליף את הנתונים הבאים:

   • ‫PROJECT-ID: מזהה הפרויקט.
   • ‫INSTANCE-ID: מזהה המכונה.
   • ‫DATABASE-ID: מזהה מסד הנתונים.
   • ‫OPERATION-ID: מזהה הפעולה.

   ה-method של ה-HTTP וכתובת ה-URL:

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

   כדי לשלוח את הבקשה צריך להרחיב אחת מהאפשרויות הבאות:

   ‫Curl (Linux,‏ macOS או Cloud Shell)

   הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login, או באמצעות Cloud Shell שמחבר אתכם אוטומטית ל-CLI של gcloud. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

   מריצים את הפקודה הבאה:

   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)

   הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

   מריצים את הפקודה הבאה:

   $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

   אתם אמורים לקבל תגובת JSON שדומה לזו:

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

אם הפעולה נמשכת יותר מדי זמן, אפשר לבטל אותה. מידע נוסף זמין במאמר בנושא ביטול פעולת מסד נתונים ממושכת.

בנוסף, Spanner מזהה באופן אוטומטי הזדמנויות ליישום שיטות מומלצות לעיצוב סכימה. אם יש המלצות למסד נתונים, אפשר לראות אותן בדף Spanner Studio של מסד הנתונים הזה. מידע נוסף זמין במאמר בנושא המלצות לשיטות מומלצות לעיצוב סכימה.

מחיקה של מסד נתונים

מחיקה של מסד נתונים מסירה אותו ואת כל הנתונים שבו באופן סופי. אי אפשר לבטל את מחיקת מסד הנתונים. אם ההגנה מפני מחיקת מסד נתונים מופעלת במסד נתונים, אי אפשר למחוק את מסד הנתונים הזה עד שמשביתים את ההגנה מפני מחיקה.

גיבויים קיימים לא נמחקים כשמוחקים מסד נתונים. מידע נוסף זמין במאמר גיבוי ושחזור.

מסוף Google Cloud

1. נכנסים לדף Spanner instances במסוף Google Cloud .

   כניסה לדף Spanner instances

2. בוחרים את המופע שמכיל את מסד הנתונים שרוצים למחוק.

3. בוחרים את מסד הנתונים.

4. לוחצים על מחיקת מסד הנתונים. מופיע אישור.

5. מקלידים את שם מסד הנתונים ולוחצים על מחיקה.

gcloud

כדי למחוק מסד נתונים באמצעות כלי שורת הפקודה gcloud, משתמשים בפקודה gcloud spanner databases delete.

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

חובה לציין את האפשרויות הבאות:

DATABASE

מזהה מסד הנתונים או מזהה מוגדר במלואו של מסד הנתונים. אם מספקים את המזהה המלא, אין צורך להוסיף את הדגל --instance.

--instance=INSTANCE

המכונה של Spanner למסד הנתונים.

מידע נוסף זמין במאמר gcloud.

DDL

DDL לא תומך בתחביר של מחיקת מסד נתונים.

המאמרים הבאים

• יצירת מסד נתונים וטעינת נתונים לדוגמה
• מידע נוסף על הפניות ל-DDL ב-GoogleSQL
• מידע נוסף על הפניה ל-PostgreSQL DDL
• איך מגבים מסד נתונים ומשחזרים אותו
• איך אפשר למנוע מחיקה מקרית של מסד נתונים
• איך מעדכנים את הסכימה