Datastore 元数据

Datastore 模式 Firestore 提供对元数据的访问权限，元数据包括实体组、命名空间、实体种类和属性的相关信息，以及每个属性的属性表示法。例如，您可以使用元数据为应用或后端管理功能构建自定义 Datastore 查看器。

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

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

元数据查询

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

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

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

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

命名空间查询

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

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

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

C#

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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__, n'amespace-a)'
  AND __key__  < KEY(__namespace__, n'amespace-b)'

种类查询

种类查询返回种类为 __kind__ 的实体，其键名为实体种类的名称。此类型的查询隐式地限制于当前命名空间，并且仅支持对 __key__ 伪属性的范围进行过滤。结果可以按 __key__ 值升序（但不能降序）排序。由于 __kind__ 实体没有属性，仅限于键的查询和非仅限于键的查询返回的信息相同。

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

C#

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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__, T'ask)'

属性查询：过滤

属性查询支持对 __kind__ 或 __property__ 键进行祖先过滤，以将查询结果限为单一种类或属性，如上面的属性表示法查询所示。

属性查询还可以通过伪属性 __key__ 的某个范围进行过滤，其中键表示 __kind__ 或 __property__ 实体。结果可以按 __key__ 值升序（但不能降序）排序。过滤适用于种类属性对，先按种类排序，再按属性排序。例如，假设您的实体具有以下属性：

• 种类 Task，其属性为：
  • created
  • priority
  • tags
• 种类 TaskList，其属性为：
  • created

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

C#

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

不适用

<ph type="x-smartling-placeholder">

</ph>

Java

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

不适用

<ph type="x-smartling-placeholder">

</ph>

PHP

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

不适用

<ph type="x-smartling-placeholder">

</ph>

Ruby

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

如需向 Cloud Datastore 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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__, T'ask,' __property__, p'riority)'

将收集以下种类属性名称对：

Task, priority
Task, tags
TaskList, created

请注意，查询结果包含 Task 和 TaskList 种类的属性，但不包含 Task 种类的 created 属性，因为此属性不在为查询指定的范围内。

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