Se usó la API de Cloud Translation para traducir esta página.

Entidades, propiedades y claves

Los objetos de datos de Firestore en modo Datastore se conocen como entidades. Una entidad posee una o más propiedades con nombre, que pueden tener uno o más valores. No es necesario que las entidades del mismo tipo tengan las mismas propiedades y los valores de una entidad para una propiedad determinada no necesitan pertenecer al mismo tipo de datos. (Si fuera necesario, una aplicación puede establecer y aplicar esas restricciones en su propio modelo de dados).

El modo Datastore es compatible con una variedad de tipos de datos para valores de propiedad. Se incluyen, entre otros:

Números enteros
números de punto flotante
Strings
Fechas
Datos binarios

Cada entidad de una base de datos de modo Datastore tiene una clave que la identifica de manera única. La clave consta de los componentes siguientes:

El espacio de nombres de la entidad, que permite la función multiusuario
El tipo de la entidad, que la clasifica con el propósito de realizar consultas
Un identificador de la entidad individual, que puede ser de alguna de las siguientes opciones:
- una string de nombre de clave
- un ID numérico de enteros
Una ruta principal opcional que ubica la entidad dentro de la jerarquía de la base de datos

Una aplicación puede recuperar una entidad individual de la base de datos mediante la clave de la entidad, o bien una o más entidades con una consulta basada en los valores de propiedad o las claves de las entidades.

Firestore en modo Datastore no aplica ninguna restricción en las estructuras de las entidades. Por ejemplo, si una propiedad posee un valor de un tipo en particular, esta tarea le corresponde a la aplicación.

Los fragmentos de esta página se basan en el ejemplo de Introducción a Firestore en modo Datastore.

Trabaja con entidades

Las aplicaciones pueden usar la API de Firestore en modo Datastore para crear, recuperar, actualizar y borrar entidades. Si la aplicación conoce la clave completa de una entidad (o puede obtenerla del tipo, identificador o clave de la superior), puede usar la clave para operar directamente con la entidad. Una aplicación también puede obtener la clave de una entidad como resultado de una consulta. Para obtener más información, lee el tema Consultas.

Cómo crear una entidad

Para crear una nueva entidad, debes inicializarla y establecer sus propiedades:

C#

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta Bibliotecas cliente de Cloud Datastore. Si deseas obtener más información, consulta la documentación de referencia de la API de C# de Cloud Datastore.

Para autenticarte en Cloud Datastore, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Entity task = new Entity()
{
    Key = _db.CreateKeyFactory("Task").CreateKey("sampleTask"),
    ["category"] = "Personal",
    ["done"] = false,
    ["priority"] = 4,
    ["description"] = "Learn Cloud Datastore"
};

Go

type Task struct {
	Category        string
	Done            bool
	Priority        float64
	Description     string `datastore:",noindex"`
	PercentComplete float64
	Created         time.Time
}
task := &Task{
	Category:        "Personal",
	Done:            false,
	Priority:        4,
	Description:     "Learn Cloud Datastore",
	PercentComplete: 10.0,
	Created:         time.Now(),
}

Java

Key taskKey = datastore.newKeyFactory().setKind("Task").newKey("sampleTask");
Entity task =
    Entity.newBuilder(taskKey)
        .set("category", "Personal")
        .set("done", false)
        .set("priority", 4)
        .set("description", "Learn Cloud Datastore")
        .build();

Node.js

const task = {
  category: 'Personal',
  done: false,
  priority: 4,
  description: 'Learn Cloud Datastore',
};

PHP

$task = $datastore->entity('Task', [
    'category' => 'Personal',
    'done' => false,
    'priority' => 4,
    'description' => 'Learn Cloud Datastore'
]);

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

task = datastore.Entity(client.key("Task"))
task.update(
    {
        "category": "Personal",
        "done": False,
        "priority": 4,
        "description": "Learn Cloud Datastore",
    }
)

Ruby

task = datastore.entity "Task" do |t|
  t["category"] = "Personal"
  t["done"] = false
  t["priority"] = 4
  t["description"] = "Learn Cloud Datastore"
end

Puedes guardar la entidad en la base de datos mediante upsert (que reemplazará una entidad ya existente en el modo Datastore) o con insert (que requiere que ya no exista la clave de la entidad).

A continuación, te mostramos cómo realizar una operación upsert en una entidad:

C#

_db.Upsert(_sampleTask);

Go

key := datastore.IncompleteKey("Task", nil)
key, err := client.Put(ctx, key, task)

Java

