Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

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, ni que todos los valores de una entidad para una propiedad determinada sean del 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 clases siguientes:
- 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.

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 las bibliotecas cliente de Cloud Datastore. Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Datastore para C#.

Para autenticarte en Cloud Datastore, configura las credenciales predeterminadas de la aplicación. Para 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

Recupera 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

Actualiza 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;
Transaction txn = datastore.newTransaction();
try {
  task = Entity.newBuilder(txn.get(taskKey)).set("priority", 5).build();
  txn.put(task);
  txn.commit();
} finally {
  if (txn.isActive()) {
    txn.rollback();
  }
}

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. Con una transacción, puedes 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 por lotes no afectan los costos de lectura, escritura o eliminación, que se documentan en Precios y cuotas. 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.

Incremento y otras transformaciones de propiedades

Usa transformaciones de propiedades, como increment, para realizar actualizaciones del servidor en una propiedad. Una transformación de propiedad evita una operación de lectura adicional del cliente para obtener el valor actual y evita un cálculo del cliente para determinar el valor nuevo.

El modo Datastore admite las siguientes transformaciones de propiedades:

increment
maximum
minimum
appendMissingElements
removeAllFromArray
setToServerValue(REQUEST_TIME)

En el siguiente ejemplo, se muestra una transformación de propiedad. Esta operación incrementa las propiedades según los valores especificados:

REST

POST https://datastore.googleapis.com/v1/projects/{projectId}:commit
{
  "mode": "NON_TRANSACTIONAL",
  "mutations": [
    {
      "propertyMask": {},  // Empty write mask indicates only transforms can change the entity.
      "propertyTransforms": [
        {
          "property": "quantity",
          "increment": {
            "integerValue": 2
          }
        },
        {
          "property": "inStock",
          "maximum": {
            "integerValue": 100
          }
        },
      ]
      "upsert": {
        "key": {
          "path": [
            {
              "kind": "Items",
              "name": "entity_1"
            }
          ]
        }
      }
    }
  ]
}

En el siguiente ejemplo, se establece un valor de propiedad en la hora en que el servidor procesó la solicitud con precisión de milisegundos.

REST

POST https://datastore.googleapis.com/v1/projects/{projectId}:commit
{
  "mode": "NON_TRANSACTIONAL",
  "mutations": [
    {
      "propertyMask": {},  // // Empty write mask indicates only transforms can change the entity.
      "propertyTransforms": [
        {
          "property": "timeField",
          "setToServerValue": "REQUEST_TIME"
        },
      ]
      "upsert": {
        "key": {
          "path": [
            {
              "kind": "Kind_1",
              "name": "entity_1"
            }
          ]
        }
      }
    }
  ]
}

En el siguiente ejemplo, se agregan elementos de array si faltan.

REST

POST https://datastore.googleapis.com/v1/projects/{projectId}:commit
{
  "mode": "NON_TRANSACTIONAL",
  "mutations": [
    {
      "propertyMask": {},  // Empty write mask indicates only transforms can change the entity.
      "propertyTransforms": [
        {
          "property": "arrayField",
          "appendMissingElements": {
            "values": [
              { "stringValue": "str" }, { "integerValue": 10 }
            ]
          }
        },
      ]
      "upsert": {
        "key": {
          "path": [
            {
              "kind": "Kind_1",
              "name": "entity_1"
            }
          ]
        }
      }
    }
  ]
}

Tipos mixtos con `maximum` y `minimum`

Las transformaciones de propiedades maximum y minimum toman un valor de número entero o un valor doble (número de punto flotante) como entrada. El valor de la propiedad de destino también puede ser un número entero o un valor de tipo double.

Si la propiedad no es un número entero o doble, o si no existe, la transformación establece la propiedad en el valor y el tipo de entrada dados. Si se aplica una operación maximum en la que la propiedad y el valor de entrada son de tipos mixtos (es decir, uno es un número entero y el otro es un número de punto flotante de doble precisión), la propiedad adopta el tipo del operando más grande. Para minimum, la propiedad toma el tipo del operando más pequeño.

Si los operandos son equivalentes (p.ej., 3 y 3.0), la propiedad no cambia. 0, 0.0 y -0.0 son todos cero. El maximum o minimum de un valor almacenado de cero y un valor de entrada de cero siempre es el valor almacenado. La maximum o minimum de cualquier valor numérico y NaN es NaN.

