Metadatos de Datastore

Google Cloud Datastore proporciona acceso programático a algunos de sus metadatos para permitir la metaprogramación, la implementación de funciones administrativas del backend, la simplificación del almacenamiento en caché coherente y propósitos similares. Lo puedes usar, por ejemplo, para crear un lector personalizado de almacén de datos para tu aplicación. Los metadatos disponibles incluyen información sobre los grupos de entidad, los espacios de nombres, los tipos de entidades y las propiedades que usa tu aplicación, así como las representaciones de propiedades para cada propiedad.

En el panel de Cloud Datastore en GCP Console también se proporcionan metadatos sobre tu aplicación, pero los datos que se muestran allí difieren en algunos aspectos importantes de los que se muestran en estas funciones.

  • Actualidad: Cuando se leen los metadatos con la API, se obtienen los datos actuales, mientras que los datos del panel se actualizan solo una vez por día.
  • Contenido: Algunos metadatos del panel no están disponibles mediante las API y viceversa.
  • Velocidad: La consulta y la obtención de metadatos se facturan de la misma forma que las de Datastore. Las consultas de metadatos que buscan información en espacios de nombres, tipos y propiedades son generalmente de ejecución lenta. Como regla general, una consulta de metadatos que muestre N entidades puede tomar el mismo tiempo que N consultas comunes que muestren una sola entidad cada una. Además, la consultas de representaciones de propiedades (consultas de propiedades no solo de claves) son más lentas que las consultas de propiedades solo de claves. La obtención de metadatos de grupos de entidad es más rápida que la de una entidad normal.

Consultas de metadatos

Hay tres tipos de entidades especiales reservados para las consultas de metadatos:

Entidad Descripción
__namespace__ Se usa para encontrar todos los espacios de nombres empleados en las entidades de tu aplicación.
__kind__ Se usa para consultar un tipo específico.
__property__ Se usa para consultar según una propiedad de un tipo.

Estos tipos no entrarán en conflicto con otros que tengan el mismo nombre y que ya existan en tu aplicación. Si consultas estos tipos especiales, puedes obtener entidades que contengan los metadatos deseados.

Las entidades que se muestran como resultado de las consultas de metadatos se generan dinámicamente según el estado actual de Datastore. Si bien puedes crear objetos de entidades locales de tipo __namespace__, __kind__ o __property__, todo intento de almacenarlos en Datastore fallará.

Consultas de espacio de nombres

Puedes usar una consulta de espacio de nombres para encontrar todos los espacios de nombres que se usan en las entidades de la aplicación. Esto te permite realizar actividades tales como las funciones administrativas en varios espacios de nombres.

Las consultas de espacios de nombres muestran entidades __namespace__ de tipo especial cuyo nombre de clave es el de un espacio de nombres. Una excepción es el espacio de nombres predeterminado designado por la string vacía "". Como la string vacía no es un nombre de clave válido, a este espacio de nombres se le asigna el ID numérico 1 como clave. Las consultas de este tipo admiten el filtrado solo para rangos superiores a la pseudopropiedad especial __key__, cuyo valor es la clave de la entidad. Se pueden ordenar los resultados según el valor __key__ de forma ascendente (pero no descendente). Dado que las entidades __namespace__ no tienen propiedades, tanto las consultas solo de claves como las que no lo son muestran la misma información.

En el ejemplo siguiente, se muestra una lista de los espacios de nombres de una aplicación en el rango de los valores asignados a las variables startNamespace y endNamespace:

C#

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de C# de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Go de Cloud Datastore. 

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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Java de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Node.js de 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('__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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de PHP de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de Cloud Datastore. 

# 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Ruby de 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__, 'namespace-a')
  AND __key__ <  KEY(__namespace__, 'namespace-b')

Consultas de tipos

Las consultas de tipos muestran entidades de tipo __kind__ cuyo nombre de clave es el nombre de un tipo de entidad. Las consultas de este tipo se restringen de forma implícita al espacio de nombres actual y permiten filtrar solo rangos superiores a la pseudopropiedad __key__. Se pueden ordenar los resultados según el valor __key__ de forma ascendente (pero no descendente). Dado que las entidades __kind__ no tienen propiedades, tanto las consultas solo de clave como las que no lo son muestran la misma información.

En el ejemplo siguiente, se muestra una lista de los tipos usados en una aplicación:

C#

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de C# de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Go de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Java de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Node.js de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de PHP de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de Cloud Datastore. 

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

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

Ruby

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Ruby de Cloud Datastore. 

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

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

GQL


SELECT __key__ FROM __kind__

Consultas de propiedades

Las consultas de propiedades muestran entidades de tipo __property__ que denotan las propiedades indexadas que están asociadas a un tipo de entidad. No se incluyen las propiedades no indexadas. La entidad que representa la propiedad p de tipo k se construye de la siguiente forma:

  • La clave de la entidad es de tipo __property__ y tiene nombre de clave p.
  • La clave principal de la entidad es de tipo __kind__ y tiene nombre de clave k.
  • La propiedad del arreglo property_representation de la entidad contiene todas las representaciones de la propiedad.

Por ejemplo, supón que tienes un almacén de datos que contiene exactamente dos entidades Task con las propiedades name y done:

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

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

En ese caso, la consulta de __property__ mostrará las siguientes dos entidades:

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

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

Las consultas de propiedades se restringen de forma implícita al espacio de nombres actual y permiten el filtrado limitado con una propiedad principal o un rango superior a la pseudopropiedad __key__.

Una consulta de propiedades solo de claves es más eficiente que una consulta que no sea solo de claves, ya que no necesita recopilar las representaciones de la propiedad. El siguiente ejemplo muestra los nombres de todos los tipos de entidades de una aplicación y las propiedades asociadas a cada uno:

C#

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de C# de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Go de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Java de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Node.js de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de PHP de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de Cloud Datastore. 

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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Ruby de 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__

Consultas de propiedades: representaciones de propiedades

Las consultas de propiedades que no son solo de claves, conocidas como consultas de representaciones de propiedades, muestran información adicional sobre los tipos de valores que se usan para cada propiedad. La propiedad property_representation de la entidad que representa la propiedad p de tipo k es un arreglo que contiene todas las representaciones de valor p en cualquier entidad de tipo k.

Cada valor tiene la representación siguiente (algunos tipos de valores comparten las representaciones):

Tipo de valor Representación
Número entero INT64
Número de coma flotante DOUBLE
Booleano BOOLEAN
String de texto STRING
String de bytes STRING
Fecha y hora INT64
Clave de Datastore REFERENCE
Entidad incorporada STRING
Arreglo representación de los elementos del arreglo
Punto geográfico POINT
Nulo NULL

En el siguiente ejemplo, se encuentran todas las representaciones de las propiedades de tipo Task mediante una consulta de propiedades principales:

C#

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de C# de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Go de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Java de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Node.js de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de PHP de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de Cloud Datastore. 

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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Ruby de 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__, 'Task')

Consultas de propiedades: filtrado

Las consultas de propiedades permiten el filtrado por principales de una clave __kind__ o __property__ a fin de limitar los resultados de la consulta a un solo tipo o a una sola propiedad, tal como se observa en la consulta de representaciones de propiedades anterior.

Las consultas de propiedades también se pueden filtrar con un rango superior a la pseudopropiedad __key__, en el caso en que las claves denotan entidades __kind__ o __property__. Se pueden ordenar los resultados según el valor __key__ de forma ascendente (pero no descendente). Se aplica el filtro a los pares tipo-propiedad, ordenados primero por tipo y después por propiedad. Por ejemplo, imagina que tienes entidades con las siguientes propiedades:

  • tipo Task con propiedades
    • created
    • priority
    • tags
  • tipo TaskList con propiedades
    • created

La siguiente consulta de propiedades solo de claves:

C#

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de C# de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Go de Cloud Datastore.

No aplicable

Java

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Java de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Node.js de Cloud Datastore.

No aplicable

PHP

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de PHP de 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

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de Cloud Datastore.

No aplicable

Ruby

Para saber cómo instalar y usar la biblioteca cliente de Cloud Datastore, consulta esta página. Si deseas obtener más información, consulta la documentación de referencia de la API de Ruby de 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__, 'Task', __property__, 'priority')

Recopilará los siguientes pares de nombre de propiedad y tipo:

Task, priority
Task, tags
TaskList, created

Observa que los resultados incluyen propiedades de tipo Task y TaskList, pero no incluyen la propiedad created de tipo Task, ya que no entra en el rango especificado para la consulta.

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

Esta página
Comentarios sobre la documentación
Documentación de Cloud Datastore
Comentarios sobre el producto