Entity task = Entity.newBuilder(keyFactory.newKey("sampleTask")).build();
datastore.put(task);

Node.js

const taskKey = datastore.key('Task');
const task = {
  category: 'Personal',
  done: false,
  priority: 4,
  description: 'Learn Cloud Datastore',
};

const entity = {
  key: taskKey,
  data: task,
};

await datastore.upsert(entity);
// Task inserted successfully.

PHP

$key = $datastore->key('Task', 'sampleTask');
$task = $datastore->entity($key, [
    'category' => 'Personal',
    'done' => false,
    'priority' => 4,
    'description' => 'Learn Cloud Datastore'
]);
$datastore->upsert($task);

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

complete_key = client.key("Task", "sampleTask")

task = datastore.Entity(key=complete_key)

task.update(
    {
        "category": "Personal",
        "done": False,
        "priority": 4,
        "description": "Learn Cloud Datastore",
    }
)

client.put(task)

Ruby

# task_name = "sampleTask"
task = datastore.entity "Task", task_name do |t|
  t["category"] = "Personal"
  t["done"] = false
  t["priority"] = 4
  t["description"] = "Learn Cloud Datastore"
end
datastore.save task

A continuación, te mostramos cómo realizar una operación insert en una entidad:

C#

Entity task = new Entity()
{
    Key = _keyFactory.CreateIncompleteKey()
};
task.Key = _db.Insert(task);

Go

taskKey := datastore.NameKey("Task", "sampleTask", nil)
_, err := client.RunInTransaction(ctx, func(tx *datastore.Transaction) error {
	// We first check that there is no entity stored with the given key.
	var empty Task
	if err := tx.Get(taskKey, &empty); err != datastore.ErrNoSuchEntity {
		return err
	}
	// If there was no matching entity, store it now.
	_, err := tx.Put(taskKey, &task)
	return err
})

Java

Key taskKey = datastore.add(FullEntity.newBuilder(keyFactory.newKey()).build()).getKey();

Node.js

const taskKey = datastore.key('Task');
const task = {
  category: 'Personal',
  done: false,
  priority: 4,
  description: 'Learn Cloud Datastore',
};

const entity = {
  key: taskKey,
  data: task,
};

datastore.insert(entity).then(() => {
  // Task inserted successfully.
});

PHP

$task = $datastore->entity('Task', [
    'category' => 'Personal',
    'done' => false,
    'priority' => 4,
    'description' => 'Learn Cloud Datastore'
]);
$datastore->insert($task);

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

with client.transaction():
    incomplete_key = client.key("Task")

    task = datastore.Entity(key=incomplete_key)

    task.update(
        {
            "category": "Personal",
            "done": False,
            "priority": 4,
            "description": "Learn Cloud Datastore",
        }
    )

    client.put(task)

Ruby

datastore.transaction do |_tx|
  task = datastore.entity "Task" do |t|
    t["category"] = "Personal"
    t["done"] = false
    t["priority"] = 4
    t["description"] = "Learn Cloud Datastore"
  end
  datastore.save task
end

Cómo recuperar una entidad

Para recuperar una entidad a partir de la base de datos, utiliza su clave para una búsqueda:

C#

Entity task = _db.Lookup(_sampleTask.Key);

Go

var task Task
taskKey := datastore.NameKey("Task", "sampleTask", nil)
err := client.Get(ctx, taskKey, &task)

Java

Entity task = datastore.get(taskKey);

Node.js

const taskKey = datastore.key('Task');
const [entity] = await datastore.get(taskKey);
// entity = {
//   category: 'Personal',
//   done: false,
//   priority: 4,
//   description: 'Learn Cloud Datastore',
//   [Symbol(KEY)]:
//    Key {
//      namespace: undefined,
//      id: '...',
//      kind: 'Task',
//      path: [Getter]
//    }
//   }
// };
console.log(entity);

PHP

$task = $datastore->lookup($key);

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

key = client.key("Task", "sampleTask")
task = client.get(key)

Ruby

# task_name = "sampleTask"
task_key = datastore.key "Task", task_name
task = datastore.find task_key

Cómo actualizar una entidad

Para aplicar una update a una entidad existente, modifica las propiedades de la entidad recuperada con anterioridad y guárdala con la clave como se indica a continuación:

C#

_sampleTask["priority"] = 5;
_db.Update(_sampleTask);

Go

