Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

תחילת השימוש ב-Firestore במצב Datastore API

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

דרישות מוקדמות

יכולת לכתוב ולהריץ אפליקציה בשורת פקודה בשפות התכנות שבהן נעשה שימוש בנושא הזה
בנוסף לידע בסיסי בפיתוח אפליקציות, צריך להיות לכם ידע בהורדה ובהתקנה של ספריות נוספות לפני שתנסו לבצע את ההדרכה הזו.
פרויקט Google Cloud עם Datastore mode API מופעל
אפליקציות שמשתמשות ב-Datastore mode משויכות לפרויקט Google Cloud עם Datastore mode API מופעל. הפרויקט הזה מספק פרטי כניסה לאימות שבהם אתם משתמשים באפליקציה כדי לזהות אותה ב-Google ולאשר את השימוש שלה בממשק ה-API של מצב Datastore.
פועלים לפי ההוראות האלה כדי ליצור פרויקט, להפעיל בו את Datastore mode API ולהגדיר את סביבת הפיתוח המקומית עם פרטי אימות באמצעות הפקודה gcloud auth login. רושמים או זוכרים את מזהה הפרויקט, שבו תשתמשו בהמשך.

התקנה והגדרה

מתקינים ספריות לקוח ומגדירים הגדרות נוספות לסביבת הפיתוח.

C#‎

מוודאים ש-Visual Studio (גרסה 2013 ואילך) מותקן.
מורידים את האפליקציה לדוגמה TaskList ממאגר הדוגמאות.
מחלקים את הקבצים מקובץ ה-ZIP לספרייה בתיקייה Documents.
ב-Visual Studio, פותחים את הקובץ dotnet-docs-samples-master\datastore\api\Datastore.sln.
בחלון Solution Explorer (סייר הפתרונות) של Visual Studio, לוחצים לחיצה ימנית על הפרויקט TaskList (רשימת המשימות) ובוחרים באפשרות Set as StartUp Project (הגדרה כפרויקט הפעלה).
לוחצים לחיצה ימנית על הפרויקט TaskList ובוחרים באפשרות Properties (מאפיינים).
בחלון Properties (מאפיינים), לוחצים על Debug (ניפוי באגים) ומקלידים את המזהה של פרויקטGoogle Cloud בתיבה Command line arguments: (ארגומנטים של שורת הפקודה).
לוחצים על קובץ ואז על שמירה כדי לשמור את השינויים.
מפעילים את האפליקציה. מקישים על F5 במקלדת.

המשך

משכפלים את האפליקציה לדוגמה TaskList.

go get github.com/GoogleCloudPlatform/golang-samples/datastore/tasks

עוברים לספרייה שבה שיבטתם את הדוגמה:

cd $GOPATH/src/github.com/GoogleCloudPlatform/golang-samples/datastore/tasks

בשורת הפקודה, מריצים את הפקודה הבאה, כאשר <project-id> הוא המזהה של פרויקט Google Cloud .
```
export DATASTORE_PROJECT_ID=<project-id>
```
(משתמשי Windows: משתמשים ב-set במקום ב-export).
מפעילים את האפליקציה.
```
go run tasks.go
```

Java

מוודאים ש-Maven ו-Java (גרסה 8 ואילך) מותקנים.
מורידים את האפליקציה לדוגמה TaskList ממאגר הדוגמאות.
בשורת הפקודה, מחלצים את ההורדה:
```
unzip main.zip
```
עוברים לספריות של אפליקציית TaskList:
```
cd java-datastore-main/samples/snippets
```
מריצים את הפקודה הבאה, כאשר <project-id> הוא המזהה של הפרויקט Google Cloud .
```
gcloud config set project <project-id>
```

קומפילציה והרצה של האפליקציה.

mvn clean compile
mvn exec:java -Dexec.mainClass="com.google.datastore.snippets.TaskList"

Node.js

הכנת הסביבה לפיתוח ב-Node.js
מורידים את האפליקציה לדוגמה TaskList ממאגר הדוגמאות.
חילוץ ההורדה:
```
unzip master.zip
```
עוברים לספריות של אפליקציית TaskList:
```
cd nodejs-datastore-master/samples
```
מתקינים את יחסי התלות ומקשרים את האפליקציה:
```
npm install
```
בשורת הפקודה, מריצים את הפקודה הבאה, כאשר <project-id> הוא המזהה של פרויקט Google Cloud .
```
export GCLOUD_PROJECT=<project-id>
```
(משתמשי Windows: משתמשים ב-set במקום ב-export).
מפעילים את האפליקציה.
```
node tasks.js
```

