‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

ישויות, מאפיינים ומפתחות

אובייקטים של נתונים ב-Firestore במצב Datastore נקראים ישויות. לישות יש מאפיין אחד או יותר עם שם, ולכל אחד מהם יכולים להיות ערך אחד או יותר. ישויות מאותו סוג לא חייבות לכלול את אותם מאפיינים, והערכים של ישות מסוימת במאפיין נתון לא חייבים להיות מאותו סוג נתונים. (אם צריך, אפליקציה יכולה להגדיר ולאכוף הגבלות כאלה במודל הנתונים שלה).

במצב Datastore יש תמיכה במגוון סוגי נתונים לערכי מאפיינים. למשל:

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

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

מרחב השמות של הישות, שמאפשר ריבוי דיירים (multitenancy)
סוג הישות, שמשמש לסיווג שלה לצורך שאילתות
מזהה של הישות הספציפית, שיכול להיות:
- מחרוזת של שם מפתח
- מזהה מספרי של מספר שלם
נתיב אב קדמון אופציונלי שמאתר את הישות בתוך היררכיית מסד הנתונים

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

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

קטעי הקוד בדף הזה מבוססים על הדוגמה במאמר תחילת השימוש ב-Firestore במצב Datastore.

עבודה עם ישויות

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

יצירת ישות

כדי ליצור ישות חדשה, צריך לאתחל אותה ולהגדיר את המאפיינים שלה:

C#

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

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

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

Go

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

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

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

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

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

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

PHP

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

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

Python

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

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

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

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

כדי לשמור את הישות במסד הנתונים, אפשר להשתמש ב-upsert (שיחליף ישות אם היא כבר קיימת במצב Datastore) או ב-insert (שמחייב שמפתח הישות לא יהיה קיים כבר).

כדי upsert ישות:

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

כדי insert ישות:

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#

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

עדכון ישות

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

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

הנתונים שסופקו מחליפים את הישות הקיימת. צריך לשלוח את כל האובייקט למסד הנתונים. אם הישות לא קיימת, העדכון ייכשל. אם רוצים לעדכן או ליצור ישות, משתמשים ב-upsert כפי שמתואר למעלה. שימוש בטרנזקציה מאפשר לבצע את הפעולות get ו-update בטרנזקציה אטומית אחת.

מחיקת ישות

אם יש לכם את המפתח של הישות, אתם יכולים delete אותה:

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

פעולות באצווה

ב-Firestore במצב Datastore יש תמיכה בגרסאות של פעולות באצווה, שמאפשרות לבצע פעולות בכמה אובייקטים בקריאה אחת במצב Datastore.

קריאות כאלה מהירות יותר מביצוע קריאות נפרדות לכל ישות, כי הן כרוכות בתקורה של קריאת שירות אחת בלבד. אם מעורבות כמה קבוצות של ישויות, העבודה על כל הקבוצות מתבצעת במקביל בצד השרת.

לדוגמה, אפשר upsert כמה ישויות:

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

אפשר לחפש כמה ישויות:

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

אפשר למחוק כמה ישויות:

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

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

גודל הישויות שמעורבות בפעולה לא משפיע על עלויות הקריאה, הכתיבה או המחיקה. עם זאת, גודל הישויות משפיע על עלויות נפח האחסון.

הגדלה ושינויים אחרים במאפיינים

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

במצב Datastore אפשר להשתמש בטרנספורמציות הבאות של מאפיינים:

increment
maximum
minimum
appendMissingElements
removeAllFromArray
setToServerValue(REQUEST_TIME)

בדוגמה הבאה מוצג שינוי של מאפיין. הפעולה הזו מגדילה את המאפיינים בערכים שצוינו:

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

בדוגמה הבאה, ערך המאפיין מוגדר לזמן שבו השרת עיבד את הבקשה, ברמת דיוק של אלפית השנייה.

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

בדוגמה הבאה, רכיבי המערך מתווספים אם הם חסרים.

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

סוגים מעורבים עם `maximum` ו-`minimum`