taskKey := datastore.NameKey("Task", "sampleTask", nil)
tx, err := client.NewTransaction(ctx)
if err != nil {
	log.Fatalf("client.NewTransaction: %v", err)
}
var task Task
if err := tx.Get(taskKey, &task); err != nil {
	log.Fatalf("tx.Get: %v", err)
}
task.Priority = 5
if _, err := tx.Put(taskKey, &task); err != nil {
	log.Fatalf("tx.Put: %v", err)
}
if _, err := tx.Commit(); err != nil {
	log.Fatalf("tx.Commit: %v", err)
}

Java

Entity task = Entity.newBuilder(datastore.get(taskKey)).set("priority", 5).build();
datastore.update(task);

Node.js

const taskKey = datastore.key('Task');
const task = {
  category: 'Personal',
  done: false,
  priority: 4,
  description: 'Learn Cloud Datastore',
};

const entity = {
  key: taskKey,
  data: task,
};

await datastore.update(entity);
// Task updated successfully.

PHP

$transaction = $datastore->transaction();
$key = $datastore->key('Task', 'sampleTask');
$task = $transaction->lookup($key);
$task['priority'] = 5;
$transaction->update($task);
$transaction->commit();

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

with client.transaction():
    key = client.key("Task", "sampleTask")
    task = client.get(key)

    task["done"] = True

    client.put(task)

Ruby

# task_name = "sampleTask"
datastore.transaction do |_tx|
  task = datastore.find "Task", task_name
  task["priority"] = 5
  datastore.save task
end

Los datos proporcionados reemplazan la entidad existente. El objeto completo se debe enviar a la base de datos. Si la entidad no existe, la actualización fallará. Si deseas actualizar o crear una entidad, usa upsert como se describió antes. Usar una transacción te permite realizar las operaciones get y update en una sola transacción atómica.

Borra una entidad

Si tienes la clave correspondiente, puedes delete la entidad:

C#

_db.Delete(_sampleTask.Key);

Go

key := datastore.NameKey("Task", "sampletask", nil)
err := client.Delete(ctx, key)

Java

datastore.delete(taskKey);

Node.js

const taskKey = datastore.key('Task');
await datastore.delete(taskKey);
// Task deleted successfully.

PHP

$datastore->delete($taskKey);

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

key = client.key("Task", "sampleTask")
client.delete(key)

Ruby

# task_name = "sampleTask"
task_key = datastore.key "Task", task_name
datastore.delete task_key

Operaciones por lotes

Firestore en modo Datastore admite versiones por lotes de las operaciones que le permiten operar en varios objetos en una sola llamada del modo Datastore.

Hacer llamadas por lotes es más rápido que hacer llamadas por separado para cada entidad individual porque estas generan sobrecarga por solo una llamada al servicio. Si se involucran varios grupos de entidad, el trabajo de todos ellos se realiza en paralelo del lado del servidor.

Por ejemplo, puedes upsert varias entidades:

C#

var taskList = new[]
{
    new Entity()
    {
        Key = _keyFactory.CreateIncompleteKey(),
        ["category"] = "Personal",
        ["done"] = false,
        ["priority"] = 4,
        ["description"] = "Learn Cloud Datastore"
    },
    new Entity()
    {
        Key = _keyFactory.CreateIncompleteKey(),
        ["category"] = "Personal",
        ["done"] = "false",
        ["priority"] = 5,
        ["description"] = "Integrate Cloud Datastore"
    }
};
var keyList = _db.Upsert(taskList[0], taskList[1]);

Go

tasks := []*Task{
	{
		Category:    "Personal",
		Done:        false,
		Priority:    4,
		Description: "Learn Cloud Datastore",
	},
	{
		Category:    "Personal",
		Done:        false,
		Priority:    5,
		Description: "Integrate Cloud Datastore",
	},
}
keys := []*datastore.Key{
	datastore.IncompleteKey("Task", nil),
	datastore.IncompleteKey("Task", nil),
}

keys, err := client.PutMulti(ctx, keys, tasks)

Java

FullEntity<IncompleteKey> task1 =
    FullEntity.newBuilder(keyFactory.newKey())
        .set("category", "Personal")
        .set("done", false)
        .set("priority", 4)
        .set("description", "Learn Cloud Datastore")
        .build();
FullEntity<IncompleteKey> task2 =
    Entity.newBuilder(keyFactory.newKey())
        .set("category", "Personal")
        .set("done", false)
        .set("priority", 5)
        .set("description", "Integrate Cloud Datastore")
        .build();
List<Entity> tasks = datastore.add(task1, task2);
Key taskKey1 = tasks.get(0).getKey();
Key taskKey2 = tasks.get(1).getKey();