PHP

מוודאים ש-PHP (גרסה 5.6 ואילך) ו-Composer מותקנים.
מורידים את האפליקציה לדוגמה TaskList ממאגר הדוגמאות.
חילוץ ההורדה:
```
unzip master.zip
```
עוברים לספריות של אפליקציית TaskList:
```
cd php-docs-samples-master/datastore/tutorial
```
מתקינים יחסי תלות.
```
composer install
```
מפעילים את האפליקציה.
```
php src/list_tasks.php
```

Python

מוודאים שמותקנים Python (גרסה 2.7.9 ואילך),‏ pip ו-virtualenv.

הפעלת סשן של virtualenv.

virtualenv venv
source venv/bin/activate

מורידים את האפליקציה לדוגמה TaskList ממאגר הדוגמאות.
חילוץ ההורדה:
```
unzip master.zip
```
עוברים לספריות של אפליקציית TaskList:
```
cd python-docs-samples-master/datastore/cloud-client
```
יחסי תלות של התקנות:
```
pip install -r requirements.txt
```
מריצים את האפליקציה! משתמשים במזהה של Google Cloud הפרויקט בשביל <project-id>.
```
python tasks.py new project-id
```

Ruby

מוודאים שRuby ו-Bundler מותקנים.
מורידים את האפליקציה לדוגמה TaskList ממאגר הדוגמאות.
חילוץ ההורדה:
```
unzip master.zip
```

עוברים לספריות של אפליקציית TaskList:

cd google-cloud-ruby-master/google-cloud-datastore/samples

מתקינים את יחסי התלות:
```
bundle install
```
בשורת הפקודה, מריצים את הפקודה הבאה, כאשר <project-id> הוא המזהה של פרויקט Google Cloud .
```
export GOOGLE_CLOUD_PROJECT=<project-id>
```
(משתמשי Windows: משתמשים ב-set במקום ב-export).
מפעילים את האפליקציה.
```
bundle exec ruby tasks.rb
```

יצירת אובייקט שירות מורשה

כדי לשלוח בקשות מאומתות לממשקי Google Cloud API באמצעות ספריות הלקוח של Google APIs, צריך:

שליפת פרטי הכניסה לשימוש בבקשות.
יוצרים אובייקט שירות שמשתמש בפרטי הכניסה האלה.

לאחר מכן אפשר לבצע קריאות ל-API על ידי הפעלת שיטות באובייקט השירות של מצב Datastore.

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

זו הקריאה ליצירת אובייקט שירות מורשה במצב Datastore:

C#

מידע על התקנת ספריית הלקוח של Cloud Datastore ושימוש בה מופיע במאמר ספריות הלקוח של Cloud Datastore. מידע נוסף מופיע במאמרי העזרה של Cloud Datastore C# API.

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

// Create an authorized Datastore service using Application Default Credentials.
_db = DatastoreDb.Create(projectId);
// Create a Key factory to construct keys associated with this project.
_keyFactory = _db.CreateKeyFactory("Task");

Go

מידע על התקנת ספריית הלקוח של Cloud Datastore ושימוש בה מופיע במאמר ספריות הלקוח של Cloud Datastore. מידע נוסף מופיע במאמרי העזרה של Cloud Datastore Go API.

import (
	"context"
	"log"

	"cloud.google.com/go/datastore"
)

func createClient(projectID string) (*datastore.Client, error) {
	ctx := context.Background()
	client, err := datastore.NewClient(ctx, projectID)
	if err != nil {
		log.Fatalf("Could not create datastore client: %v", err)
	}
	// Note: call the following from main() to ensure the client
	// properly frees all resources.
	// defer client.Close()
	return client, nil
}

Java

מידע על התקנת ספריית הלקוח של Cloud Datastore ושימוש בה מופיע במאמר ספריות הלקוח של Cloud Datastore. מידע נוסף מופיע במאמרי העזרה של Cloud Datastore Java API.

// Create an authorized Datastore service using Application Default Credentials.
private final Datastore datastore = DatastoreOptions.getDefaultInstance().getService();

// Create a Key factory to construct keys associated with this project.
private final KeyFactory keyFactory = datastore.newKeyFactory().setKind("Task");