הטרנספורמציות של המאפיינים maximum ו-minimum מקבלות כקלט ערך של מספר שלם או ערך מסוג double (מספר נקודה צפה). הערך במאפיין היעד יכול להיות גם מספר שלם או ערך מסוג double.

אם המאפיין הוא לא מספר שלם או מספר double, או אם המאפיין לא קיים, הטרנספורמציה מגדירה את המאפיין לערך ולסוג הקלט שצוינו. אם מפעילים פעולת maximum כשהמאפיין וערך הקלט הם מסוגים שונים (כלומר, אחד הוא מספר שלם והשני הוא מספר ממשי), המאפיין מקבל את הסוג של האופרנד הגדול יותר. ב-minimum, המאפיין מקבל את הסוג של האופרנד הקטן יותר.

אם האופרנדים שווים (למשל 3 ו-3.0), המאפיין לא משתנה. הערכים 0,‏ 0.0 ו-0.0- הם כולם אפס. התוצאה של maximum או minimum של ערך מאוחסן אפס וערך קלט אפס היא תמיד הערך המאוחסן. התוצאה של maximum או minimum של כל ערך מספרי ו-NaN היא NaN.

מספר מוטציות ו-`PropertyMask`

השינויים בנכס מוחלים ברצף אחרי כל שינוי נוסף בבקשה. PropertyMask מגביל את המוטציות insert,‏ update ו-upsert למאפיינים שצוינו, אבל לא מגביל את הטרנספורמציות של המאפיינים.

לדוגמה, נתחיל עם הישות הבאה:

REST

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

הבקשה הבאה מעדכנת את a וגם את b, ואז מחילה טרנספורמציה של מאפיין על המאפיין 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
          }
        }
      ]
    }
  ]
}

התוצאה היא:

REST

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

סוגים ומזהים

כל ישות היא מסוג מסוים, שמסווג את הישות למטרת שאילתות. לדוגמה, אפליקציה של רשימת משימות יכולה לייצג כל משימה לביצוע באמצעות ישות מסוג Task.

כל שמות הסוגים שמתחילים בשני קווים תחתונים (__) שמורים ואי אפשר להשתמש בהם.

הקצאת מזהים

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

האפליקציה יכולה לציין מחרוזת שם מפתח משלה לישות.

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

בדוגמה הבאה נוצר מפתח מסוג Task שמשתמש בשם המפתח, "sampleTask", כמזהה:

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

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

בדוגמה הבאה נוצר מפתח מסוג Task, בלי להשתמש בשם מפתח. המפתח המלא (כולל המזהה שהוקצה אוטומטית) של הישות יוחזר כשישות עם מפתח חלקי נשמרת במצב 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"

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

הקצאת מזהה מספרי משלכם

במקום להשתמש במחרוזות של שמות מפתחות או ליצור מזהים מספריים באופן אוטומטי, אפליקציות מתקדמות יכולות לפעמים להקצות מזהים מספריים משלהן באופן ידני לישויות שהן יוצרות. עם זאת, חשוב לזכור שאין שום דבר שמונע ממסד נתונים במצב Datastore להקצות את אחד מהמזהים המספריים הידניים לישות אחרת. הדרך היחידה למנוע התנגשויות כאלה היא שהאפליקציה תקבל בלוק של מזהים באמצעות השיטה allocateIds().

מחולל המזהים האוטומטי של מצב Datastore יעקוב אחרי המזהים שהוקצו בשיטות האלה, ולא ישתמש בהם שוב לישות אחרת. כך תוכלו להשתמש במזהים האלה בבטחה בלי התנגשויות. אי אפשר לבחור באופן ידני אילו ערכים יוחזרו על ידי ה-method‏ allocateIds(). הערכים שמוחזרים על ידי allocateIds() מוקצים על ידי מצב Datastore.

נתיבי ישויות אם

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

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

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

בישות שורש, נתיב הישות האב ריק והמפתח מורכב רק מהסוג והמזהה של הישות עצמה:

[User:alice]

רמות של הורים

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

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

אם האפליקציה מארגנת ישויות מסוג Task קודם לפי ישויות מסוג User ואז לפי ישויות מסוג TaskList, צריך להשתמש בכמה רמות של הורים:

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

