Metadados do Datastore

O Firestore no modo Datastore fornece acesso a metadados como informações sobre grupos de entidade, namespaces, tipos de entidade, propriedades e representações de propriedade referentes a cada propriedade. É possível usar metadados, por exemplo, para criar um visualizador do Datastore personalizado para seu aplicativo ou para funções administrativas de back-end.

O Painel do Datastore, no Console do Cloud, também fornece alguns metadados sobre seu aplicativo, mas os dados exibidos nele diferem, em alguns aspectos importantes, dos retornados por essas funções.

  • Atualização. A leitura de metadados pela API fornece dados atuais, enquanto os dados do painel são atualizados somente uma vez por dia.
  • Conteúdo. Alguns metadados no painel não estão disponíveis por meio das APIs e vice-versa.
  • Velocidade. Consultas e resultados de metadados são faturados da mesma maneira que consultas e resultados do armazenamento de dados. As consultas de metadados que buscam informações sobre namespaces, tipos e propriedades costumam ter execução lenta. Como regra geral, uma consulta de metadados que retorna entidades N costuma levar mais ou menos o mesmo tempo que consultas N comuns, cada uma retornando uma única entidade. Além disso, as consultas de representação de propriedade, que têm somente propriedade sem chaves, são mais lentas do que as consultas de propriedades somente com chaves. Os resultados de metadados do grupo de entidades são um pouco mais rápidos do que os de uma entidade normal.

Consultas de metadados

Três tipos de entidades especiais são reservados para consultas de metadados:

Entidade Descrição
__namespace__ Usada para localizar todos os namespaces usados nas entidades do aplicativo.
__kind__ Usada para consultar um tipo específico.
__property__ Usada para consultar por uma propriedade de um tipo.

Esses tipos não entrarão em conflito com outros de nomes iguais que já existam no aplicativo. Ao consultar esses tipos especiais, é possível recuperar as entidades que contenham os metadados desejados.

As entidades retornadas por consultas de metadados são geradas dinamicamente, com base no estado atual do banco de dados. É possível criar objetos de entidades locais dos tipos __namespace__, __kind__ ou __property__, porém, qualquer tentativa de armazená-los no banco de dados falhará.

Consultas de namespace

Use uma consulta de namespace para encontrar todos os namespaces usados nas entidades do aplicativo. Isso permite que você execute atividades, como funções administrativas, em vários namespaces.

As consultas de namespace retornam entidades do tipo especial __namespace__. O nome de chave é o nome de um namespace. Uma exceção é o namespace padrão designado pela string vazia "": como a string vazia não é um nome de chave válido, esse namespace é identificado pelo ID numérico 1. As consultas desse tipo somente aceitam filtragem de intervalos na pseudopropriedade especial __key__. O valor é a chave da entidade. Os resultados podem ser classificados pelo valor __key__ crescente (mas não decrescente). Como as entidades __namespace__ não têm propriedades, as consultas apenas de chaves e sem chaves retornam as mesmas informações.

O exemplo a seguir retorna uma lista de namespaces de um aplicativo no intervalo entre os valores atribuídos às variáveis startNamespace e endNamespace:

C#

Para saber como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para C# (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Go (em inglês).


    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: %v", err)
    	}

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

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

Java