Node.js

מידע על התקנת ספריית הלקוח של Cloud Datastore ושימוש בה מופיע במאמר ספריות הלקוח של Cloud Datastore. מידע נוסף מופיע במאמרי העזרה של Cloud Datastore Node.js API.

// By default, the client will authenticate using the service account file
// specified by the GOOGLE_APPLICATION_CREDENTIALS environment variable and use
// the project specified by the GCLOUD_PROJECT environment variable. See
// https://googlecloudplatform.github.io/google-cloud-node/#/docs/datastore/latest/guides/authentication
const {Datastore} = require('@google-cloud/datastore');

// Creates a client
const datastore = new Datastore();

PHP

מידע על התקנת ספריית הלקוח של Cloud Datastore ושימוש בה מופיע במאמר ספריות הלקוח של Cloud Datastore. מידע נוסף מופיע במאמרי העזרה של Cloud Datastore PHP API.

use Google\Cloud\Datastore\DatastoreClient;

/**
 * Create a Cloud Datastore client.
 *
 * @param string $projectId The Google Cloud project ID.
 */
function build_service(string $projectId)
{
    $datastore = new DatastoreClient(['projectId' => $projectId]);
    return $datastore;
}

Python

מידע על התקנת ספריית הלקוח של Cloud Datastore ושימוש בה מופיע במאמר ספריות הלקוח של Cloud Datastore. מידע נוסף מופיע במאמרי העזרה של Cloud Datastore Python API.

from google.cloud import datastore

def create_client(project_id):
    return datastore.Client(project_id)

Ruby

מידע על התקנת ספריית הלקוח של Cloud Datastore ושימוש בה מופיע במאמר ספריות הלקוח של Cloud Datastore. מידע נוסף מופיע במאמרי העזרה של Cloud Datastore Ruby API.

require "google/cloud/datastore"

datastore = Google::Cloud::Datastore.new

אחסון נתונים

אובייקטים במצב Datastore נקראים ישויות, וכל ישות היא מסוג מסוים. אפליקציית TaskList תאחסן ישויות מסוג Task, עם המאפיינים הבאים:

‫description: מחרוזת שהמשתמש מציין כתיאור המשימה
‫created: תאריך שבו המשימה נוצרה
‫done: ערך בוליאני שמציין אם המשימה הושלמה

כשהמשתמש מוסיף משימה חדשה, אפליקציית TaskList יוצרת ישות Task עם ערכים למאפיינים שצוינו קודם:

C#

/// <summary>
///  Adds a task entity to the Datastore
/// </summary>
/// <param name="description">The task description.</param>
/// <returns>The key of the entity.</returns>
Key AddTask(string description)
{
    Entity task = new Entity()
    {
        Key = _keyFactory.CreateIncompleteKey(),
        ["description"] = new Value()
        {
            StringValue = description,
            ExcludeFromIndexes = true
        },
        ["created"] = DateTime.UtcNow,
        ["done"] = false
    };
    return _db.Insert(task);
}

Go

import (
	"context"
	"log"
	"time"

	"cloud.google.com/go/datastore"
)

// Task is the model used to store tasks in the datastore.
type Task struct {
	Desc    string    `datastore:"description"`
	Created time.Time `datastore:"created"`
	Done    bool      `datastore:"done"`
	id      int64     // The integer ID used in the datastore.
}

// AddTask adds a task with the given description to the datastore,
// returning the key of the newly created entity.
func AddTask(projectID string, desc string) (*datastore.Key, error) {
	ctx := context.Background()
	client, err := datastore.NewClient(ctx, projectID)
	if err != nil {
		log.Fatalf("Could not create datastore client: %v", err)
	}
	defer client.Close()
	task := &Task{
		Desc:    desc,
		Created: time.Now(),
	}
	key := datastore.IncompleteKey("Task", nil)
	return client.Put(ctx, key, task)

}

Java

/**
 * Adds a task entity to the Datastore.
 *
 * @param description The task description
 * @return The {@link Key} of the entity
 * @throws DatastoreException if the ID allocation or put fails
 */
Key addTask(String description) {
  Key key = datastore.allocateId(keyFactory.newKey());
  Entity task =
      Entity.newBuilder(key)
          .set(
              "description",
              StringValue.newBuilder(description).setExcludeFromIndexes(true).build())
          .set("created", Timestamp.now())
          .set("done", false)
          .build();
  datastore.put(task);
  return key;
}