כמו שמוצג בדוגמה הקודמת, כשיוצרים ישות עם הורה, מציינים את נתיב הישויות האבות המלא של ההורה.

באפליקציה שמתחזקת פרופילי משתמשים, יכול להיות שתידרש רק רמה אחת של הורה לנתוני פרופיל המשתמש. לדוגמה, שימוש בנתיב של ישות אב ברמה אחת (User) לישויות מסוג Profile:

[User:alice, Profile:public]

באפליקציה שמספקת תזמון של חדרי ישיבות, יכול להיות שיהיה צורך בכמה רמות של הורים, כמו נתיב אב קדמון של Building/Floor בכמה רמות לישויות Room:

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

קבוצות של ישויות

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

מאפיינים וסוגי ערכים

ערכי הנתונים שמשויכים לישות מורכבים ממאפיין אחד או יותר. לכל מאפיין יש שם וערך אחד או יותר.

למאפיין יכולים להיות ערכים מכמה סוגים, ולשתי ישויות יכולים להיות ערכים מסוגים שונים לאותו מאפיין. מאפיין יכול להיות נוסף לאינדקס או לא נוסף לאינדקס (שאילתות שמסדרות או מסננות לפי מאפיין p יתעלמו מישויות שבהן p לא נוסף לאינדקס).

דוגמאות למאפיינים:

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

מאפייני המערך

מאפיין עם יותר מערך אחד נקרא מאפיין מערך. הדוגמה הזו מכילה שני מאפייני מערך. הראשון נקרא tags עם הערכים fun ו-programming. השני נקרא collaborators עם הערכים alice ו-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

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

סוגי ערכים נתמכים

המאפיינים מאוחסנים כמפה מסוג string/value שמכילה את השמות והערכים של מאפייני הישות. אלה סוגי הערכים הנתמכים:

מספר שלם של 32 ביט

‫API בארכיטקטורת REST
- שם השדה: entityValue
- type: מפת ישויות בפורמט JSON שמכילה מאפיין יחיד __int__ עם מספר שלם integerValue
‫API ל-RPC
- שם השדה: entity_value
- סוג: הודעת Entity שמכילה מאפיין יחיד __int__ עם integer_value
סדר המיון: מספרי

מספר שלם של 64 ביט

‫API בארכיטקטורת REST
- שם השדה: integerValue
- סוג: מספר או מחרוזת. צריך להשתמש במחרוזות למספרים שלמים שאי אפשר לייצג אותם כמספרים באופן מדויק.
‫API ל-RPC
- שם השדה: integer_value
- סוג: int64
סדר המיון: מספרי

מערך

‫API בארכיטקטורת REST
- שם השדה: arrayValue
- type: אובייקט ArrayValue שמכיל מערך של אובייקטים מסוג JSON Value
- כדי להקצות מאפיין מערך, משתמשים בשדה arrayValue מסוג ArrayValue ומגדירים את השדה values שלו למערך של ערכים. כדי להסיר נכס מהאינדקס, מגדירים את השדה excludeFromIndexes של אובייקט הערך של הנכס ל-true.
API ל-RPC
- שם השדה: array_value
- סוג: הודעת ArrayValue שמכילה הודעת Value אחת או יותר
- כדי להקצות מאפיין מערך, משתמשים בשדה array_value מסוג ArrayValue ומאכלסים את השדה values שלו בכמה אובייקטים מסוג Value. כדי להסיר נכס מהאינדקס, מגדירים את השדה exclude_from_indexes של Value לערך true.
סדר המיון: ללא
הערות: לא יכול להכיל ערך מערך אחר. מופע הערך לא יכול להגדיר את meaning או את exclude_from_indexes.

בוליאני

‫API בארכיטקטורת REST
- שם השדה: booleanValue
- סוג: true או false
‫API ל-RPC
- שם השדה: boolean_value
- סוג: bool
סדר המיון: false<true

חותמת זמן של BSON