Para saber como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Java (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Storage para Node.js (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para PHP (em inglês).

$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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Python (em inglês).

# 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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Ruby (em inglês).

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 tipo

Consultas de tipo retornam entidades do tipo __kind__. O nome de chave é o nome de um tipo de entidade. As consultas desse tipo são implicitamente restritas ao namespace atual e somente aceitam filtragem para intervalos acima da pseudopropriedade __key__. Os resultados podem ser classificados por valor __key__ crescente (mas não decrescente). Como as entidades __kind__ não têm propriedades, as consultas apenas de chave e sem chave retornam as mesmas informações.

No exemplo a seguir, é impressa uma lista dos tipos usados em um aplicativo:

C#

Para saber como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para C# (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Go (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Java (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Storage para Node.js (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para PHP (em inglês).

$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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Python (em inglês).

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

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

Ruby

Para saber como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Ruby (em inglês).

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

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

GQL


    SELECT __key__ FROM __kind__

    

Consultas de propriedade

As consultas de propriedade retornam entidades do tipo __property__, que indicam as propriedades indexadas associadas a um tipo de entidade. As propriedades não indexadas não são incluídas. A entidade que representa a propriedade p do tipo k é criada da seguinte forma:

  • A chave da entidade tem o tipo __property__ e o nome de chave p.
  • A chave pai da entidade tem o tipo __kind__ e o nome de chave k.
  • A propriedade de matriz property_representation da entidade contém todas as representações da propriedade.

Por exemplo, se seu banco de dados contiver exatamente duas entidades Task com as propriedades name e done:

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

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

então as duas entidades retornadas por uma consulta __property__ serão:

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

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

As consultas de propriedade são implicitamente restritas ao namespace atual e são compatíveis com filtragem limitada a um ancestral ou um intervalo acima da pseudopropriedade __key__.

Uma consulta de propriedade apenas de chave é mais eficiente que uma consulta apenas sem chave, já que não é necessário coletar as representações da propriedade. No exemplo a seguir, recupera-se os nomes de todos os tipos de entidade de um aplicativo e as propriedades associadas a cada um deles:

C#

Para saber como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para C# (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Go (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Java (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Storage para Node.js (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para PHP (em inglês).

$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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Python (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Ruby (em inglês).

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 propriedade: representações de propriedades

As consultas de propriedades apenas sem chave, conhecidas como consultas de representação de propriedades, retornam mais informações sobre os tipos de valor usados para cada propriedade. A propriedade property_representation na entidade que representa a propriedade p do tipo k é uma matriz contendo todas as representações do valor de p em qualquer entidade do tipo k.

Cada valor tem a seguinte representação (alguns tipos de valor têm as mesmas representações):

Tipo de valor Representação
Número inteiro INT64
Número de ponto flutuante DOUBLE
Booleano BOOLEAN
String de texto STRING
String de bytes STRING
Data e hora INT64
Chave do armazenamento de dados REFERENCE
Entidade incorporada STRING
Matriz representação dos elementos da matriz
Ponto geográfico POINT
Nulo NULL

No exemplo a seguir, são encontradas todas as representações de propriedades do tipo Task, usando uma consulta de propriedade ancestral:

C#

Para saber como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para C# (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Go (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Java (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Storage para Node.js (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para PHP (em inglês).

$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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Python (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Ruby (em inglês).

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 propriedade: filtragem

As consultas de propriedade são compatíveis com a filtragem de ancestral em uma chave __kind__ ou __property__, para limitar os resultados da consulta a um único tipo ou propriedade, como visto na consulta de representação de propriedade acima.

As consultas de propriedade também podem ser filtradas com um intervalo acima da pseudopropriedade __key__, em que as chaves denotam entidades __kind__ ou __property__. Os resultados podem ser classificados por valor __key__ crescente (mas não decrescente). A filtragem é aplicada a pares de tipo/propriedade, classificados primeiro por tipo e depois por propriedade. Por exemplo, suponha que haja entidades com estas propriedades:

  • tipo Task com as propriedades
    • created
    • priority
    • tags
  • tipo TaskList com as propriedades
    • created

A seguinte consulta de propriedade apenas de chave:

C#

Para saber como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para C# (em inglês).

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 como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Go (em inglês).

Não relevante

Java

Para saber como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Java (em inglês).

Não relevante

Node.js

Para saber como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Storage para Node.js (em inglês).

Não relevante

PHP

Para saber como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para PHP (em inglês).

Não relevante

Python

Para saber como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Python (em inglês).

Não relevante

Ruby

Para saber como instalar e usar a biblioteca de cliente do Cloud Datastore, consulte as bibliotecas de cliente do Cloud Datastore. Para mais informações, consulte a documentação de referência de API do Cloud Datastore para Ruby (em inglês).

Não relevante

GQL

Não relevante

coletará os seguintes pares de nomes de tipo/propriedade:

Task, priority
    Task, tags
    TaskList, created
    

Observe que os resultados incluem propriedades dos tipos Task e TaskList, mas não incluem a propriedade created do tipo Task, porque ela está fora do intervalo especificado para a consulta.