Questa pagina è stata tradotta dall'API Cloud Translation.

Entità, proprietà e chiavi

Gli oggetti dati in Firestore in modalità Datastore sono noti come entità. Un'entità ha una o più proprietà denominate, ciascuna delle quali può avere uno o più valori. Le entità dello stesso tipo non devono necessariamente avere le stesse proprietà e non tutti i valori di un'entità per una determinata proprietà devono essere dello stesso tipo. Se necessario, un'applicazione può stabilire e applicare queste restrizioni nel proprio modello dei dati.

La modalità Datastore supporta diversi tipi di dati per i valori delle proprietà. Alcuni esempi sono:

Numeri interi
Numeri con virgola mobile
Stringhe
Date
Dati binari

Ogni entità in un database in modalità Datastore ha una chiave che la identifica in modo univoco. La chiave è costituita dai seguenti componenti:

Lo spazio dei nomi dell'entità, che consente la multitenancy
Il kind dell'entità, che la classifica per lo scopo delle query
Un identificatore per la singola entità, che può essere:
- una stringa di nome chiave
- un ID numerico intero
Un percorso predecessore facoltativo che individua l'entità all'interno della gerarchia del database

Un'applicazione può recuperare una singola entità dal database utilizzando la chiave dell'entità oppure può recuperare una o più entità inviando una query in base alle chiavi o ai valori delle proprietà delle entità.

Firestore in modalità Datastore non applica restrizioni sulla struttura delle entità, ad esempio se una determinata proprietà ha un valore di un determinato tipo; questa attività viene lasciata all'applicazione.

Gli snippet in questa pagina si basano sull'esempio riportato in Introduzione a Firestore in modalità Datastore.

Utilizzare le entità

Le applicazioni possono utilizzare l'API Firestore in modalità Datastore per creare, recuperare, aggiornare ed eliminare le entità. Se l'applicazione conosce la chiave completa di un'entità (o può ricavarla dalla chiave, dal tipo e dall'identificatore padre), può utilizzare la chiave per operare direttamente sull'entità. Un'applicazione può anche ottenere la chiave di un'entità a seguito di una query; per ulteriori informazioni, consulta l'argomento Query.

Crea un'entità

Puoi creare una nuova entità inizializzandola e impostandone le proprietà:

C#

Per scoprire come installare e utilizzare la libreria client per Cloud Datastore, consulta librerie client di Cloud Datastore. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Datastore C#.

Per eseguire l'autenticazione in Cloud Datastore, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Puoi salvare l'entità nel database utilizzando upsert (che sovrascriverà un'entità se esiste già in modalità Datastore) o insert (che richiede che la chiave dell'entità non esista già).

Ecco come upsert un'entità:

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

Ecco come insert un'entità:

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 un'entità

Per recuperare un'entità dal database, utilizza la relativa chiave per una ricerca:

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

Aggiorna un'entità

Per update un'entità esistente, modifica le proprietà dell'entità recuperata in precedenza e archiviala utilizzando la chiave:

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

I dati forniti sovrascrivono l'entità esistente. L'intero oggetto deve essere inviato al database. Se l'entità non esiste, l'aggiornamento non andrà a buon fine. Se vuoi aggiornare o creare un'entità, utilizza upsert come descritto in precedenza. L'utilizzo di una transazione ti consente di eseguire le operazioni get e update in una singola transazione atomica.

Elimina un'entità

Data la chiave di un'entità, puoi delete l'entità:

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

Operazioni batch

Firestore in modalità Datastore supporta le versioni batch delle operazioni che consentono di operare su più oggetti in una singola chiamata in modalità Datastore.

Queste chiamate batch sono più veloci rispetto all'esecuzione di chiamate separate per ogni singola entità, perché comportano l'overhead per una sola chiamata di servizio. Se sono coinvolti più gruppi di entità, il lavoro per tutti i gruppi viene eseguito in parallelo sul lato server.

Ad esempio, puoi upsert più entità:

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

Puoi cercare più entità:

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

Puoi eliminare più entità:

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

Le operazioni in batch non modificano i costi di lettura, scrittura o eliminazione, documentati nella sezione Prezzi e quota. Ti verrà addebitato il costo di ogni chiave in un'operazione in batch, indipendentemente dall'esistenza di ogni chiave.

Le dimensioni delle entità coinvolte in un'operazione non influiscono sui costi di lettura, scrittura o eliminazione. Tuttavia, la dimensione delle entità influisce sui costi relativi alle dimensioni dello spazio di archiviazione.

Tipi e identificatori

Ogni entità è di un tipo particolare, che classifica l'entità ai fini delle query. Ad esempio, un'applicazione che contiene un elenco di attività potrebbe rappresentare ogni attività da completare con un'entità di tipo Task.

Tutti i nomi dei tipi che iniziano con due trattini bassi (__) sono riservati e non possono essere utilizzati.

Assegna identificatori

Oltre a un tipo, a ogni entità è assegnato un identificatore, che viene assegnato al momento della creazione dell'entità. Poiché fa parte della chiave dell'entità, l'identificatore è associato in modo permanente all'entità e non può essere modificato. Può essere assegnato in due modi:

L'applicazione può specificare la propria stringa del nome della chiave per l'entità.

Per informazioni sulla dimensione massima della stringa chiave di entità, consulta Limiti.
Puoi fare in modo che Firestore in modalità Datastore assegni automaticamente all'entità un ID numerico intero.

Nell'esempio seguente viene creata una chiave di tipo Task che utilizza il nome della chiave "sampleTask" come identificatore:

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

Gli ID possono anche essere assegnati automaticamente in modalità Datastore. La modalità Datastore genera una sequenza casuale di ID inutilizzati che sono distribuiti approssimativamente in modo uniforme. Ogni ID può contenere fino a 16 cifre decimali.

L'esempio seguente crea una chiave di tipo Task, senza utilizzare un nome della chiave. La chiave completa (incluso l'ID assegnato automaticamente) dell'entità viene restituita quando un'entità con la chiave incompleta viene salvata in modalità 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"

Se vuoi mostrare gli ID entità all'utente e/o dipendono dal loro ordine, la soluzione migliore è utilizzare l'allocazione manuale.

Assegna il tuo ID numerico

Anziché utilizzare le stringhe dei nomi delle chiavi o generare automaticamente ID numerici, a volte le applicazioni avanzate possono assegnare manualmente i propri ID numerici alle entità che creano. Tuttavia, tieni presente che non c'è nulla che possa impedire a un database in modalità Datastore di assegnare uno dei tuoi ID numerici manuali a un'altra entità. L'unico modo per evitare questi conflitti è fare in modo che l'applicazione ottenga un blocco di ID con il metodo allocateIds().

Il generatore di ID automatico in modalità Datastore tiene traccia degli ID assegnati con questi metodi e eviterà di riutilizzarli per un'altra entità, in modo da poterli utilizzare in modo sicuro senza conflitti. Non puoi scegliere manualmente i valori che vengono restituiti dal metodo allocateIds(). I valori restituiti da allocateIds() vengono assegnati dalla modalità Datastore.

Percorsi predecessori

Le entità in un database in modalità Datastore formano uno spazio strutturato in modo gerarchico simile alla struttura di directory di un file system. Quando crei un'entità, puoi facoltativamente designare un'altra entità come parent. La nuova entità è un'entità parent dell'entità padre. Tieni presente che, a differenza di un file system, l'entità padre non deve necessariamente esistere effettivamente. Un'entità senza un elemento padre è un'entità principale. L'associazione tra un'entità e l'entità padre è permanente e non può essere modificata una volta creata l'entità. La modalità Datastore non assegnerà mai lo stesso ID numerico a due entità con lo stesso elemento padre o a due entità principali (quelle senza un elemento padre).

Un'entità può avere più livelli di antenati e discendenti. L'entità padre, l'entità padre e così via in modo ricorsivo sono i suoi antenati; i relativi elementi figlio, figli e così via, sono i suoi discendenti. La sequenza di entità che inizia con un'entità base e procede dalla risorsa principale a quella secondaria e porta a una determinata entità, costituisce il percorso predecessore dell'entità. La chiave completa che identifica l'entità è composta da una sequenza di coppie di tipo-identifier che specificano il percorso dei predecessori e che termina con quelli dell'entità stessa:

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

Per unentità base, il percorso predecessore è vuoto e la chiave è composta esclusivamente dal tipo e dall'identificatore dell'entità:

[User:alice]

Livelli dei genitori

Utilizza i livelli dei genitori per organizzare i dati. Ad esempio, se la tua applicazione organizza le entità Task in base alle entità TaskList, utilizza un livello dell'entità padre:

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

Se l'applicazione organizza le entità Task prima in base alle entità User e poi in base alle entità TaskList, utilizza più livelli di elementi principali:

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

Come mostrato nell'esempio precedente, quando crei un'entità con un elemento padre, specifichi il percorso predecessore completo dell'elemento padre.

Un'applicazione che gestisce i profili utente può richiedere solo un livello principale per i dati del profilo utente. Ad esempio, utilizza un percorso predecessore User a livello singolo per le entità Profile:

[User:alice, Profile:public]

Un'applicazione che offre la pianificazione di sale conferenze può richiedere più livelli di elementi principali, ad esempio un percorso predecessore Building/Floor a più livelli per le entità Room:

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

Gruppi di entità

Un gruppo di entità è costituito da un'entità base e da tutti i suoi discendenti. Le applicazioni in genere utilizzano gruppi di entità per organizzare dati altamente correlati. Ad esempio, un'applicazione può utilizzare un gruppo di entità per archiviare i dati relativi a un prodotto o a un profilo utente.

Proprietà e tipi di valori

I valori dei dati associati a un'entità sono costituiti da una o più proprietà. Ogni proprietà ha un nome e uno o più valori.

Una proprietà può avere valori di più di un tipo e due entità possono avere valori di tipi diversi per la stessa proprietà. Una proprietà può essere indicizzata o non indicizzata (le query che ordinano o filtrano su una proprietà p ignorano le entità in cui p non è indicizzato).

Alcune proprietà di esempio:

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

