Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

מטא-נתונים של Datastore

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

לוח הבקרה של Datastore ב-Console מספק גם מטא-נתונים מסוימים לגבי האפליקציה, אבל הנתונים שמוצגים שם שונים בפרטים חשובים מהנתונים שמוחזרים על ידי הפונקציות האלה. Google Cloud

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

שאילתות לקבלת מטא נתונים

שלושה סוגים מיוחדים של ישויות שמורים לשאילתות של מטא-נתונים:

ישות	תיאור
`__namespace__`	משמש כדי למצוא את כל מרחבי השמות שנעשה בהם שימוש בישויות של האפליקציה.
`__kind__`	משמש לשליחת שאילתה לגבי סוג ספציפי.
`__property__`	משמש לשליחת שאילתות לפי מאפיין מסוג מסוים.

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

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

שאילתות במרחב שמות

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

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

בדוגמה הבאה מוחזרת רשימה של מרחבי שמות של אפליקציה בטווח שבין הערכים שהוקצו למשתנים startNamespace ו-endNamespace:

C#

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

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

KeyFactory keyFactory = _db.CreateKeyFactory("__namespace__");
// List all the namespaces between a lower and upper bound.
string lowerBound = _db.NamespaceId.Substring(0,
    _db.NamespaceId.Length - 1);
string upperBound = _db.NamespaceId + "z";
Key startNamespace = keyFactory.CreateKey(lowerBound);
Key endNamespace = keyFactory.CreateKey(upperBound);
Query query = new Query("__namespace__")
{
    Filter = Filter.And(
        Filter.GreaterThan("__key__", startNamespace),
        Filter.LessThan("__key__", endNamespace))
};
var namespaces = new List<string>();
foreach (Entity entity in _db.RunQuery(query).Entities)
{
    namespaces.Add(entity.Key.Path[0].Name);
};

Go

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


func metadataNamespaces(w io.Writer, projectID string) error {
	// projectID := "my-project"

	ctx := context.Background()
	client, err := datastore.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("datastore.NewClient: %w", err)
	}
	defer client.Close()

	start := datastore.NameKey("__namespace__", "g", nil)
	end := datastore.NameKey("__namespace__", "h", nil)
	query := datastore.NewQuery("__namespace__").
		FilterField("__key__", ">=", start).
		FilterField("__key__", "<", end).
		KeysOnly()
	keys, err := client.GetAll(ctx, query, nil)
	if err != nil {
		return fmt.Errorf("client.GetAll: %w", err)
	}

	fmt.Fprintln(w, "Namespaces:")
	for _, k := range keys {
		fmt.Fprintf(w, "\t%v", k.Name)
	}
	return nil
}

Java

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

KeyFactory keyFactory = datastore.newKeyFactory().setKind("__namespace__");
Key startNamespace = keyFactory.newKey("g");
Key endNamespace = keyFactory.newKey("h");
Query<Key> query =
    Query.newKeyQueryBuilder()
        .setKind("__namespace__")
        .setFilter(
            CompositeFilter.and(
                PropertyFilter.gt("__key__", startNamespace),
                PropertyFilter.lt("__key__", endNamespace)))
        .build();
List<String> namespaces = new ArrayList<>();
QueryResults<Key> results = datastore.run(query);
while (results.hasNext()) {
  namespaces.add(results.next().getName());
}

Node.js

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

async function runNamespaceQuery(startNamespace, endNamespace) {
  const startKey = datastore.key(['__namespace__', startNamespace]);
  const endKey = datastore.key(['__namespace__', endNamespace]);

  const query = datastore
    .createQuery('__namespace__')
    .select('__key__')
    .filter(
      and([
        new PropertyFilter('__key__', '>=', startKey),
        new PropertyFilter('__key__', '<', endKey),
      ]),
    );

  const [entities] = await datastore.runQuery(query);
  const namespaces = entities.map(entity => entity[datastore.KEY].name);

  console.log('Namespaces:');
  namespaces.forEach(namespace => console.log(namespace));

  return namespaces;
}