Node.js

async function addTask(description) {
  const taskKey = datastore.key('Task');
  const entity = {
    key: taskKey,
    data: [
      {
        name: 'created',
        value: new Date().toJSON(),
      },
      {
        name: 'description',
        value: description,
        excludeFromIndexes: true,
      },
      {
        name: 'done',
        value: false,
      },
    ],
  };

  try {
    await datastore.save(entity);
    console.log(`Task ${taskKey.id} created successfully.`);
  } catch (err) {
    console.error('ERROR:', err);
  }
}

PHP

use Google\Cloud\Datastore\DatastoreClient;

/**
 * Create a new task with a given description.
 *
 * @param string $projectId The Google Cloud project ID.
 * @param string $description
 */
function add_task(string $projectId, string $description)
{
    $datastore = new DatastoreClient(['projectId' => $projectId]);

    $taskKey = $datastore->key('Task');
    $task = $datastore->entity(
        $taskKey,
        [
            'created' => new DateTime(),
            'description' => $description,
            'done' => false
        ],
        ['excludeFromIndexes' => ['description']]
    );
    $datastore->insert($task);
    printf('Created new task with ID %d.' . PHP_EOL, $task->key()->pathEnd()['id']);
}

Python

from google.cloud import datastore

def add_task(client: datastore.Client, description: str):
    # Create an incomplete key for an entity of kind "Task". An incomplete
    # key is one where Datastore will automatically generate an Id
    key = client.key("Task")

    # Create an unsaved Entity object, and tell Datastore not to index the
    # `description` field
    task = datastore.Entity(key, exclude_from_indexes=("description",))

    # Apply new field values and save the Task entity to Datastore
    task.update(
        {
            "created": datetime.datetime.now(tz=datetime.timezone.utc),
            "description": description,
            "done": False,
        }
    )
    client.put(task)
    return task.key

Ruby

def add_task description
  require "google/cloud/datastore"

  datastore = Google::Cloud::Datastore.new

  task = datastore.entity "Task" do |t|
    t["description"] = description
    t["created"]     = Time.now
    t["done"]        = false
    t.exclude_from_indexes! "description", true
  end

  datastore.save task

  puts task.key.id

  task.key.id
end

בנוסף, אנחנו מספקים שיטה לעדכון הנכס בבקשה הזו, כדי לציין שהמשימה הושלמה:done

C#

/// <summary>
/// Marks a task entity as done.
/// </summary>
/// <param name="id">The ID of the task entity as given by Key.</param>
/// <returns>true if the task was found.</returns>
bool MarkDone(long id)
{
    using (var transaction = _db.BeginTransaction())
    {
        Entity task = transaction.Lookup(_keyFactory.CreateKey(id));
        if (task != null)
        {
            task["done"] = true;
            transaction.Update(task);
        }
        transaction.Commit();
        return task != null;
    }
}

Go

import (
	"context"
	"log"

	"cloud.google.com/go/datastore"
)

// MarkDone marks the task done with the given ID.
func MarkDone(projectID string, taskID int64) error {
	ctx := context.Background()
	client, err := datastore.NewClient(ctx, projectID)
	if err != nil {
		log.Fatalf("Could not create datastore client: %v", err)
	}
	defer client.Close()
	// Create a key using the given integer ID.
	key := datastore.IDKey("Task", taskID, nil)

	// In a transaction load each task, set done to true and store.
	_, err = client.RunInTransaction(ctx, func(tx *datastore.Transaction) error {
		var task Task
		if err := tx.Get(key, &task); err != nil {
			return err
		}
		task.Done = true
		_, err := tx.Put(key, &task)
		return err
	})
	return err
}

Java

/**
 * Marks a task entity as done.
 *
 * @param id The ID of the task entity as given by {@link Key#id()}
 * @return true if the task was found, false if not
 * @throws DatastoreException if the transaction fails
 */
boolean markDone(long id) {
  Transaction transaction = datastore.newTransaction();
  try {
    Entity task = transaction.get(keyFactory.newKey(id));
    if (task != null) {
      transaction.put(Entity.newBuilder(task).set("done", true).build());
    }
    transaction.commit();
    return task != null;
  } finally {
    if (transaction.isActive()) {
      transaction.rollback();
    }
  }
}

