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

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

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

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

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

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

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

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

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

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

מסוף Google Cloud

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

   כניסה לדף Spanner instances

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

3. לוחצים על Create database.

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

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

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

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

‫

המזהה של המפתח או המזהה המלא של המפתח.

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

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

המשך

במאמר ספריות הלקוח של 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";
}

המשך

במאמר ספריות הלקוח של 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.

ייבוא מסד נתונים מ-Cloud SQL

אם אתם משתמשים ב-Cloud SQL ל-MySQL ורוצים לבדוק את Spanner, אתם יכולים לייבא נתונים ממכונת Cloud SQL ל-MySQL אל Spanner. התכונה הזו ממירה את הסכימה של MySQL ויוצרת סכימה תואמת של Spanner. לאחר מכן, הוא טוען נתונים ממסד הנתונים של Cloud SQL ל-MySQL ל-Spanner.

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

מידע נוסף זמין במאמר ייבוא מ-Cloud SQL ל-Spanner.

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

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

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

   כניסה לדף Spanner instances

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

3. לוחצים על Explore datasets.

4. בוחרים קבוצת נתונים, בהתאם לניב של מסד הנתונים:

   GoogleSQL

   • תרשים פיננסי: משתמשים ב<b>קבוצת נתונים</b> זו כדי לבחון את התכונות של התרשים ומסד הנתונים הרלציוני של Spanner.
   • בנקאות דיגיטלית: קבוצת נתונים שמאפשרת לבחון את התכונות של Spanner לחיפוש טקסט מלא וחיפוש וקטורי.
   • משחקים אונליין: השתמשו בקבוצת הנתונים הזו כדי לבחון את התכונות של מסד הנתונים הרלציוני של Spanner.
   • קמעונאות: משתמשים בקבוצת הנתונים הזו כדי לבחון את התכונות של Spanner: תרשים, חיפוש טקסט מלא וחיפוש וקטורי.

   PostgreSQL

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

5. לוחצים על Create database.

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

אתם יכולים לעדכן את הסכימה והאפשרויות של מסד הנתונים באמצעות הצהרות 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;

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

למידע על עדכוני סכימה, ראו עדכוני סכימה.

מסוף Google Cloud

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

   כניסה לדף Spanner instances

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

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

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

5. לוחצים על New tab או משתמשים בכרטיסיית העריכה הריקה. לאחר מכן, מזינים את הצהרות ה-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 צריך לכלול, עיינו בחומר העזר בנושא DDL של ALTER DATABASE ל-GoogleSQL או ל-PostgreSQL.

DDL

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

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

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

מסוף Google Cloud

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

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

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 אין תמיכה בתחביר למחיקת מסד נתונים.

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

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