Node.js

const taskKey1 = this.datastore.key(['Task', 1]);
const taskKey2 = this.datastore.key(['Task', 2]);

const task1 = {
  category: 'Personal',
  done: false,
  priority: 4,
  description: 'Learn Cloud Datastore',
};

const task2 = {
  category: 'Work',
  done: false,
  priority: 8,
  description: 'Integrate Cloud Datastore',
};

const entities = [
  {
    key: taskKey1,
    data: task1,
  },
  {
    key: taskKey2,
    data: task2,
  },
];

await datastore.upsert(entities);
// Tasks inserted successfully.

PHP

$result = $datastore->upsertBatch($tasks);

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

task1 = datastore.Entity(client.key("Task", 1))

task1.update(
    {
        "category": "Personal",
        "done": False,
        "priority": 4,
        "description": "Learn Cloud Datastore",
    }
)

task2 = datastore.Entity(client.key("Task", 2))

task2.update(
    {
        "category": "Work",
        "done": False,
        "priority": 8,
        "description": "Integrate Cloud Datastore",
    }
)

client.put_multi([task1, task2])

Ruby

task_1 = datastore.entity "Task" do |t|
  t["category"] = "Personal"
  t["done"] = false
  t["priority"] = 4
  t["description"] = "Learn Cloud Datastore"
end

task_2 = datastore.entity "Task" do |t|
  t["category"] = "Personal"
  t["done"] = false
  t["priority"] = 5
  t["description"] = "Integrate Cloud Datastore"
end

tasks = datastore.save task_1, task_2
task_key_1 = tasks[0].key
task_key_2 = tasks[1].key

Puedes buscar múltiples entidades:

C#

var keys = new Key[] { _keyFactory.CreateKey(1), _keyFactory.CreateKey(2) };
var tasks = _db.Lookup(keys[0], keys[1]);

Go

var taskKeys []*datastore.Key // Populated with incomplete keys.
tasks := make([]*Task, len(taskKeys))
err := client.GetMulti(ctx, taskKeys, &tasks)

Java

Iterator<Entity> tasks = datastore.get(taskKey1, taskKey2);

Node.js

const taskKey1 = this.datastore.key(['Task', 1]);
const taskKey2 = this.datastore.key(['Task', 2]);

const keys = [taskKey1, taskKey2];

const [tasks] = await datastore.get(keys);
// Tasks retrieved successfully.
console.log(tasks);

PHP

$result = $datastore->lookupBatch($keys);
if (isset($result['found'])) {
    // $result['found'] is an array of entities.
} else {
    // No entities found.
}

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

keys = [client.key("Task", 1), client.key("Task", 2)]
tasks = client.get_multi(keys)

Ruby

# task_name_1 = "sampleTask1"
# task_name_2 = "sampleTask2"
task_key_1 = datastore.key "Task", task_name_1
task_key_2 = datastore.key "Task", task_name_2
tasks = datastore.find_all task_key_1, task_key_2

Puedes borrar varias entidades:

C#

var keys = new Key[] { _keyFactory.CreateKey(1), _keyFactory.CreateKey(2) };
_db.Delete(keys);

Go

err := client.DeleteMulti(ctx, taskKeys)

Java

datastore.delete(taskKey1, taskKey2);

Node.js

const taskKey1 = this.datastore.key(['Task', 1]);
const taskKey2 = this.datastore.key(['Task', 2]);

const keys = [taskKey1, taskKey2];

await datastore.delete(keys);
// Tasks deleted successfully.

PHP

$result = $datastore->deleteBatch($keys);

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

keys = [client.key("Task", 1), client.key("Task", 2)]
client.delete_multi(keys)

Ruby

# task_name_1 = "sampleTask1"
# task_name_2 = "sampleTask2"
task_key_1 = datastore.key "Task", task_name_1
task_key_2 = datastore.key "Task", task_name_2
datastore.delete task_key_1, task_key_2

Las operaciones en lotes no cambian tus costos de lectura, escritura o eliminación; documentados en Precios y cuota. Se te cobrará por cada clave en una operación por lotes, aunque la clave no exista.

El tamaño de las entidades involucradas en una operación no afecta a los costos de lectura, escritura o eliminación. Sin embargo, el tamaño de las entidades sí modifica tus costos de tamaño de almacenamiento.

Identificadores y tipos

Cada entidad corresponde a un tipo en particular, que la clasifica con el fin de realizar consultas. Por ejemplo, una aplicación de lista de tareas podría representar cada tarea que se debe completar con una entidad del tipo Task.