Mutaciones múltiples y `PropertyMask`

Las transformaciones de propiedades se aplican de forma secuencial después de cualquier mutación adicional en la solicitud. Un PropertyMask restringe las mutaciones insert, update y upsert a las propiedades especificadas, pero no restringe las transformaciones de propiedades.

Por ejemplo, si comienzas con la siguiente entidad:

REST

entity: {
  "key" : {
    "path": [
      {
        "kind": "Kind_1",
        "name": "entity_1"
      }
    ]
  }
  "properties" : {
    "a": 1,
    "b": 2,
    "c": 3
  }
}

La siguiente solicitud actualiza a y b, y, luego, aplica una transformación de propiedad a la propiedad b:

POST https://datastore.googleapis.com/v1/projects/{projectId}:commit
{
  "mode": "NON_TRANSACTIONAL",
  "mutations": [
    {
      "propertyMask": {"a", "b"},  // update property a, b
      "update": {
        "key": {
          "path": [
            {
              "kind": "Kind_1",
              "name": "entity_1"
            }
          ]
        }
        "properties": {
          "a" : "new_value",
          "b" : -2
        }
      },
      "propertyTransforms": [
        {
          "property": "b",
          "increment": { 
            "integerValue": 2
          }
        }
      ]
    }
  ]
}

El resultado es el siguiente:

REST

entity: {
  "key" : {
    "path": [
      {
        "kind": "Kind_1",
        "name": "entity_1"
      }
    ]
  }
  "properties" : {
    "a": "new_value",
    "b": 0,
    "c": 3
  }
}

Identificadores y tipos

Cada entidad es de un tipo en particular, que la clasifica para 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

Además de un tipo, cada entidad 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.

Para obtener información sobre el tamaño máximo de la cadena de clave de entidad, consulta Límites.
Puedes hacer que Firestore en modo Datastore asigne un ID numérico entero a la entidad de forma automática.
Para conocer las prácticas recomendadas sobre la asignación de identificadores, consulta la sección Claves en las prácticas recomendadas.

En el siguiente ejemplo, se crea una clave con el tipo Task que usa un nombre de clave, "sampleTask", como 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

En lugar de usar cadenas de nombre de clave o generar IDs numéricos de forma automática, en las aplicaciones avanzadas, tal vez resulte más conveniente asignar IDs numéricos propios de forma manual a las entidades creadas. 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 manualmente qué valores devuelve 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 principal, en cuyo caso la nueva entidad es secundaria 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).

Una entidad puede tener varios niveles de ancestros y descendientes. El elemento superior de una entidad, el elemento superior de un elemento superior, etc., son los principales de la entidad. El elemento secundario de una entidad, el elemento secundario de un elemento secundario, etc., son los subordinados de una entidad. La secuencia de entidades que comienza con una entidad raíz y continúa de superior a subordinada, lo que lleva a una entidad determinada, constituye la ruta principal de esa entidad. La clave completa que identifica la entidad consta de una secuencia de pares de identificadores de tipo que especifican su ruta principal y terminan con los de la entidad en sí:

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

En el caso de una entidad raíz, la ruta de principales está vacía, y la clave consta solo del tipo y el 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 un elemento superior, especificas la ruta de acceso principal completa del elemento 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()

import datetime

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 array pueden ser útiles, por ejemplo, cuando se realizan consultas con filtros de igualdad: una entidad satisface la consulta 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:

Número entero de 32 bits.

API de REST
- nombre del campo: entityValue
- type: un mapa de entidades JSON que contiene una sola propiedad __int__ con un número entero integerValue
API de RPC
- nombre del campo: entity_value
- type: un mensaje Entity que contiene una sola propiedad __int__ con un integer_value
Orden de clasificación: numérico

Número entero de 64 bits

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

Arreglo

API de REST
- nombre del campo: arrayValue
- tipo: un objeto ArrayValue que contiene un arreglo de objetos de valor JSON
- Se puede asignar una propiedad de array con el campo arrayValue, que es de tipo ArrayValue, y configurar su campo values como un array de valores. Para que una propiedad no se indexe, 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 que una propiedad no esté indexada, configura el campo exclude_from_indexes de Value como 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

Marca de tiempo de BSON