Node.js

async function markDone(taskId) {
  const transaction = datastore.transaction();
  const taskKey = datastore.key(['Task', datastore.int(taskId)]);

  try {
    await transaction.run();
    const [task] = await transaction.get(taskKey);
    task.done = true;
    transaction.save({
      key: taskKey,
      data: task,
    });
    await transaction.commit();
    console.log(`Task ${taskId} updated successfully.`);
  } catch (err) {
    await transaction.rollback();
  }
}

PHP

use Google\Cloud\Datastore\DatastoreClient;

/**
 * Mark a task with a given id as done.
 *
 * @param string $projectId The Google Cloud project ID.
 * @param string $taskId
 */
function mark_done(string $projectId, string $taskId)
{
    $datastore = new DatastoreClient(['projectId' => $projectId]);

    $taskKey = $datastore->key('Task', $taskId);
    $transaction = $datastore->transaction();
    $task = $transaction->lookup($taskKey);
    $task['done'] = true;
    $transaction->upsert($task);
    $transaction->commit();
    printf('Task %d updated successfully.' . PHP_EOL, $taskId);
}

Python

from google.cloud import datastore

def mark_done(client: datastore.Client, task_id: str | int):
    with client.transaction():
        # Create a key for an entity of kind "Task", and with the supplied
        # `task_id` as its Id
        key = client.key("Task", task_id)
        # Use that key to load the entity
        task = client.get(key)

        if not task:
            raise ValueError(f"Task {task_id} does not exist.")

        # Update a field indicating that the associated
        # work has been completed
        task["done"] = True

        # Persist the change back to Datastore
        client.put(task)

Ruby

def mark_done task_id
  require "google/cloud/datastore"

  datastore = Google::Cloud::Datastore.new

  task = datastore.find "Task", task_id

  task["done"] = true

  datastore.save task
end

כך מוחקים ישות Task באמצעות המפתח של ישות Task:

C#

/// <summary>
/// Deletes a task entity.
/// </summary>
/// <param name="id">The ID of the task entity as given by Key.</param>
void DeleteTask(long id)
{
    _db.Delete(_keyFactory.CreateKey(id));
}

Go

import (
	"context"
	"log"

	"cloud.google.com/go/datastore"
)

// DeleteTask deletes the task with the given ID.
func DeleteTask(projectID string, taskID int64) error {
	ctx := context.Background()
	client, err := datastore.NewClient(ctx, projectID)
	if err != nil {
		log.Fatalf("Could not create datastore client: %v", err)
	}
	return client.Delete(ctx, datastore.IDKey("Task", taskID, nil))
}

Java

/**
 * Deletes a task entity.
 *
 * @param id The ID of the task entity as given by {@link Key#id()}
 * @throws DatastoreException if the delete fails
 */
void deleteTask(long id) {
  datastore.delete(keyFactory.newKey(id));
}

Node.js

async function deleteTask(taskId) {
  const taskKey = datastore.key(['Task', datastore.int(taskId)]);

  await datastore.delete(taskKey);
  console.log(`Task ${taskId} deleted successfully.`);
}

PHP

use Google\Cloud\Datastore\DatastoreClient;

/**
 * Delete a task with a given id.
 *
 * @param string $projectId The Google Cloud project ID.
 * @param string $taskId
 */
function delete_task(string $projectId, string $taskId)
{
    $datastore = new DatastoreClient(['projectId' => $projectId]);

    $taskKey = $datastore->key('Task', $taskId);
    $datastore->delete($taskKey);

    printf('Task %d deleted successfully.' . PHP_EOL, $taskId);
}

Python

from google.cloud import datastore

def delete_task(client: datastore.Client, task_id: str | int):
    # Create a key for an entity of kind "Task", and with the supplied
    # `task_id` as its Id
    key = client.key("Task", task_id)
    # Use that key to delete its associated document, if it exists
    client.delete(key)

Ruby

def delete_task task_id
  require "google/cloud/datastore"

  datastore = Google::Cloud::Datastore.new

  task = datastore.find "Task", task_id

  datastore.delete task
end

הרצת שאילתה

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

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

עבור האפליקציה הזו, נבצע שאילתה במצב Datastore כדי לאחזר Task ישויות ממוינות לפי זמן היצירה:

C#