‫API בארכיטקטורת REST
- שם השדה: entityValue
- סוג: מפת ישויות בפורמט JSON שמכילה את המאפיין __request_timestamp__ עם המאפיינים seconds ו-increment כמספרים שלמים
‫API ל-RPC
- שם השדה: entity_value
- סוג: הודעת Entity שמייצגת חותמת זמן של BSON שמכילה את seconds ו-increment
סדר המיון: כרונולוגי
הערות: ערך של חותמת זמן של 64 ביט שמורכב משניות של Unix וממונה מצטבר.

בייטים (Blob)

‫API בארכיטקטורת REST
- שם השדה: blobValue
- סוג: מחרוזת. חייב להיות בקידוד Base64.
‫API ל-RPC
- שם השדה: blob_value
- סוג: bytes
סדר המיון: סדר בתים
הערות: עד 1,500 בייטים אם המאפיין נוסף לאינדקס, אחרת עד 1,048,487 בייטים (1MiB פחות 89 בייטים).

בייטים עם סוג משנה

‫API בארכיטקטורת REST
- שם השדה: entityValue
- סוג: מפת ישויות בפורמט JSON שמכילה מאפיין יחיד __binary__ עם blobValue בקידוד base64 (בייט של סוג משנה שנוסף לפני הנתונים)
‫API ל-RPC
- שם השדה: entity_value
- סוג: הודעת Entity שמכילה מאפיין יחיד __binary__ עם blob_value (בייט של סוג משנה שנוסף לנתונים)
סדר המיון: סדר בייטים (סוג משנה, ואז ערך)
הערות: רצף בייטים בינארי עם אינדיקטור של סוג משנה של BSON.

תאריך ושעה (חותמת זמן)

‫API בארכיטקטורת REST
- שם השדה: timestampValue
- סוג: מחרוזת (בפורמט RFC 3339, עם אלפיות שנייה, למשל 2013-05-14T00:01:00.234Z)
‫API ל-RPC
- שם השדה: timestamp_value
- סוג: Timestamp
סדר המיון: כרונולוגי
הערות:
- כשמאוחסן במצב Datastore, הדיוק הוא רק עד מיקרו-שניות. כל דיוק נוסף מעוגל כלפי מטה.
- כשמוחזרים ערכים כחלק משאילתת הטלה, מצב Datastore ממיר את ערכי חותמות הזמן לערכים של מספרים שלמים במיקרו-שניות.

Decimal128

‫API בארכיטקטורת REST
- שם השדה: entityValue
- סוג: מפת ישויות בפורמט JSON שמכילה מאפיין יחיד __decimal128__ עם stringValue
‫API ל-RPC
- שם השדה: entity_value
- type: הודעת Entity שמכילה מאפיין יחיד __decimal128__ עם string_value
סדר המיון: מספרי
הערות: מספר עשרוני בשיטת נקודה צפה (floating-point) של 128 ביט לחישובים ברמת דיוק גבוהה.

מספר בשיטת נקודה צפה (Double)

‫API בארכיטקטורת REST
- שם השדה: doubleValue
- סוג: מספר
‫API ל-RPC
- שם השדה: double_value
- סוג: double
סדר המיון: מספרי
הערות: דיוק כפול של 64 ביט, IEEE 754

ישות מוטמעת

‫API בארכיטקטורת REST
- שם השדה: entityValue
- type: ישות JSON
‫API ל-RPC
- שם השדה: entity_value
- סוג: הודעת Entity
סדר המיון: ללא
הערות: כשהמאפיינים נוספים לאינדקס, אפשר לשלוח שאילתות לגבי מאפייני משנה. אם מחריגים את הערך הזה מהוספה לאינדקס, גם כל נכסי המשנה מוחרגים מהוספה לאינדקס.

נקודה גיאוגרפית

‫API בארכיטקטורת REST
- שם השדה: geoPointValue
- סוג: זוג קווי רוחב/אורך ב-JSON
‫API ל-RPC
- שם השדה: geo_point_value
- סוג: הודעה של LatLng
סדר המיון: לפי קו רוחב, ואז קו אורך

מפתח

