Erste Schritte mit der Firestore in Datastore mode API

Diese Seite enthält eine kurze Übung zum Erstellen einer einfachen TaskList-Befehlszeilenanwendung mit der Firestore in Datastore mode API. Die TaskList-Anwendung speichert, listet, aktualisiert und entfernt Aufgaben.

Vorbereitung

Fähigkeit, eine Befehlszeilenanwendung in den Programmiersprachen zu schreiben und auszuführen, die in diesem Thema verwendet werden
Neben grundlegenden Kenntnissen zur Entwicklung von Anwendungen sollten Sie in der Lage sein, zusätzliche Bibliotheken herunterzuladen und zu installieren, bevor Sie sich mit dieser Anleitung befassen.
Ein Google Cloud Console-Projekt mit aktivierter Datastore mode API
Anwendungen, die den Datastore-Modus verwenden, müssen mit einem Google Cloud Console-Projekt verknüpft sein, für das die Datastore mode API aktiviert ist. Das Projekt stellt Authentifizierungsdaten bereit, mit denen Sie Ihre Anwendung gegenüber Google identifizieren, damit die Nutzung der Datastore mode API autorisiert wird.
Erstellen Sie ein Projekt gemäß dieser Anleitung. Aktivieren Sie die Datastore mode API für das Projekt und richten Sie mit dem Befehl gcloud auth login Ihre lokale Entwicklungsumgebung mit Authentifizierungsdaten ein. Notieren Sie sich die Projekt-ID, die Sie später benötigen.
Eine aktive App Engine-Anwendung
Projekte, die die Datastore mode API verwenden, brauchen eine aktive App Engine-Anwendung. Öffnen Sie das App Engine-Dashboard und prüfen Sie, ob Ihr Projekt eine aktive App Engine-Anwendung hat.
Erstellen Sie gegebenenfalls eine App Engine-Anwendung. Die App darf nicht deaktiviert sein.

Installation und Einrichtung

Installieren Sie Clientbibliotheken und konfigurieren Sie zusätzliche Einstellungen für Ihre Entwicklungsumgebung.

C#

Stellen Sie sicher, dass Visual Studio (Version 2013 oder höher) installiert ist.
Laden Sie die TaskList-Beispielanwendung herunter.
Extrahieren Sie die Dateien aus der ZIP-Datei in ein Verzeichnis in Ihrem Ordner Dokumente.
Öffnen Sie in Visual Studio die Datei dotnet-docs-samples-master\datastore\api\Datastore.sln.
Klicken Sie im Fenster Projektmappen-Explorer von Visual Studio mit der rechten Maustaste auf das TaskList-Projekt und wählen Sie Als Startprojekt festlegen aus.
Klicken Sie mit der rechen Maustaste noch einmal auf das Projekt TaskList und wählen Sie Eigenschaften aus.
Klicken Sie im Fenster Eigenschaften auf Fehlerbehebung und geben Sie die ID Ihres Google Cloud Platform-Projekts in das Feld Befehlszeilenargumente ein.
Klicken Sie auf Datei und danach auf Speichern, um die Änderungen zu speichern.
Führen Sie die Anwendung aus: Drücken Sie F5 auf der Tastatur.

Einfach loslegen (Go)

Klonen Sie die TaskList-Beispielanwendung:

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

Wechseln Sie zu den Verzeichnissen, in denen Sie das Beispiel geklont haben:

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

Führen Sie in einer Befehlszeile den folgenden Befehl aus, wobei <project-id> die ID des Google Cloud Platform-Projekts ist:
```
export DATASTORE_PROJECT_ID=<project-id>
```
Windows-Nutzer sollten set anstelle von export verwenden.
Führen Sie die Anwendung aus:
```
go run tasks.go
```

Java

Achten Sie darauf, dass Maven und Java (ab Version 8) installiert sind.
Laden Sie die TaskList-Beispielanwendung herunter.
Entpacken Sie den Download in einer Befehlszeile:
```
unzip main.zip
```
Wechseln Sie in das Verzeichnis der TaskList-Anwendung:
```
cd java-datastore-main/samples/snippets
```
Führen Sie den folgenden Befehl aus, wobei <project-id> die ID des Google Cloud Platform-Projekts ist:
```
gcloud config set project <project-id>
```

Kompilieren Sie die Anwendung und führen Sie sie aus:

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

Node.js

Bereiten Sie Ihre Umgebung für die Node.js-Entwicklung vor.
Laden Sie die TaskList-Beispielanwendung herunter.
Entpacken Sie den Download:
```
unzip master.zip
```
Wechseln Sie in das Verzeichnis der TaskList-Anwendung:
```
cd nodejs-datastore-master/samples
```
Installieren Sie die Abhängigkeiten und verknüpfen Sie die Anwendung:
```
npm install
```
Führen Sie in einer Befehlszeile den folgenden Befehl aus, wobei <project-id> die ID des Google Cloud Platform-Projekts ist:
```
export GCLOUD_PROJECT=<project-id>
```
Windows-Nutzer sollten set anstelle von export verwenden.
Führen Sie die Anwendung aus:
```
node tasks.js
```

PHP

