Datastore 元数据

Google Cloud Datastore 能够以编程方式访问部分元数据以支持元编程，从而实现后端管理功能，简化一致性缓存以及类似的目的；例如，您可以使用它为应用构建自定义数据存储区查看器。可用的元数据包括应用使用的实体组、命名空间、实体种类和属性的相关信息，以及每个属性的属性表示法。

GCP Console 中的 Cloud Datastore 信息中心还提供一些有关应用的元数据，但其中显示的数据在某些重要方面与这些函数返回的数据有所不同。

• 时效性。 使用 API 读取元数据会获取当前数据，而信息中心中的数据每天只更新一次。
• 内容。 信息中心中的某些元数据不能通过 API 获得；反之亦然。
• 速度。 元数据获取和查询的计费方式与数据存储区获取和查询相同。元数据查询用于获取命名空间、种类和属性的相关信息，但通常执行起来较慢。根据经验，返回 N 个实体的元数据查询预计与各返回单个实体的 N 个普通查询的时间大致相同。此外，属性表示法查询（非仅限于键的属性查询）比仅限于键的属性查询慢。对实体组元数据进行的元数据获取比获取常规实体要快一些。

元数据查询

为元数据查询保留三种特殊实体种类：

实体	说明
__namespace__	用于查找应用实体中使用的所有命名空间。
__kind__	用于查询特定种类。
__property__	用于通过某个种类的属性进行查询。

这些种类不会与应用中可能已存在的其他相同名称的种类冲突。通过查询这些特殊种类，您可以检索包含所需元数据的实体。

元数据查询返回的实体是基于 Datastore 的当前状态动态生成的。虽然您可以创建种类 __namespace__、__kind__ 或 __property__ 的本地实体对象，但任何将其存储在 Datastore 中的尝试都将失败。

命名空间查询

您可以使用命名空间查询来查找应用的实体中使用的所有命名空间。这样您就可以跨多个命名空间执行管理功能等活动。

命名空间查询返回特殊种类 __namespace__ 的实体，其键名为命名空间的名称（由空字符串 "" 指定的默认命名空间例外：由于空字符串不是有效的键名，因此该命名空间改为以数字 ID 1 为键）。此类型的查询仅支持对特殊伪属性 __key__ 的范围进行过滤，该伪属性的值即为实体的键。结果可以按 __key__ 值升序（而不是降序）排序。因为 __namespace__ 实体没有属性，所以仅限于键的查询和非仅限于键的查询将返回相同的信息。

以下示例返回应用的命名空间列表，其范围介于分配给 startNamespace 和 endNamespace 变量的值之间：

C#

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore C# API 参考文档。

在 GitHub 上查看 反馈

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 参考文档。

在 GitHub 上查看 反馈

const (
	startNamespace = "g"
	endNamespace   = "h"
)
query := datastore.NewQuery("__namespace__").
	Filter("__key__ >=", startNamespace).
	Filter("__key__ <", endNamespace).
	KeysOnly()
keys, err := client.GetAll(ctx, query, nil)
if err != nil {
	log.Fatalf("client.GetAll: %v", err)
}

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

Java

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Java API 参考文档。

在 GitHub 上查看 反馈

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 参考文档。

在 GitHub 上查看 反馈

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('__key__', '>=', startKey)
    .filter('__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 参考文档。

在 GitHub 上查看 反馈

$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 参考文档。

在 GitHub 上查看 反馈

# 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 参考文档。

在 GitHub 上查看 反馈

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__ 的实体，其键名为实体种类的名称。此类型的查询隐式地限制于当前命名空间，并且仅支持对 __key__ 伪属性的范围进行过滤。结果可以按 __key__ 值升序（而不是降序）排序。因为 __kind__ 实体没有属性，所以仅限于键的查询和非仅限于键的查询将返回相同的信息。

以下示例打印应用中使用的种类列表：

C#

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore C# API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Go API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Java API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Node.js API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore PHP API 参考文档。

在 GitHub 上查看 反馈

$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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Python API 参考文档。

在 GitHub 上查看 反馈

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

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

Ruby

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Ruby API 参考文档。

在 GitHub 上查看 反馈

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

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

GQL

SELECT __key__ FROM __kind__

属性查询

属性查询返回种类为 __property__ 的实体，该实体表示与某实体种类关联的编入索引的属性。（不包括未编入索引的属性）。代表种类 k 的属性 p 的实体按以下方式构建：

• 实体的键具有种类 __property__ 和键名 p。
• 实体的父键具有种类 __kind__ 和键名 k。
• 实体的 property_representation 数组属性包含属性的所有表示法。

例如，如果数据存储区恰好包含具有 name 和 done 属性的两个 Task 实体：

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__ 伪属性的某个范围进行限定过滤。

“仅限于键”的属性查询比非仅限于键的查询更有效，因为不需要收集属性的表示法。以下示例将检索应用的所有实体种类的名称以及与各种类相关联的属性：

C#

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore C# API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Go API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Java API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Node.js API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore PHP API 参考文档。

在 GitHub 上查看 反馈

$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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Python API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Ruby API 参考文档。

在 GitHub 上查看 反馈

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__

属性查询：属性表示法

非仅限于键的属性查询称为“属性表示法查询”，其返回用于每个属性的值类型的相关额外信息。实体中表示种类 k 的属性 p 的 property_representation 属性是一个数组，它包含种类 k 的任何实体中的 p 值的所有表示法。

每个值具有以下表示法（请注意，某些值类型会有相同的表示法）：

值类型	表示法
整数	INT64
浮点数	DOUBLE
布尔值	BOOLEAN
文本字符串	STRING
字节字符串	STRING
日期和时间	INT64
数据存储区键	REFERENCE
嵌入式实体	STRING
数组	数组元素的表示法
地理位置点	POINT
Null	NULL

以下示例使用祖先实体属性查询查找 Task 种类的属性的所有表示法：

C#

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore C# API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Go API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Java API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Node.js API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore PHP API 参考文档。

在 GitHub 上查看 反馈

$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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Python API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Ruby API 参考文档。

在 GitHub 上查看 反馈

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__ 值升序（而不是降序）排序。过滤适用于种类属性对，先按种类排序，再按属性排序。例如，假设您的实体具有以下属性：

• 具有以下属性的种类 Task
  • created
  • priority
  • tags
• 具有以下属性的种类 TaskList
  • created

以下仅限于键的属性查询：

C#

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore C# API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Go API 参考文档。

不适用

Java

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Java API 参考文档。

在 GitHub 上查看 反馈

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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Node.js API 参考文档。

不适用

PHP

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore PHP API 参考文档。

在 GitHub 上查看 反馈

$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

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Python API 参考文档。

不适用

Ruby

要了解如何安装和使用 Cloud Datastore 客户端库，请参阅 Cloud Datastore 客户端库。如需了解详情，请参阅 Cloud Datastore Ruby API 参考文档。

在 GitHub 上查看 反馈

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 的属性，但不包括种类 Task 的 created 属性，因为此属性在为查询指定的范围之外。

注意：由于 __key__ 种类会对“种类属性对”进行过滤，因此您不能将单个查询用于不同种类中的相同属性名称。您可以查询所有种类（或一些种类）中的所有属性，但无法构造这样一个查询，例如在所有种类（或种类 A 和 B）中检索名称在 m 与 q 之间的所有属性。