Proprietà array

Una proprietà con più valori viene chiamata proprietà array. Questo esempio contiene due proprietà array. Il primo è denominato tags con i valori fun e programming. Il secondo è denominato collaborators con i valori alice e 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

Le proprietà degli array possono essere utili, ad esempio, quando si eseguono query con filtri di uguaglianza: un'entità soddisfa la query se uno qualsiasi dei suoi valori per una proprietà corrisponde al valore specificato nel filtro. Per ulteriori dettagli sulle proprietà degli array, inclusi i problemi di cui dovresti essere a conoscenza, consulta l'argomento Query.

Tipi di valori supportati

Le proprietà vengono memorizzate come una mappa string/value che contiene i nomi e i valori delle proprietà dell'entità. Per i valori sono supportati i seguenti tipi:

Array

API REST
- nome campo: arrayValue
- type: un oggetto ArrayValue che contiene un array di oggetti JSON Value
- Una proprietà array può essere assegnata utilizzando il campo arrayValue, di tipo ArrayValue, e impostando il relativo campo values su un array di valori. Per annullare l'indicizzazione di una proprietà, imposta il campo excludeFromIndexes dell'oggetto valore della proprietà su true.
API RPC
- nome campo: array_value
- type: un messaggio ArrayValue contenente uno o più messaggi Value
- Una proprietà array può essere assegnata utilizzando il campo array_value, di tipo ArrayValue, e compilando il relativo campo values con più oggetti Value. Affinché una proprietà non venga indicizzata, imposta il campo exclude_from_indexes di Value su true.
Ordinamento: nessuno
Note: non può contenere un altro valore dell'array. L'istanza del valore non deve impostare meaning o exclude_from_indexes.

Booleano

API REST
- nome campo: booleanValue
- tipo: true o false
API RPC
- nome campo: boolean_value
- tipo: bool
Ordinamento: false<true

Blob

API REST
- nome campo: blobValue
- type: stringa. Deve essere codificata in Base64.
API RPC
- nome campo: blob_value
- tipo: bytes
Ordinamento: byte
Note: fino a 1500 byte se la proprietà è indicizzata, fino a 1.048.487 byte (1 MiB - 89 byte).

Data e ora

API REST
- nome campo: timestampValue
- tipo: stringa (in formato RFC 3339, con millisecondi, ad esempio 2013-05-14T00:01:00.234Z)
API RPC
- nome campo: timestamp_value
- tipo: Timestamp
Ordinamento: cronologico
Note:
- Se archiviato in modalità Datastore, l'accuratezza è in pochi microsecondi; l'eventuale precisione aggiuntiva viene arrotondata per difetto.
- Quando viene restituita come parte di una query di proiezione, la modalità Datastore converte i valori del timestamp in valori interi in microsecondi.

Entità incorporata

API REST
- nome campo: entityValue
- type: un'entità JSON
API RPC
- nome campo: entity_value
- type: un messaggio Entity
Ordinamento: nessuno
Note: una volta eseguita l'indicizzazione, puoi eseguire query sulle proprietà secondarie. Se escludi questo valore dall'indicizzazione, anche tutte le proprietà secondarie verranno escluse dall'indicizzazione.

Numero con virgola mobile

API REST
- nome campo: doubleValue
- type: numero
API RPC
- nome campo: double_value
- tipo: double
Ordinamento: numerico
Note: Doppia precisione a 64 bit, IEEE 754

Punto geografico

API REST
- nome campo: geoPointValue
- type: una coppia JSON/latitudine/longitudine
API RPC
- nome campo: geo_point_value
- tipo: un messaggio LatLng
Ordinamento: per latitudine, poi longitudine

Integer

API REST
- nome campo: integerValue
- type: numero o stringa. Utilizza stringhe per numeri interi che non possono essere rappresentati esattamente come numeri.
API RPC
- nome campo: integer_value
- tipo: int64
Ordinamento: numerico

Chiave

API REST
- nome campo: keyValue
- type: una chiave JSON Datastore
API RPC
- nome campo: key_value
- tipo: un messaggio Key
Ordinamento: in base agli elementi del percorso (tipo, identificatore, tipo, identificatore...)

Null

API REST
- nome campo: nullValue
- tipo: null
API RPC
- nome campo: null_value
- tipo: NullValue
Ordinamento: nessuno

Stringa di testo

API REST
- nome campo: stringValue
- type: stringa
API RPC
- nome campo: string_value
- tipo: string
Ordinamento: ordine dei byte con codifica UTF-8
Note: fino a 1500 byte se la proprietà è indicizzata, fino a 1.048.487 byte (1 MiB - 89 byte).

Ordine del tipo di valore

Quando una query riguarda una proprietà con valori di tipi misti, un database in modalità Datastore utilizza un ordinamento deterministico basato sulle rappresentazioni interne. Il seguente elenco mostra l'ordine:

Valori null
Numeri a virgola fissa
- Numeri interi
- Date e ore
Valori booleani
Stringhe byte
Stringhe Unicode
Numeri con virgola mobile
Valori NAN
Punti geografici
Chiavi in modalità Datastore