API de REST
- nombre del campo: entityValue
- type: un mapa de entidades JSON que contiene una propiedad __request_timestamp__ con propiedades de números enteros seconds y increment
API de RPC
- nombre del campo: entity_value
- type: un mensaje Entity que representa una marca de tiempo de BSON que contiene seconds y increment
Orden de clasificación: cronológico
Notas: Es un valor de marca de tiempo de 64 bits que comprende segundos Unix y un contador de incremento.

Bytes (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).

Bytes con subtipo

API de REST
- nombre del campo: entityValue
- type: un mapa de entidades JSON que contiene una sola propiedad __binary__ con blobValue codificado en Base64 (el byte de subtipo se antepone a los datos)
API de RPC
- nombre del campo: entity_value
- type: un mensaje Entity que contiene una sola propiedad __binary__ con blob_value (byte de subtipo antepuesto a los datos)
Orden de clasificación: orden de bytes (subtipo y, luego, valor)
Notas: Secuencia de bytes binarios con un indicador de subtipo de BSON.

Fecha y hora (marca de tiempo)

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.

Decimal128

API de REST
- nombre del campo: entityValue
- type: un mapa de entidades JSON que contiene una sola propiedad __decimal128__ con un stringValue
API de RPC
- nombre del campo: entity_value
- type: un mensaje Entity que contiene una sola propiedad __decimal128__ con un string_value
Orden de clasificación: numérico
Notas: Número de punto flotante decimal de 128 bits para aritmética de alta precisión.

Double (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.

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.

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

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

MaxKey

API de REST
- nombre del campo: entityValue
- type: un mapa de entidades JSON que contiene una sola propiedad __max__ con un nullValue
API de RPC
- nombre del campo: entity_value
- type: un mensaje Entity que contiene una sola propiedad __max__ con un null_value

MinKey

API de REST
- nombre del campo: entityValue
- type: un mapa de entidades JSON que contiene una sola propiedad __min__ con un nullValue
API de RPC
- nombre del campo: entity_value
- type: un mensaje Entity que contiene una sola propiedad __min__ con un null_value

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

ObjectId

API de REST
- nombre del campo: entityValue
- type: un mapa de entidades JSON que contiene una sola propiedad __oid__ con un stringValue (cadena hexadecimal en minúsculas)
API de RPC
- nombre del campo: entity_value
- type: un mensaje Entity que contiene una sola propiedad __oid__ con un string_value
Orden de clasificación: Por secuencia de 12 bytes

Expresión regular

API de REST
- nombre del campo: entityValue
- type: un mapa de entidades JSON que contiene __regex__ con propiedades para pattern y options
API de RPC
- nombre del campo: entity_value
- type: un mensaje Entity que representa una expresión regular con las propiedades pattern y options
Orden: por patrón y, luego, por opciones

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
MinKey
Números enteros de 32 bits
Números enteros de 64 bits y marcas de tiempo
Valores booleanos
Cadenas de bytes y cadenas Unicode
Bytes con subtipos
Dobles (NaN se ordena al final)
Puntos geográficos
Claves del modo Datastore
ObjectId
Marca de tiempo de BSON
Expresión regular
Decimal128 (NaN se ordena al final)
MaxKey

Entidades, propiedades y claves Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Trabaja con entidades

Crear una entidad

C#

Go

Java

Node.js

PHP

Python

Ruby

C#

Go

Java

Node.js

PHP

Python

Ruby

C#

Go

Java

Node.js

PHP

Python

Ruby

Recupera una entidad

C#

Go

Java

Node.js

PHP

Python

Ruby

Actualiza una entidad

C#

Go

Java

Node.js

PHP

Python

Ruby

Borra una entidad

C#

Go

Java

Node.js

PHP

Python

Ruby

Operaciones por lotes

C#

Go

Java

Node.js

PHP

Python

Ruby

C#

Go

Java

Node.js

PHP

Python

Ruby

C#

Go

Java

Node.js

PHP

Python

Ruby

Incremento y otras transformaciones de propiedades

REST

REST

REST

Tipos mixtos con maximum y minimum

Mutaciones múltiples y PropertyMask

REST

REST

Identificadores y tipos

Asigna identificadores

Entidades, propiedades y claves

Tipos mixtos con `maximum` y `minimum`

Mutaciones múltiples y `PropertyMask`