Achten Sie darauf, dass PHP (ab Version 5.6) und Composer installiert sind.
Laden Sie die TaskList-Beispielanwendung herunter.
Entpacken Sie den Download:
```
unzip master.zip
```
Wechseln Sie in das Verzeichnis der TaskList-Anwendung:
```
cd php-docs-samples-master/datastore/tutorial
```
Installieren Sie die Abhängigkeiten:
```
composer install
```
Führen Sie die Anwendung aus:
```
php src/list_tasks.php
```

Python

Achten Sie darauf, dass Python (ab Version 2.7.9), pip und virtualenv installiert sind.

Aktivieren Sie eine virtualenv-Sitzung.

virtualenv venv
source venv/bin/activate

Laden Sie die TaskList-Beispielanwendung herunter.
Entpacken Sie den Download:
```
unzip master.zip
```
Wechseln Sie in das Verzeichnis der TaskList-Anwendung:
```
cd python-docs-samples-master/datastore/cloud-client
```
Installieren Sie Abhängigkeiten:
```
pip install -r requirements.txt
```
Führen Sie die Anwendung aus: Verwenden Sie für <project-id> die ID Ihres Google Cloud Platform-Projekts.
```
python tasks.py new project-id
```

Ruby

Achten Sie darauf, dass Ruby und Bundler installiert sind.
Laden Sie die TaskList-Beispielanwendung herunter.
Entpacken Sie den Download:
```
unzip master.zip
```

Wechseln Sie in das Verzeichnis der TaskList-Anwendung:

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

Installieren Sie die Abhängigkeiten:
```
bundle install
```
Führen Sie in einer Befehlszeile den folgenden Befehl aus, wobei <project-id> die ID des Google Cloud Platform-Projekts ist:
```
export GOOGLE_CLOUD_PROJECT=<project-id>
```
Windows-Nutzer sollten set anstelle von export verwenden.
Führen Sie die Anwendung aus:
```
bundle exec ruby tasks.rb
```

Autorisiertes Dienstobjekt erstellen

Wenn Sie mithilfe der Google APIs-Clientbibliotheken authentifizierte Anfragen an Google Cloud APIs stellen möchten, müssen Sie:

die Anmeldedaten für die Anfragen abrufen.
ein Dienstobjekt erstellen, das Anmeldedaten verwendet.

Dann können Sie API-Aufrufe ausführen, indem Sie Methoden für das Dienstobjekt im Datastore-Modus aufrufen.

Für dieses Beispiel rufen Sie Anwendungsstandardanmeldedaten aus der Umgebung ab und übergeben sie als Argument, um das Dienstobjekt zu erstellen.

So sieht der Aufruf zum Erstellen des autorisierten Dienstobjekts im Datastore-Modus aus:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie unter Cloud Datastore-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore C# API.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Datastore zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

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

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

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

from google.cloud import datastore

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

Ruby

require "google/cloud/datastore"

datastore = Google::Cloud::Datastore.new

Daten speichern

Objekte im Datastore-Modus werden als Entitäten bezeichnet und jede Entität gehört zu einer bestimmten Art. Die TaskList-Anwendung speichert Entitäten der Art Task mit den folgenden Attributen:

description: ein vom Nutzer als Aufgabenbeschreibung angegebener String
created: ein Datum, mit dem angegeben wird, wann die Aufgabe erstellt wurde
done: ein boolescher Wert, mit dem angegeben wird, ob die Aufgabe abgeschlossen wurde

Wenn der Nutzer eine neue Aufgabe hinzufügt, erstellt die TaskList-Anwendung eine Task-Entität mit Werten für die oben aufgeführten Attribute:

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

Für diese Anwendung stellen wir auch eine Methode zur Aktualisierung des Attributs done bereit, um anzugeben, dass die Aufgabe abgeschlossen ist:

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

Dies ist die Methode zum Löschen einer Task-Entität mit dem Schlüssel der Task-Entität:

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

Abfrage ausführen

Zusätzlich zum Abruf von Entitäten aus dem Datastore-Modus direkt mit den entsprechenden Schlüsseln kann eine Anwendung anhand einer Abfrage die Entitäten nach den Werten ihrer Attribute abrufen. Eine typische Abfrage umfasst

Einen Entitätstyp, auf den die Abfrage angewendet wird
Null oder mehr Filter, beispielsweise zur Auswahl von Typen, deren Attribute mit einem Wert übereinstimmen
Null oder mehr Sortierfolgen zur Anordnung der Ergebnisse

Bei dieser Anwendung wird der Datastore-Modus auf Task-Entitäten abgefragt, die nach der Erstellungszeit sortiert sind:

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

Weitere Informationen

Diese Anleitung enthält lediglich die grundlegenden Schritte, die notwendig sind, um über eine Befehlszeilenanwendung Aufrufe an die Datastore mode API auszuführen. Der Datastore-Modus unterstützt unter anderem schnelle und hoch skalierbare ACID-Transaktionen, SQL-ähnliche Abfragen und Indexe.

Weitere Informationen zu den Funktionen des Datastore-Modus finden Sie unter Cloud Firestore im Datastore-Modus.
Mehr zum Einsatz des Datastore-Modus-Emulators bei der Entwicklung Ihrer Anwendung finden Sie unter Cloud Datastore-Emulator.