PHP

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

$query = $datastore->query()
    ->kind('__namespace__')
    ->projection(['__key__'])
    ->filter('__key__', '>=', $datastore->key('__namespace__', $start))
    ->filter('__key__', '<', $datastore->key('__namespace__', $end));
$result = $datastore->runQuery($query);
/* @var array<string> $namespaces */
$namespaces = [];
foreach ($result as $namespace) {
    $namespaces[] = $namespace->key()->pathEnd()['name'];
}

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

# All namespaces
query = client.query(kind="__namespace__")
query.keys_only()

all_namespaces = [entity.key.id_or_name for entity in query.fetch()]

# Filtered namespaces
start_namespace = client.key("__namespace__", "g")
end_namespace = client.key("__namespace__", "h")
query = client.query(kind="__namespace__")
query.key_filter(start_namespace, ">=")
query.key_filter(end_namespace, "<")

filtered_namespaces = [entity.key.id_or_name for entity in query.fetch()]

Ruby

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

query = datastore.query("__namespace__")
                 .select("__key__")
                 .where("__key__", ">=", datastore.key("__namespace__", "g"))
                 .where("__key__", "<", datastore.key("__namespace__", "h"))

namespaces = datastore.run(query).map do |entity|
  entity.key.name
end

GQL

SELECT __key__ FROM __namespace__
WHERE __key__ >= KEY(__namespace__, 'namespace-a')
  AND __key__ <  KEY(__namespace__, 'namespace-b')

שאילתות מסוג Kind

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

בדוגמה הבאה מודפסת רשימה של הסוגים שנעשה בהם שימוש באפליקציה:

C#

Query query = new Query("__kind__");
var kinds = new List<string>();
foreach (Entity entity in _db.RunQuery(query).Entities)
{
    kinds.Add(entity.Key.Path[0].Name);
};

Go

query := datastore.NewQuery("__kind__").KeysOnly()
keys, err := client.GetAll(ctx, query, nil)
if err != nil {
	log.Fatalf("client.GetAll: %v", err)
}

kinds := make([]string, 0, len(keys))
for _, k := range keys {
	kinds = append(kinds, k.Name)
}

Java

Query<Key> query = Query.newKeyQueryBuilder().setKind("__kind__").build();
List<String> kinds = new ArrayList<>();
QueryResults<Key> results = datastore.run(query);
while (results.hasNext()) {
  kinds.add(results.next().getName());
}

Node.js

async function runKindQuery() {
  const query = datastore.createQuery('__kind__').select('__key__');

  const [entities] = await datastore.runQuery(query);
  const kinds = entities.map(entity => entity[datastore.KEY].name);

  console.log('Kinds:');
  kinds.forEach(kind => console.log(kind));

  return kinds;
}

PHP

$query = $datastore->query()
    ->kind('__kind__')
    ->projection(['__key__']);
$result = $datastore->runQuery($query);
/* @var array<string> $kinds */
$kinds = [];
foreach ($result as $kind) {
    $kinds[] = $kind->key()->pathEnd()['name'];
}

Python

from google.cloud import datastore

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

query = client.query(kind="__kind__")
query.keys_only()

kinds = [entity.key.id_or_name for entity in query.fetch()]

Ruby

query = datastore.query("__kind__")
                 .select("__key__")

kinds = datastore.run(query).map do |entity|
  entity.key.name
end

GQL

SELECT __key__ FROM __kind__

שאילתות לגבי נכסים

שאילתות מאפיינים מחזירות ישויות מסוג __property__ שמציינות את המאפיינים המאונדקסים שמשויכים לסוג ישות. (לא נכללים מאפיינים שלא נוספו לאינדקס). הישות שמייצגת את המאפיין p מסוג k בנויה כך:

המפתח של הישות הוא מסוג __property__ ושם המפתח הוא p.
מפתח האב של הישות הוא מסוג __kind__ ושם המפתח הוא k.
מאפיין המערך property_representation של הישות מכיל את כל הייצוגים של המאפיין.

לדוגמה, אם מסד הנתונים מכיל בדיוק שני ישויות Task עם מאפיינים name ו-done:

Key: 'Task:1'
name: 'Read some properties'
done: true

Key: 'Task:2'
name: 'Climb'
done: null

אז שתי הישויות שיוחזרו על ידי שאילתת __property__ יהיו:

Key: '__kind__:Task/__property__:name'
property_representation: [ 'STRING' ]

Key: '__kind__:Task/__property__:done'
property_representation: [ 'BOOLEAN', 'NULL' ]

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

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

C#

Query query = new Query("__property__");
var properties = new List<string>();
foreach (Entity entity in _db.RunQuery(query).Entities)
{
    string kind = entity.Key.Path[0].Name;
    string property = entity.Key.Path[1].Name;
    if (kind == "Task")
        properties.Add(property);
};

Go

query := datastore.NewQuery("__property__").KeysOnly()
keys, err := client.GetAll(ctx, query, nil)
if err != nil {
	log.Fatalf("client.GetAll: %v", err)
}

props := make(map[string][]string) // Map from kind to slice of properties.
for _, k := range keys {
	prop := k.Name
	kind := k.Parent.Name
	props[kind] = append(props[kind], prop)
}

Java

Query<Key> query = Query.newKeyQueryBuilder().setKind("__property__").build();
QueryResults<Key> keys = datastore.run(query);
Map<String, Collection<String>> propertiesByKind = new HashMap<>();
while (keys.hasNext()) {
  Key key = keys.next();
  String kind = key.getParent().getName();
  String propertyName = key.getName();
  Collection<String> properties = propertiesByKind.get(kind);
  if (properties == null) {
    properties = new HashSet<>();
    propertiesByKind.put(kind, properties);
  }
  properties.add(propertyName);
}

Node.js

async function runPropertyQuery() {
  const query = datastore.createQuery('__property__').select('__key__');
  const [entities] = await datastore.runQuery(query);
  // @TODO convert below object to map
  const propertiesByKind = {};

  entities.forEach(entity => {
    const key = entity[datastore.KEY];
    const kind = key.path[1];
    const property = key.path[3];

    propertiesByKind[kind] = propertiesByKind[kind] || [];
    propertiesByKind[kind].push(property);
  });

  console.log('Properties by Kind:');
  for (const key in propertiesByKind) {
    console.log(key, propertiesByKind[key]);
  }

  return propertiesByKind;
}

PHP

$query = $datastore->query()
    ->kind('__property__')
    ->projection(['__key__']);
$result = $datastore->runQuery($query);
/* @var array<string> $properties */
$properties = [];
/* @var Entity $entity */
foreach ($result as $entity) {
    $kind = $entity->key()->path()[0]['name'];
    $propertyName = $entity->key()->path()[1]['name'];
    $properties[] = "$kind.$propertyName";
}

Python

from google.cloud import datastore

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

from collections import defaultdict

query = client.query(kind="__property__")
query.keys_only()

properties_by_kind = defaultdict(list)

for entity in query.fetch():
    kind = entity.key.parent.name
    property_ = entity.key.name

    properties_by_kind[kind].append(property_)

Ruby

query = datastore.query("__property__")
                 .select("__key__")

entities = datastore.run query
properties_by_kind = entities.each_with_object({}) do |entity, memo|
  kind = entity.key.parent.name
  prop = entity.key.name
  memo[kind] ||= []
  memo[kind] << prop
end

GQL

SELECT __key__ FROM __property__

שאילתות על נכסים: ייצוגים של נכסים

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

לכל value יש את הייצוג הבא (שימו לב שלחלק מסוגי הערכים יש ייצוגים משותפים):