‫API בארכיטקטורת REST
- שם השדה: keyValue
- סוג: מפתח JSON של מצב Datastore
‫API ל-RPC
- שם השדה: key_value
- type: a Key message
סדר המיון: לפי רכיבי הנתיב (סוג, מזהה, סוג, מזהה...)

MaxKey

‫API בארכיטקטורת REST
- שם השדה: entityValue
- type: מפת ישויות ב-JSON שמכילה מאפיין יחיד __max__ עם nullValue
‫API ל-RPC
- שם השדה: entity_value
- type: הודעת Entity שמכילה מאפיין יחיד __max__ עם null_value

MinKey

‫API בארכיטקטורת REST
- שם השדה: entityValue
- type: מפת ישויות בפורמט JSON שמכילה מאפיין יחיד __min__ עם nullValue
‫API ל-RPC
- שם השדה: entity_value
- סוג: הודעת Entity שמכילה מאפיין יחיד __min__ עם null_value

Null

‫API בארכיטקטורת REST
- שם השדה: nullValue
- type: null
‫API ל-RPC
- שם השדה: null_value
- סוג: NullValue
סדר המיון: ללא

ObjectId

‫API בארכיטקטורת REST
- שם השדה: entityValue
- סוג: מפת ישויות בפורמט JSON שמכילה מאפיין יחיד __oid__ עם stringValue (מחרוזת הקסדצימלית באותיות קטנות)
‫API ל-RPC
- שם השדה: entity_value
- type: הודעת Entity שמכילה מאפיין יחיד __oid__ עם string_value
סדר המיון: לפי רצף של 12 בייטים

ביטוי רגולרי

‫API בארכיטקטורת REST
- שם השדה: entityValue
- סוג: מפת ישויות בפורמט JSON שמכילה את __regex__ עם מאפיינים של pattern ו-options
‫API ל-RPC
- שם השדה: entity_value
- סוג: הודעת Entity שמייצגת ביטוי רגולרי עם המאפיינים pattern ו-options
סדר המיון: לפי תבנית, ואז לפי אפשרויות

מחרוזת טקסט

‫API בארכיטקטורת REST
- שם השדה: stringValue
- סוג: מחרוזת
‫API ל-RPC
- שם השדה: string_value
- סוג: string
סדר המיון: סדר בייטים בקידוד UTF-8
הערות: עד 1,500 בייטים אם המאפיין נוסף לאינדקס, אחרת עד 1,048,487 בייטים (1MiB פחות 89 בייטים).

סדר סוגי הערכים

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

ערכים ריקים
MinKey
מספרים שלמים של 32 ביט
מספרים שלמים וחותמות זמן של 64 ביט
ערכים בוליאניים
מחרוזות בייטים ומחרוזות Unicode
בייטים עם סוגי משנה
מספרים עשרוניים (NaN ממוין אחרון)
נקודות גיאוגרפיות
מפתחות במצב Datastore
ObjectId
חותמת זמן של BSON
ביטוי רגולרי
‫Decimal128 (ערכי NaN ממוינים בסוף)
MaxKey

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

עבודה עם ישויות

יצירת ישות

C#

Go

Java

Node.js

PHP

Python

Ruby

C#

Go

Java

Node.js

PHP

Python

Ruby

C#

Go

Java

Node.js

PHP

Python

Ruby

אחזור ישות

C#

Go

Java

Node.js

PHP

Python

Ruby

עדכון ישות

C#

Go

Java

Node.js

PHP

Python

Ruby

מחיקת ישות

C#

Go

Java

Node.js

PHP

Python

Ruby

פעולות באצווה

C#

Go

Java

Node.js

PHP

Python

Ruby

C#

Go

Java

Node.js

PHP

Python

Ruby

C#

Go

Java

Node.js

PHP

Python

Ruby

הגדלה ושינויים אחרים במאפיינים

REST

REST

REST

סוגים מעורבים עם maximum ו-minimum

מספר מוטציות ו-PropertyMask

REST

REST

סוגים ומזהים

הקצאת מזהים

ישויות, מאפיינים ומפתחות

סוגים מעורבים עם `maximum` ו-`minimum`

מספר מוטציות ו-`PropertyMask`