/// <summary>
/// Returns a list of all task entities in ascending order of creation time.
/// </summary>
IEnumerable<Entity> ListTasks()
{
    Query query = new Query("Task")
    {
        Order = { { "created", PropertyOrder.Types.Direction.Descending } }
    };
    return _db.RunQuery(query).Entities;
}

Go

import (
	"context"
	"log"

	"cloud.google.com/go/datastore"
)

// ListTasks returns all the tasks in ascending order of creation time.
func ListTasks(projectID string) ([]*Task, error) {
	ctx := context.Background()
	client, err := datastore.NewClient(ctx, projectID)
	if err != nil {
		log.Fatalf("Could not create datastore client: %v", err)
	}

	var tasks []*Task
	// Create a query to fetch all Task entities, ordered by "created".
	query := datastore.NewQuery("Task").Order("created")
	keys, err := client.GetAll(ctx, query, &tasks)
	if err != nil {
		return nil, err
	}

	// Set the id field on each Task from the corresponding key.
	for i, key := range keys {
		tasks[i].id = key.ID
	}

	return tasks, nil
}

Java

/**
 * Returns a list of all task entities in ascending order of creation time.
 *
 * @throws DatastoreException if the query fails
 */
Iterator<Entity> listTasks() {
  Query<Entity> query =
      Query.newEntityQueryBuilder().setKind("Task").setOrderBy(OrderBy.asc("created")).build();
  return datastore.run(query);
}

Node.js

async function listTasks() {
  const query = datastore.createQuery('Task').order('created');

  const [tasks] = await datastore.runQuery(query);
  console.log('Tasks:');
  tasks.forEach(task => {
    const taskKey = task[datastore.KEY];
    console.log(taskKey.id, task);
  });
}

PHP

use Google\Cloud\Datastore\DatastoreClient;

/**
 * Return an iterator for all the tasks in ascending order of creation time.
 *
 * @param string $projectId The Google Cloud project ID.
 */
function list_tasks(string $projectId)
{
    $datastore = new DatastoreClient(['projectId' => $projectId]);

    $query = $datastore->query()
        ->kind('Task')
        ->order('created');
    $result = $datastore->runQuery($query);
    /* @var Entity $task */
    foreach ($result as $index => $task) {
        printf('ID: %s' . PHP_EOL, $task->key()->pathEnd()['id']);
        printf('  Description: %s' . PHP_EOL, $task['description']);
        printf('  Status: %s' . PHP_EOL, $task['done'] ? 'done' : 'created');
        printf('  Created: %s' . PHP_EOL, $task['created']->format('Y-m-d H:i:s e'));
        print(PHP_EOL);
    }
}

Python

from google.cloud import datastore

def list_tasks(client: datastore.Client):
    # Create a query against all of your objects of kind "Task"
    query = client.query(kind="Task")
    query.order = ["created"]

    return list(query.fetch())

Ruby

def list_tasks
  require "google/cloud/datastore"

  datastore = Google::Cloud::Datastore.new

  query = datastore.query("Task").order("created")
  tasks = datastore.run query

  tasks.each do |t|
    puts t["description"]
    puts t["done"] ? "  Done" : "  Not Done"
    puts "  ID: #{t.key.id}"
  end
end

השלבים הבאים

המדריך הזה כולל רק את השלבים הבסיסיים ביותר שנדרשים כדי לבצע קריאות ל-API של מצב Datastore מאפליקציית שורת פקודה. מצב Datastore תומך בעסקאות ACID מהירות וניתנות להרחבה, בשאילתות, באינדקסים ועוד.

למידע נוסף על היכולות של מצב Datastore, אפשר לעיין במאמר מה זה Firestore במצב Datastore?.
מידע על שימוש באמולטור של מצב Datastore במהלך פיתוח האפליקציה זמין במאמר אמולטור של מצב Datastore.

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

דרישות מוקדמות

התקנה והגדרה

C#‎

המשך

Java

Node.js

PHP

Python

Ruby

יצירת אובייקט שירות מורשה

C#

Go

Java

Node.js

PHP

Python

Ruby

אחסון נתונים

C#

Go

Java

Node.js

PHP

Python

Ruby

C#

Go

Java

Node.js

PHP

Python

Ruby

C#

Go

Java

Node.js

PHP

Python

Ruby

הרצת שאילתה

C#

Go

Java

Node.js

PHP

Python

Ruby

השלבים הבאים

תחילת השימוש ב-Firestore במצב Datastore API