סוג הערך	ייצוג
מספר שלם	`INT64`
מספר בשיטת נקודה צפה	`DOUBLE`
בוליאני	`BOOLEAN`
מחרוזת טקסט	`STRING`
מחרוזת בייטים	`STRING`
תאריך ושעה	`INT64`
מפתח Datastore	`REFERENCE`
ישות מוטמעת	`STRING`
מערך	ייצוג של רכיבי המערך
נקודה גיאוגרפית	`POINT`
Null	`NULL`

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

C#

Key key = _db.CreateKeyFactory("__kind__").CreateKey("Task");
Query query = new Query("__property__")
{
    Filter = Filter.HasAncestor(key)
};
var properties = new List<string>();
foreach (Entity entity in _db.RunQuery(query).Entities)
{
    string kind = entity.Key.Path[0].Name;
    string property = entity.Key.Path[1].Name;
    var representations = entity["property_representation"]
        .ArrayValue.Values.Select(x => x.StringValue)
        .OrderBy(x => x);
    properties.Add($"{property}:" +
        string.Join(",", representations));
};

Go

kindKey := datastore.NameKey("__kind__", "Task", nil)
query := datastore.NewQuery("__property__").Ancestor(kindKey)

type Prop struct {
	Repr []string `datastore:"property_representation"`
}

var props []Prop
keys, err := client.GetAll(ctx, query, &props)

Java

Key key = datastore.newKeyFactory().setKind("__kind__").newKey("Task");
Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("__property__")
        .setFilter(PropertyFilter.hasAncestor(key))
        .build();
QueryResults<Entity> results = datastore.run(query);
Map<String, Collection<String>> representationsByProperty = new HashMap<>();
while (results.hasNext()) {
  Entity result = results.next();
  String propertyName = result.getKey().getName();
  List<StringValue> representations = result.getList("property_representation");
  Collection<String> currentRepresentations = representationsByProperty.get(propertyName);
  if (currentRepresentations == null) {
    currentRepresentations = new HashSet<>();
    representationsByProperty.put(propertyName, currentRepresentations);
  }
  for (StringValue value : representations) {
    currentRepresentations.add(value.get());
  }
}

Node.js

async function runPropertyByKindQuery() {
  const ancestorKey = datastore.key(['__kind__', 'Account']);

  const query = datastore
    .createQuery('__property__')
    .hasAncestor(ancestorKey);
  const [entities] = await datastore.runQuery(query);

  const representationsByProperty = {};

  entities.forEach(entity => {
    const key = entity[datastore.KEY];
    const propertyName = key.name;
    const propertyType = entity.property_representation;

    representationsByProperty[propertyName] = propertyType;
  });

  console.log('Task property representations:');
  for (const key in representationsByProperty) {
    console.log(key, representationsByProperty[key]);
  }

  return representationsByProperty;
}

PHP

$ancestorKey = $datastore->key('__kind__', 'Task');
$query = $datastore->query()
    ->kind('__property__')
    ->hasAncestor($ancestorKey);
$result = $datastore->runQuery($query);
/* @var array<string,string> $properties */
$properties = [];
/* @var Entity $entity */
foreach ($result as $entity) {
    $propertyName = $entity->key()->path()[1]['name'];
    $propertyType = $entity['property_representation'];
    $properties[$propertyName] = $propertyType;
}
// Example values of $properties: ['description' => ['STRING']]

Python

from google.cloud import datastore

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

ancestor = client.key("__kind__", "Task")
query = client.query(kind="__property__", ancestor=ancestor)

representations_by_property = {}

for entity in query.fetch():
    property_name = entity.key.name
    property_types = entity["property_representation"]

    representations_by_property[property_name] = property_types

Ruby

ancestor_key = datastore.key "__kind__", "Task"
query = datastore.query("__property__")
                 .ancestor(ancestor_key)

entities = datastore.run query
representations = entities.each_with_object({}) do |entity, memo|
  property_name = entity.key.name
  property_types = entity["property_representation"]
  memo[property_name] = property_types
end

GQL