Todos los nombres de tipo que comienzan con dos guiones bajos (__) están reservados y no se pueden usar.

Asigna identificadores

Cada entidad, además de un tipo, también posee un identificador, que se le asigna cuando se crea la entidad. Debido a que es parte de la clave de la entidad, el identificador se encuentra asociado de forma permanente a la entidad y no se puede cambiar. Se puede asignar de dos maneras:

Tu aplicación puede especificar su propia string de nombre de clave para la entidad.
Puedes hacer que Firestore en modo Datastore asigne un ID numérico entero a la entidad de forma automática.

En el siguiente ejemplo, se crea una clave con el tipo Task mediante un nombre de clave, "sampleTask", como el identificador:

C#

Key key = _db.CreateKeyFactory("Task").CreateKey("sampleTask");

Go

taskKey := datastore.NameKey("Task", "sampletask", nil)

Java

Key taskKey = datastore.newKeyFactory().setKind("Task").newKey("sampleTask");

Node.js

const taskKey = datastore.key(['Task', 'sampleTask']);

PHP

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

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

key = client.key("Task", "sampleTask")

Ruby

# task_name = "sampleTask"
task_key = datastore.key "Task", task_name

El modo Datastore también puede asignar varios ID de forma automática. El modo Datastore genera una secuencia aleatoria de ID sin usar con una distribución aproximadamente uniforme. Cada ID puede tener hasta 16 dígitos decimales.

En el siguiente ejemplo, se crea una clave del tipo Task sin usar un nombre de clave. La clave completa de la entidad (incluso el ID asignado de forma automática) se mostrará cuando una entidad con clave incompleta se guarde en el modo Datastore:

C#

Key incompleteKey = _db.CreateKeyFactory("Task").CreateIncompleteKey();
Key key = _db.AllocateId(incompleteKey);

Go

// A complete key is assigned to the entity when it is Put.
taskKey := datastore.IncompleteKey("Task", nil)

Java

KeyFactory keyFactory = datastore.newKeyFactory().setKind("Task");
Key taskKey = datastore.allocateId(keyFactory.newKey());

Node.js

const taskKey = datastore.key('Task');

PHP

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

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

key = client.key("Task")

Ruby

task_key = datastore.key "Task"

Si quieres mostrar al usuario los ID de la entidad o depender de su pedido, lo mejor que puedes hacer es usar la asignación manual.

Asigna tu propio ID numérico

A veces, las aplicaciones avanzadas quieren asignar sus propios ID numéricos de forma manual a las entidades que crean, en lugar de usar strings de nombre de clave o generar ID numéricos de forma automática. Sin embargo, ten en cuenta que nada impide que una base de datos en modo Datastore asigne uno de tus ID numéricos manuales a otra entidad. La única forma de impedir tal conflicto es si tu aplicación que obtiene un bloque de varios ID con el método allocateIds().

El generador automático de ID del modo Datastore llevará un registro de los ID asignados con estos métodos y evitará volver a usarlos para otra entidad; de esta manera, podrás usarlos sin que se generen conflictos. No puedes elegir de forma manual qué valores muestra el método allocateIds(). El modo Datastore asigna los valores que muestra allocateIds().

Rutas de principales

Las entidades en una base de datos en modo Datastore conforman un espacio con estructura jerárquica, similar a la estructura de directorios de un sistema de archivos. Cuando creas una entidad, tienes la opción de designar otra entidad como parent, en cuyo caso la nueva entidad es parent respecto de la entidad principal (ten en cuenta que, a diferencia de lo que ocurre en un sistema de archivos, no es necesario que efectivamente exista una entidad principal). Las entidades para las que no existe entidad superior se denominan entidades raíz. La asociación entre una entidad secundaria y la entidad superior es permanente, y no puede cambiarse una vez creada la entidad. El modo Datastore nunca asignará el mismo ID numérico a dos entidades asociadas a la misma entidad principal ni a dos entidades raíz (no asociadas a una entidad principal).

La superior de una entidad y la superior de una superior, y así sucesivamente, son sus principales. Sus secundarios y los secundarios de los secundarios, y así sucesivamente, son sus descendientes. La secuencia de entidades que comienza con una entidad raíz y sigue de una entidad superior a una secundaria, hasta llegar a determinada entidad, constituye la ruta de principales de esa entidad. La clave completa que identifica una entidad consta de una secuencia de pares de tipo-identificador que especifican la ruta de principales y terminan con el tipo y el identificador de la propia entidad:

[User:alice, TaskList:default, Task:sampleTask]

Para una entidad raíz, la ruta principal está vacía y la clave consta solo del tipo y del identificador de la entidad:

[User:alice]

Niveles de superiores

Usa niveles de superiores para organizar tus datos. Por ejemplo, si tu aplicación organiza entidades Task por entidades TaskList, usa un nivel de superior:

C#

Key rootKey = _db.CreateKeyFactory("TaskList").CreateKey("default");
Key key = new KeyFactory(rootKey, "Task").CreateKey("sampleTask");

Go

parentKey := datastore.NameKey("TaskList", "default", nil)
taskKey := datastore.NameKey("Task", "sampleTask", parentKey)

Java

Key taskKey =
    datastore
        .newKeyFactory()
        .addAncestors(PathElement.of("TaskList", "default"))
        .setKind("Task")
        .newKey("sampleTask");

Node.js

const taskKey = datastore.key([
  'TaskList',
  'default',
  'Task',
  'sampleTask',
]);

PHP

$taskKey = $datastore->key('TaskList', 'default')
    ->pathElement('Task', 'sampleTask');

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

key = client.key("TaskList", "default", "Task", "sampleTask")
# Alternatively
parent_key = client.key("TaskList", "default")
key = client.key("Task", "sampleTask", parent=parent_key)

Ruby

# task_list_name = "default"
# task_name = "sampleTask"
task_key = datastore.key [["TaskList", task_list_name], ["Task", task_name]]

Si tu aplicación organiza primero entidades Task según entidades User y, luego, según entidades TaskList, usa varios niveles de superior:

C#

Key rootKey = _db.CreateKeyFactory("User").CreateKey("Alice");
Key taskListKey = new KeyFactory(rootKey, "TaskList").CreateKey("default");
Key key = new KeyFactory(taskListKey, "Task").CreateKey("sampleTask");

Go

userKey := datastore.NameKey("User", "alice", nil)
parentKey := datastore.NameKey("TaskList", "default", userKey)
taskKey := datastore.NameKey("Task", "sampleTask", parentKey)

Java

KeyFactory keyFactory =
    datastore
        .newKeyFactory()
        .addAncestors(PathElement.of("User", "Alice"), PathElement.of("TaskList", "default"))
        .setKind("Task");
Key taskKey = keyFactory.newKey("sampleTask");

Node.js

const taskKey = datastore.key([
  'User',
  'alice',
  'TaskList',
  'default',
  'Task',
  'sampleTask',
]);

PHP

$taskKey = $datastore->key('User', 'alice')
    ->pathElement('TaskList', 'default')
    ->pathElement('Task', 'sampleTask');

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

key = client.key("User", "alice", "TaskList", "default", "Task", "sampleTask")

Ruby

# user_name = "alice"
# task_list_name = "default"
# task_name = "sampleTask"
task_key = datastore.key([
                           ["User", user_name],
                           ["TaskList", task_list_name],
                           ["Task", task_name]
                         ])

Como se muestra en el ejemplo anterior, cuando creas una entidad con una superior, especificas la ruta principal completa de la superior.

Una aplicación que mantiene perfiles de usuario puede requerir solo un nivel de superior para los datos del perfil de usuario. Por ejemplo, usa sola ruta de principales de User de un solo nivel para entidades Profile:

[User:alice, Profile:public]

Una aplicación de planificación de conferencias puede requerir varios niveles de superiores, como una ruta principal Building/Floor de nivel múltiple para entidades Room:

[Building:C, Floor:1, Room:123]

Grupos de entidad

Un grupo de entidades consta de una entidad raíz y todos sus descendientes. Las aplicaciones suelen usar grupos de entidades para organizar datos muy relacionados entre sí. Por ejemplo, una aplicación puede utilizar un grupo de entidades para almacenar datos de un producto o un perfil de usuario.

Tipos de valores y propiedades

Los valores de datos asociados a una entidad constan de una o más propiedades. Cada propiedad tiene un nombre y uno o más valores.

Una propiedad puede tener valores de más de un tipo y dos entidades pueden tener valores de diferente tipo para la misma propiedad. Una propiedad puede o no estar indexada (las consultas que ordenan o filtran en una propiedad p ignorarán las entidades en las que p no esté indexada).

Algunos ejemplos de propiedades son:

C#