SELECT * FROM __property__
WHERE __key__ HAS ANCESTOR KEY(__kind__, 'Task')

שאילתות לגבי נכסים: סינון

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

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

‫kind Task עם מאפיינים
- created
- priority
- tags
‫kind TaskList עם מאפיינים
- created

שאילתת הנכס הבאה עם מפתחות בלבד:

C#

Key key = _db.CreateKeyFactory("__kind__").CreateKey("Task");
Key startKey = new KeyFactory(key, "__property__")
    .CreateKey("priority");
Query query = new Query("__property__")
{
    Filter = Filter.GreaterThanOrEqual("__key__", startKey)
};
var properties = new List<string>();
foreach (Entity entity in _db.RunQuery(query).Entities)
{
    string kind = entity.Key.Path[0].Name;
    string property = entity.Key.Path[1].Name;
    properties.Add($"{kind}.{property}");
};

Go

לא רלוונטי

Java

Key startKey =
    datastore
        .newKeyFactory()
        .setKind("__property__")
        .addAncestors(PathElement.of("__kind__", "Task"))
        .newKey("priority");
Query<Key> query =
    Query.newKeyQueryBuilder()
        .setKind("__property__")
        .setFilter(PropertyFilter.ge("__key__", startKey))
        .build();
Map<String, Collection<String>> propertiesByKind = new HashMap<>();
QueryResults<Key> keys = datastore.run(query);
while (keys.hasNext()) {
  Key key = keys.next();
  String kind = key.getParent().getName();
  String propertyName = key.getName();
  Collection<String> properties = propertiesByKind.get(kind);
  if (properties == null) {
    properties = new HashSet<String>();
    propertiesByKind.put(kind, properties);
  }
  properties.add(propertyName);
}

Node.js

לא רלוונטי

PHP

$ancestorKey = $datastore->key('__kind__', 'Task');
$startKey = $datastore->key('__property__', 'priority')
    ->ancestorKey($ancestorKey);
$query = $datastore->query()
    ->kind('__property__')
    ->filter('__key__', '>=', $startKey);
$result = $datastore->runQuery($query);
/* @var array<string> $properties */
$properties = [];
/* @var Entity $entity */
foreach ($result as $entity) {
    $kind = $entity->key()->path()[0]['name'];
    $propertyName = $entity->key()->path()[1]['name'];
    $properties[] = "$kind.$propertyName";
}

Python

לא רלוונטי

Ruby

start_key = datastore.key [["__kind__", "Task"], ["__property__", "priority"]]
query = datastore.query("__property__")
                 .select("__key__")
                 .where("__key__", ">=", start_key)

entities = datastore.run query
properties_by_kind = entities.each_with_object({}) do |entity, memo|
  kind = entity.key.parent.name
  prop = entity.key.name
  memo[kind] ||= []
  memo[kind] << prop
end

GQL

SELECT __key__ FROM __property__
WHERE __key__ >= KEY(__kind__, 'Task', __property__, 'priority')

ייאספו זוגות מהסוגים הבאים של שמות מאפיינים:

Task, priority
Task, tags
TaskList, created

שימו לב שהתוצאות כוללות נכסים מסוגים Task ו-TaskList, אבל לא כוללות את הנכס created מסוג Task, כי הוא לא נמצא בטווח שצוין בשאילתה.

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

שאילתות לקבלת מטא נתונים

שאילתות במרחב שמות

C#

Go

Java

Node.js

PHP

Python

Ruby

GQL

שאילתות מסוג Kind

C#

Go

Java

Node.js

PHP

Python

Ruby

GQL

שאילתות לגבי נכסים

C#

Go

Java

Node.js

PHP

Python

Ruby

GQL

שאילתות על נכסים: ייצוגים של נכסים

C#

Go

Java

Node.js

PHP

Python

Ruby

GQL

שאילתות לגבי נכסים: סינון

C#

Go

Java

Node.js

PHP

Python

Ruby

GQL

מטא-נתונים של Datastore