Entity task = new Entity()
{
    Key = _db.CreateKeyFactory("Task").CreateKey("sampleTask"),
    ["category"] = "Personal",
    ["created"] = new DateTime(1999, 01, 01, 0, 0, 0, DateTimeKind.Utc),
    ["done"] = false,
    ["priority"] = 4,
    ["percent_complete"] = 10.0,
    ["description"] = new Value()
    {
        StringValue = "Learn Cloud Datastore",
        ExcludeFromIndexes = true
    },
};

Go

type Task struct {
	Category        string
	Done            bool
	Priority        int
	Description     string `datastore:",noindex"`
	PercentComplete float64
	Created         time.Time
}
task := &Task{
	Category:        "Personal",
	Done:            false,
	Priority:        4,
	Description:     "Learn Cloud Datastore",
	PercentComplete: 10.0,
	Created:         time.Now(),
}

Java

Entity task =
    Entity.newBuilder(taskKey)
        .set("category", "Personal")
        .set("created", Timestamp.now())
        .set("done", false)
        .set("priority", 4)
        .set("percent_complete", 10.0)
        .set(
            "description",
            StringValue.newBuilder("Learn Cloud Datastore").setExcludeFromIndexes(true).build())
        .build();

Node.js

const task = [
  {
    name: 'category',
    value: 'Personal',
  },
  {
    name: 'created',
    value: new Date(),
  },
  {
    name: 'done',
    value: false,
  },
  {
    name: 'priority',
    value: 4,
  },
  {
    name: 'percent_complete',
    value: 10.0,
  },
  {
    name: 'description',
    value: 'Learn Cloud Datastore',
    excludeFromIndexes: true,
  },
];

PHP

$task = $datastore->entity(
    $key,
    [
        'category' => 'Personal',
        'created' => new DateTime(),
        'done' => false,
        'priority' => 4,
        'percent_complete' => 10.0,
        'description' => 'Learn Cloud Datastore'
    ],
    ['excludeFromIndexes' => ['description']]
);

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

key = client.key("Task")
task = datastore.Entity(key, exclude_from_indexes=("description",))
task.update(
    {
        "category": "Personal",
        "description": "Learn Cloud Datastore",
        "created": datetime.datetime.now(tz=datetime.timezone.utc),
        "done": False,
        "priority": 4,
        "percent_complete": 10.5,
    }
)
client.put(task)

Ruby

task = datastore.entity "Task" do |t|
  t["category"] = "Personal"
  t["created"] = Time.now
  t["done"] = false
  t["priority"] = 4
  t["percent_complete"] = 10.0
  t["description"] = "Learn Cloud Datastore"
  t.exclude_from_indexes! "description", true
end

Propiedades de arreglo

Una propiedad con más de un valor se denomina arreglo de propiedades. En este ejemplo, hay dos arreglos de propiedades. El primero se llama tags, con los valores fun y programming. El segundo se llama collaborators, con los valores alice y bob.

C#

Entity task = new Entity()
{
    Key = _db.CreateKeyFactory("Task").CreateKey("sampleTask"),
    ["collaborators"] = new ArrayValue() { Values = { "alice", "bob" } },
    ["tags"] = new ArrayValue() { Values = { "fun", "programming" } }
};

Go

type Task struct {
	Tags          []string
	Collaborators []string
}
task := &Task{
	Tags:          []string{"fun", "programming"},
	Collaborators: []string{"alice", "bob"},
}

Java

Entity task =
    Entity.newBuilder(taskKey)
        .set("tags", "fun", "programming")
        .set("collaborators", ListValue.of("alice", "bob"))
        .build();

Node.js

const task = {
  tags: ['fun', 'programming'],
  collaborators: ['alice', 'bob'],
};

PHP

$task = $datastore->entity(
    $key,
    [
        'tags' => ['fun', 'programming'],
        'collaborators' => ['alice', 'bob']
    ]
);

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

key = client.key("Task")
task = datastore.Entity(key)
task.update({"tags": ["fun", "programming"], "collaborators": ["alice", "bob"]})

Ruby

# task_name = "sampleTask"
task = datastore.entity "Task", task_name do |t|
  t["tags"] = ["fun", "programming"]
  t["collaborators"] = ["alice", "bob"]
end

Las propiedades de arreglo pueden ser útiles, por ejemplo, cuando realices búsquedas con filtros de equidad, una entidad resuelve la búsqueda si alguno de sus valores para una propiedad coincide con el valor especificado en el filtro. Para obtener más detalles sobre arreglos de propiedades y los problemas que debes tener en cuenta, visita el tema Consultas.

Tipos de valores admitidos

Las propiedades se almacenan como un mapa string/value que contiene los nombres y valores de las propiedades de la entidad. Se admiten los siguientes tipos para los valores:

Array

API de REST
- nombre del campo: arrayValue
- tipo: un objeto ArrayValue que contiene un arreglo de objetos de valor JSON
- Un array de propiedades se puede asignar con el campo arrayValue, que es del tipo ArrayValue, y con la configuración del campo values en un array de valores. Para no indexar una propiedad, establece el campo excludeFromIndexes del objeto de valor de la propiedad en true.
API de RPC
- nombre del campo: array_value
- tipo: un mensaje ArrayValue que contiene uno o más mensajes Value
- Una propiedad de arreglo se puede asignar mediante el campo array_value, que es del tipo ArrayValue, y mediante la propagación del campo values con múltiples objetos Value. Para no indexar una propiedad, establece el campo exclude_from_indexes de Value en true.
Orden de clasificación: ninguno
Notas: No puede contener otro valor de arreglo. La instancia de valor no debe establecer meaning o exclude_from_indexes.

Booleano

API de REST
- nombre del campo: booleanValue
- tipo: true o false
API de RPC
- nombre del campo: boolean_value
- tipo: bool
Orden de clasificación: false<true

BLOB

API de REST
- nombre del campo: blobValue
- tipo: string. Debe tener codificación base64.
API de RPC
- nombre del campo: blob_value
- tipo: bytes
Orden de clasificación: orden de byte
Notas: Hasta 1,500 bytes si la propiedad está indexada, o de lo contrario, hasta 1,048,487 bytes (1 MiB - 89 bytes).

Fecha y hora

API de REST
- nombre del campo: timestampValue
- tipo: string (RFC 3339 con formato, con milisegundos, por ejemplo 2013-05-14T00:01:00.234Z)
API de RPC
- nombre del campo: timestamp_value
- tipo: Timestamp
Orden de clasificación: cronológico
Notas:
- Cuando se almacena en modo Datastore, la precisión máxima es de microsegundos; cualquier precisión adicional se redondea hacia abajo.
- Cuando se muestra como parte de una consulta de proyección, el modo Datastore convierte los valores de marcas de tiempo en valores de números enteros de microsegundo.

Entidad incorporada

API de REST
- nombre del campo: entityValue
- tipo: una entidad JSON
API de RPC
- nombre del campo: entity_value
- tipo: un mensaje Entity
Orden de clasificación: ninguno
Notas: Cuando esté indexado, puedes hacer consultas en subpropiedades. Si excluyes este valor del índice, también se excluyen todas las subpropiedades del mismo.

Número de punto flotante

API de REST
- nombre del campo: doubleValue
- tipo: número
API de RPC
- nombre del campo: double_value
- tipo: double
Orden de clasificación: numérico
Notas: Precisión doble de 64 bits, IEEE 754.

Punto geográfico

API de REST
- nombre del campo: geoPointValue
- tipo: un par latitud-longitud JSON
API de RPC
- nombre del campo: geo_point_value
- tipo: un mensaje LatLng
Orden de clasificación: por latitud y, luego, por longitud

Integer

API de REST
- nombre del campo: integerValue
- tipo: número o string. Usa strings para números enteros que no se pueden representar de forma exacta como números.
API de RPC
- nombre del campo: integer_value
- tipo: int64
Orden de clasificación: numérico

Clave

API de REST
- nombre del campo: keyValue
- tipo: una clave de modo Datastore en JSON
API de RPC
- nombre del campo: key_value
- tipo: un mensaje Key
Orden de clasificación: por elementos de ruta de acceso (tipo, identificador, tipo, etc.)

Nulo

API de REST
- nombre del campo: nullValue
- tipo: nulo
API de RPC
- nombre del campo: null_value
- tipo: NullValue
Orden de clasificación: ninguno

String de texto

API de REST
- nombre del campo: stringValue
- tipo: string
API de RPC
- nombre del campo: string_value
- tipo: string
Orden de clasificación: orden de byte con codificación UTF-8
Notas: Hasta 1,500 bytes si la propiedad está indexada, o de lo contrario, hasta 1,048,487 bytes (1 MiB - 89 bytes).

Orden de los tipos de valor

Cuando una consulta incluye una propiedad con valores de varios tipos, un modo Datastore usa un orden determinista basado en las representaciones internas. La lista siguiente muestra el orden:

Valores nulos
Números de punto fijo
- Números enteros
- fechas y horarios
valores booleanos
strings de bytes
strings unicode
números de punto flotante
Valores NaN
Puntos geográficos
Claves del modo Datastore