Cloud Firestore-Firebase

Cloud Firestore (Database - Firebase)
Use nosso banco de dados de nuvem NoSQL flexível e escalonável para

armazenar e sincronizar dados no desenvolvimento do cliente e do servidor.
O Cloud Firestore é um banco de dados flexível e escalonável para
desenvolvimento de dispositivos móveis, Web e servidores a partir do Firebase
e do Google Cloud Platform. Como o Firebase Realtime Database, ele mantém
seus dados em sincronia em aplicativos cliente por meio de listeners em tempo
real. Além disso, oferece suporte off-line para dispositivos móveis e Web para
que você possa criar aplicativos responsivos que funcionem independentemente
da latência da rede ou da conectividade com a Internet. O Cloud Firestore
também oferece integração perfeita com outros produtos do Firebase e do
Google Cloud Platform, incluindo o Cloud Functions.
Como funciona?
O Cloud Firestore é um banco de dados NoSQL

hospedado na nuvem que os apps do iOS, do
Android e da Web podem acessar diretamente por
meio de SDKs nativos. Ele também está disponível
em SDKs nativos Node.js, Java, Python e Go, bem
como em REST e RPC APIs.
Seguindo o modelo de dados NoSQL do Cloud

Firestore, você armazena dados em documentos
que contêm mapeamentos de campos para
valores. Esses documentos são armazenados em
coleções, que são contêineres de documentos que você pode usar para
organizar dados e criar consultas. Os documentos são compatíveis com
muitos tipos de dados diferentes, desde strings e números simples a objetos
complexos e aninhados. Também é possível criar subcoleções dentro dos
documentos e criar estruturas de dados hierárquicas que podem ser
escalonadas à medida que o banco de dados cresce. O modelo de dados do
Cloud Firestore é compatível com qualquer estrutura de dados que funcione
melhor para seu app.
Além disso, as consultas no Cloud Firestore são expressivas, eficientes e

flexíveis. Crie consultas superficiais para recuperar dados no nível do documento
sem precisar recuperar a coleção inteira ou qualquer subcoleção aninhada.
Adicione classificação, filtragem e limites às consultas ou cursores para paginar
os resultados. Para manter os dados atualizados nos aplicativos sem recuperar
todo o banco de dados sempre que ocorrer uma atualização, adicione listeners
em tempo real. Com eles, você é notificado com um instantâneo de dados em
seu app sempre que houver mudanças nos dados que seus apps cliente estão
detectando, recuperando somente as novas alterações.
Proteja o acesso aos dados no Cloud Firestore com o Firebase Authentication e

as regras de segurança do Cloud Firestore para Android, iOS e JavaScript, ou
com o gerenciamento de identidade e acesso (IAM, na sigla em inglês) para
linguagens do servidor.
Primeiros passos com o Cloud
Firestore
Neste guia de início rápido, mostraremos como configurar o Cloud Firestore,
adicionar dados e ver os dados adicionados no Console do Firebase.
Criar um banco de dados do Cloud Firestore
1. Crie um projeto do Firebase, se você ainda não fez isso: no Console do

Firebase (em inglês), clique em Adicionar projeto e siga as instruções na tela
para criar um projeto ou adicionar serviços do Firebase a um projeto do GCP.
2. No painel de navegação do console, selecione Banco de dados e clique em
Criar banco de dados para o Cloud Firestore.
3. Selecione um modo inicial para as regras de segurança do Cloud Firestore:
Modo de teste
Ideal para dar os primeiros passos com as bibliotecas de cliente de

dispositivos móveis e Web. No entanto, esse modo permite que qualquer
pessoa leia e modifique os dados. Depois do teste, analise a
seção Proteger seus dados.
Selecione o modo de teste para começar a usar o SDK para Android,
iOS ou da Web.
Modo bloqueado
Nega todas as leituras e gravações de clientes de dispositivos móveis e

da Web. Seus servidores de aplicativos autenticados (C#, Go, Java,
Node.js, PHP, Python ou Ruby) ainda podem acessar o banco de dados.
Selecione o modo bloqueado para começar a usar a biblioteca de cliente
do servidor para C#, Go, Java, Node.js, PHP, Python ou Ruby.
4. Selecione um local para seu banco de dados.
• Essa configuração de localização é o local padrão dos recursos do Google
Cloud Platform (GCP) no seu projeto. Esse local será usado para serviços do
GCP no projeto que exigem uma configuração de local, especificamente o
intervalo padrão do Cloud Storage e o aplicativo do App Engine que é
obrigatório se você usa o Cloud Scheduler.
• Se você não conseguir selecionar um local, isso significa que seu projeto já tem
um local padrão dos recursos do GCP. Ele foi definido durante a criação do
projeto ou na configuração de outro serviço que exigia uma configuração de
local.
Configurar o ambiente de desenvolvimento
Adicione as dependências e as bibliotecas de cliente necessárias ao aplicativo.
SiteiOSJavaKotlinJavaPythonNode.jsGoPHPC#Ruby
1. Adicione o SDK Admin do Firebase ao seu app:
npm install firebase-admin --save
2. Siga as instruções abaixo para inicializar o Cloud Firestore com as credenciais apropriadas no
seu ambiente.
Inicializar o Cloud Firestore
Inicializar uma instância do Cloud Firestore:
WebSwiftObjective-CJavaKotlinJavaPythonNode.jsGoPHPMais
O SDK do Cloud Firestore é inicializado de diferentes maneiras, dependendo do seu ambiente.

Veja abaixo os métodos mais comuns. Para uma referência completa, consulte Inicializar o SDK
Admin.
• Inicializar no Cloud Functions

const admin = require('firebase-admin');
const functions = require('firebase-functions');
admin.initializeApp(functions.config().firebase);
let db = admin.firestore();
index.js
• Inicializar no Google Cloud Platform

admin.initializeApp({
credential: admin.credential.applicationDefault()
});
const db = admin.firestore();
// ...
index.js
• Inicializar no seu próprio servidor
Para usar o SDK Admin do Firebase mo seu próprio servidor ou em qualquer outro
ambiente Node.js, use uma conta de serviço. Acesse IAM e administrador > Contas
de serviço (em inglês) no Console do Cloud Platform. Gere uma nova chave privada e
salve o arquivo JSON. Em seguida, use o arquivo para inicializar o SDK:
let serviceAccount = require('path/to/serviceAccountKey.json');
admin.initializeApp({
credential: admin.credential.cert(serviceAccount)
});
let db = admin.firestore();
Modelo de dados do Cloud Firestore
O Cloud Firestore é um banco de dados NoSQL orientado a documentos. Ao

contrário de um banco de dados SQL, não há tabelas nem linhas. Em vez disso,
os dados são armazenados em documentos, que são organizados em coleções.
Cada documento contém um conjunto de pares chave-valor. O Cloud Firestore

é otimizado para armazenar grandes coleções de documentos pequenos.
É necessário que todos os documentos sejam armazenados em coleções. Os

documentos podem conter subcoleções e objetos aninhados, que podem incluir
campos primitivos, como strings, ou objetos complexos, como listas.
Coleções e documentos são criados implicitamente no Cloud Firestore. Basta

atribuir dados a um documento dentro de uma coleção. Se a coleção ou o
documento não existir, o Cloud Firestore o criará.
Documentos
No Cloud Firestore, a unidade de armazenamento é o documento. Um

documento é um registro leve que contém campos, que são mapeados para
valores. Cada documento é identificado por um nome.
Um documento que representa um usuário alovelace pode ser assim:
Observação: O Cloud Firestore é compatível com vários tipos de dados de valores:

booleano, número, string, ponto geográfico, blob binário e carimbo de data/hora. Use
arrays ou objetos aninhados, chamados mapas, para estruturar dados em um
documento.
Objetos complexos e aninhados em um documento são chamados de mapas.

Por exemplo, é possível estruturar o nome do usuário do exemplo acima com um
mapa, como este:
Observe que os documentos parecem muito com documentos JSON. Na
verdade, basicamente eles são. Há algumas diferenças, por exemplo, os
documentos são compatíveis com tipos de dados extras e têm o tamanho
limitado a 1 MB, no entanto, geralmente eles podem ser tratados como
registros JSON leves.
Coleções
Os documentos pertencem a coleções, que são

simplesmente recipientes para documentos. Por
exemplo, é possível ter uma coleção users para
conter seus vários usuários, cada um representado
por um documento:
O Cloud Firestore não usa esquemas. Portanto, você tem total liberdade sobre
quais os campos colocar em cada documento e que tipos de dados armazenar
nesses campos. Os documentos dentro da mesma coleção podem conter
diferentes campos ou armazenar diferentes tipos de dados nesses campos. No
entanto, é recomendável usar os mesmos campos e tipos de dados em vários
documentos que, assim, poderão ser consultados com mais facilidade.
Uma coleção não contém nada além de documentos. Não pode conter
diretamente campos brutos com valores e não pode conter outras coleções.
(Consulte Dados hierárquicos para saber mais sobre como estruturar dados
complexos no Cloud Firestore.)
Os nomes dos documentos dentro de uma coleção são únicos. Forneça suas
próprias chaves, como IDs de usuário, ou permita que o Cloud Firestore crie
automaticamente IDs aleatórios para você.
Não é preciso "criar" ou "excluir" coleções. Depois de criar o primeiro

documento em uma coleção, ela passa a existir. Se você excluir todos os
documentos em uma coleção, ela deixará de existir.
Referências
Cada documento no Cloud Firestore é identificado de maneira exclusiva pela

respectiva localização no banco de dados. O exemplo anterior mostrou um
documento alovelace na coleção users. Para se referir a este local no seu
código, crie uma referência a ele.
SiteSwiftObjective-CJavaKotlinJavaPythonNode.jsGoPHPMais
let alovelaceDocumentRef = db.collection('users').doc('alovelace');

index.js
Uma referência é um objeto leve que aponta apenas para um local no banco de
dados. É possível criar uma referência independentemente da existência de
dados no banco de dados. A criação de uma referência não executa nenhuma
operação de rede.
É possível também criar referências a coleções:
let usersCollectionRef = db.collection('users');

index.js
Observação: referências de coleções e referências de documentos são dois tipos

diferentes de referências que permitem a execução de operações distintas. Por
exemplo, é possível usar uma referência de coleção para consultar os documentos na
coleção e utilizar uma de documento para ler ou gravar um documento individual.
Por conveniência, também é possível criar referências especificando o caminho

para um documento ou conjunto como uma string, com componentes de
caminho separados por uma barra (/). Por exemplo, para criar uma referência
ao documento alovelace:
let alovelaceDocumentRef = db.doc('users/alovelace');

index.js
Dados hierárquicos
Para entender como as estruturas hierárquicas de dados funcionam no Cloud

Firestore, pense em um exemplo de app de bate-papo com mensagens e salas
de bate-papo.
Crie um conjunto chamado rooms para armazenar salas de bate-papo

diferentes:
Agora que você tem salas de bate-papo, decida como armazenar suas
mensagens. Talvez você não queira armazená-las no documento da sala de
bate-papo. Os documentos no Cloud Firestore precisam ser leves, e uma sala
de bate-papo pode conter um grande número de mensagens. No entanto, é
possível criar coleções adicionais no documento da sala de bate-papo, como
subcoleções.
Subcoleções
A melhor maneira de armazenar mensagens neste cenário é usando
subcoleções. Uma subcoleção é uma coleção associada a um documento
específico.
Observação: é possível consultar as subcoleções com o mesmo ID de coleção, basta

usar Consultas de grupo de coleta.
É possível criar uma subcoleção chamada messages para cada documento da

sala em sua coleção rooms:
Neste exemplo, você criaria uma referência para uma mensagem na
subcoleção com o seguinte código:
let messageRef = db.collection('rooms').doc('roomA')

.collection('messages').doc('message1');
index.js
Observe o padrão alternado de coleções e documentos. É importante que suas

coleções e documentos sigam sempre esse padrão. Você não pode fazer
referência a uma coleção em uma coleção ou a um documento em um
documento.
As subcoleções permitem que você estruture os dados hierarquicamente,

facilitando o acesso a eles. Para receber todas as mensagens em roomA, é
possível criar uma referência de coleção para a subcoleção messages e
interagir com ela como faria com outra referência de coleção.
Documentos em subcoleções também podem conter subcoleções, permitindo

que os dados sejam mais aninhados. É possível aninhar dados em até 100
níveis.
Aviso: a exclusão de um subgrupo não exclui as subcoleções.
Quando você exclui um documento que tem subcoleções, essas subcoleções não são
excluídas. Por exemplo, pode haver um documento localizado
em coll/doc/subcoll/subdoc mesmo que o documento coll/doc não existe mais.
Remova manualmente os documentos nas subcoleções ao excluir um documento pai,
conforme explicado em Excluir coleções.
Adicionar dados
O Cloud Firestore armazena dados nos Documentos que são armazenados

nas Coleções. O Cloud Firestore cria coleções e documentos de modo implícito
na primeira vez que você adiciona dados ao documento. Não é necessário criar
coleções ou documentos explicitamente.
Crie uma nova coleção e um documento usando o código de exemplo a seguir.
let docRef = db.collection('users').doc('alovelace');
let setAda = docRef.set({

first: 'Ada',
last: 'Lovelace',
born: 1815
});
index.js
Agora, adicione outro documento à coleção users. Observe que esse

documento inclui um par de valores-chave (nome do meio) que não aparece no
primeiro documento. Os documentos em uma coleção podem conter diferentes
conjuntos de informações.
let aTuringRef = db.collection('users').doc('aturing');
let setAlan = aTuringRef.set({

'first': 'Alan',
'middle': 'Mathison',
'last': 'Turing',
'born': 1912
});
index.js
Ler dados
Para verificar rapidamente se você adicionou dados ao Cloud Firestore, use o

visualizador de dados no Console do Firebase.
É possível usar o método "get" para recuperar toda a coleção.
WebSwiftObjective-CJavaKotlinJavaPythonNode.jsGoPHPMais
db.collection('users').get()
.then((snapshot) => {
snapshot.forEach((doc) => {
console.log(doc.id, '=>', doc.data());
});
})
.catch((err) => {
console.log('Error getting documents', err);
});
index.js
Proteger seus dados
Se você estiver usando o SDK para Android, iOS ou Web, utilize o Firebase
Authentication e as Regras de segurança do Cloud Firestore para proteger
seus dados no Cloud Firestore.
Veja a seguir alguns conjuntos de regras básicas que é possível usar para dar
os primeiros passos. É possível modificar as regras de segurança na guia
Regras do console.
Autenticação obrigatóriaModo bloqueadoModo de teste
// Allow read/write access on all documents to any user signed in

to the application
service cloud.firestore {
match /databases/{database}/documents {
match /{document=**} {
allow read, write: if request.auth.uid != null;
}
}
}
Se você estiver usando um dos SDKs do servidor, utilize o Gerenciamento de

identidade e acesso (IAM, na sigla em inglês) para proteger seus dados no
Cloud Firestore.
14/07/2020 Receber dados com o Cloud Firestore | Firebase
Receber dados com o Cloud Firestore
How do queries work in Clo…

Clo…
Há duas maneiras de recuperar dados armazenados no Cloud Firestore. Qualquer um

desses métodos pode ser usado com documentos, coleções de documentos ou resultados
de consultas:
Chame um método para receber os dados.
De na um listener para receber eventos de mudança de dados.
Quando você con gura um listener, o Cloud Firestore envia para ele um snapshot inicial dos
dados e, em seguida, outro snapshot cada vez que o documento é alterado.
vação: as amostras de código abrangem várias linguagens, entretanto, no texto explicativo, são feitas
ncias aos nomes de métodos da Web.
Dados de exemplo
Para começar, escreva alguns dados sobre cidades para demonstrarmos diversas formas
de leitura:
Java Kotlin
Site (#site)Swi (#swift)Objective-C (#objective-c) Java (#java)Python
Android Android
( )( )
const citiesRef = db.collection('cities');
let setSf = citiesRef.doc('SF').set({

name: 'San Francisco', state: 'CA', country: 'USA',
capital: false, population: 860000
});
let setLa = citiesRef.doc('LA').set({
name: 'Los Angeles', state: 'CA', country: 'USA',
https://firebase.google.com/docs/firestore/query-data/get-data?authuser=0 1/6
capital: false, population: 3900000

});
let setDc = citiesRef.doc('DC').set({
name: 'Washington, D.C.', state: null, country: 'USA',
capital: true, population: 680000
});
let setTok = citiesRef.doc('TOK').set({
name: 'Tokyo', state: null, country: 'Japan',
});
let setBj = citiesRef.doc('BJ').set({
name: 'Beijing', state: null, country: 'China',
});
index.js (https://github.com/ rebase/snippets-node/blob/d769695bd1159103e7c877849ccaccab3db
Receber um documento
No exemplo a seguir, mostramos como recuperar o conteúdo de um único documento

usando get():
Java Kotlin
Android Android
( )( )
let cityRef = db.collection('cities').doc('SF');

let getDoc = cityRef.get()
.then(doc => {
if (!doc.exists) {
console.log('No such document!');
} else {
console.log('Document data:', doc.data());
}
})
.catch(err => {
console.log('Error getting document', err);
});
vação: se não houver um documento no local referenciado por docRef, o resultado document estará vazio
ada de exists retornará false.
Opções de origem
Para plataformas com suporte off-line, de na a opção source para controlar como uma
chamada get usa o cache off-line.
Por padrão, uma chamada get tentará buscar o snapshot do documento mais recente do
seu banco de dados. Nas plataformas com suporte off-line, a biblioteca de cliente usará o
cache off-line se a rede estiver indisponível ou se a solicitação expirar.
É possível especi car a opção source em uma chamada get() para alterar o
comportamento padrão. É possível buscar apenas no banco de dados e ignorar o cache
off-line ou buscar somente no cache off-line. Exemplo:
Java Kotlin
Android Android
( )( )
// Not supported in the Node.js SDK.
Objetos personalizados
No exemplo anterior, o conteúdo do documento foi recuperado como um mapa. No

entanto, muitas vezes é mais conveniente usar um tipo de objeto personalizado em
algumas linguagens. Em Adicionar dados
(https:// rebase.google.com/docs/ restore/manage-data/add-data?authuser=0), você de niu uma
classe City que usou para de nir cada cidade. É possível transformar seu documento em
um objeto City:
Java Kotlin
Web (#web)Swi (#swift)Objective-C (#objective-c) Java (#java)Pytho
Android Android
( )( )
// Node.js uses JavaScript objects
tante: cada classe personalizada precisa ter um construtor público sem argumentos. Além disso, a classe
a incluir um getter público para cada propriedade.
Obter vários documentos de uma coleção
Também é possível recuperar vários documentos com uma solicitação, basta consultar os
documentos em uma coleção. Por exemplo, use where() para consultar todos os
documentos que atendam a uma determinada condição, use get() para recuperar os
resultados:
Java Kotlin
Android Android
( )( )
let citiesRef = db.collection('cities');

let query = citiesRef.where('capital', '==', true).get()
.then(snapshot => {
if (snapshot.empty) {
console.log('No matching documents.');
return;
}
snapshot.forEach(doc => {
});
})
.catch(err => {
});
Por padrão, o Cloud Firestore recupera todos os documentos que atendem à consulta em
ordem crescente por ID. No entanto, é possível ordenar e limitar os dados retornados
(https:// rebase.google.com/docs/ restore/query-data/order-limit-data?authuser=0).
Recuperar todos os documentos em uma coleção
Além disso, é possível recuperar todos os documentos de uma coleção, basta omitir o ltro
where() completamente:
Java Kotlin
Android Android
( )( )

let allCities = citiesRef.get()
.then(snapshot => {
});
})
.catch(err => {
});
Reunir vários documentos de um grupo de coleções
Um grupo de coleções é composto de todos os conjuntos com o mesmo ID. Por exemplo,
se cada documento da coleção cities tiver uma subcoleção chamada landmarks, todas
as subcoleções de landmarks pertencerão ao mesmo grupo. Por padrão, por meio das
consultas são recuperados resultados de uma única coleção no seu banco de dados. Use
uma consulta de grupo de coleções para recuperar resultados de um grupo
(https:// rebase.google.com/docs/ restore/query-data/queries?authuser=0#collection-group-query),
em vez de uma única coleção.
Listar as subcoleções de um documento
O método getCollections() das bibliotecas de cliente do servidor do Cloud Firestore lista

todas as subcoleções de uma referência de documento.
Não é possível recuperar uma lista de coleções com as bibliotecas de cliente da Web/para
dispositivos móveis. Procure nomes de coleções somente como parte de tarefas
administrativas em ambientes de servidor con áveis. Se você julgar que precisa desse
recurso nas bibliotecas de clientes da Web/para dispositivos móveis, pense em
reestruturar seus dados para que os nomes de subcoleções sejam previsíveis.
Java Kotlin
Android Android
( )( )
let sfRef = db.collection('cities').doc('SF');

sfRef.getCollections().then(collections => {
collections.forEach(collection => {
console.log('Found subcollection with id:', collection.id);
});
});
Saiba mais sobre os diferentes tipos de consultas

(https:// rebase.google.com/docs/ restore/query-data/queries?authuser=0).
Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0
License (https://creativecommons.org/licenses/by/4.0/), and code samples are licensed under the Apache
2.0 License (https://www.apache.org/licenses/LICENSE-2.0). For details, see the Google Developers Site
Policies (https://developers.google.com/site-policies?authuser=0). Java is a registered trademark of Oracle
and/or its a liates.
Last updated 2019-12-03 UTC.
14/07/2020 Adicionar dados ao Cloud Firestore | Firebase
Adicionar dados ao Cloud Firestore

Há várias formas de gravar dados no Cloud Firestore:
De nir os dados de um documento em uma coleção especi cando explicitamente um

identi cador de documento.
Adicionar um novo documento a uma coleção. Neste caso, o Cloud Firestore gera
automaticamente o identi cador de documento.
Criar um documento vazio com um identi cador gerado automaticamente e atribuir

dados a ele posteriormente.
Neste guia, explicamos como usar as funções de nir, adicionar ou atualizar documentos
individuais no Cloud Firestore. Se você quiser gravar dados em massa, consulte
Transações e gravações em lote
(https:// rebase.google.com/docs/ restore/manage-data/transactions?authuser=0).
De nir um documento
Para criar ou substituir um único documento, use o método set():
Java Kotlin+KTX
Web (#web)Swi (#swift)Objective-C (#objective-c) Java (#java)P
Android Android
( )( )
const data = {
name: 'Los Angeles',
state: 'CA',
country: 'USA'
};
// Add a new document in collection "cities" with ID 'LA'

const res = await db.collection('cities').doc('LA').set(data);
index.js (https://github.com/ rebase/snippets-node/blob/26a796e67296ead6921f7c978cf731edaacb
https://firebase.google.com/docs/firestore/manage-data/add-data?authuser=0 1/8
Se o documento não existir, ele será criado. Se o documento existir, o conteúdo dele será
substituído pelos dados recém-fornecidos da seguinte forma, a menos que você
especi que que os dados devem ser incorporados ao documento existente:
Java Kotlin+KTX
Android Android
( )( )
const cityRef = db.collection('cities').doc('BJ');
const res = await cityRef.set({

capital: true
}, { merge: true });
Se você não tiver certeza de que o documento existe, ignore a opção de mesclar novos
dados com qualquer documento atual para evitar a substituição de documentos inteiros.
Tipos de dados
O Cloud Firestore permite gravar uma variedade de tipos de dados em um documento,

incluindo strings, booleanos, números, datas, nulos, além de matrizes e objetos aninhados.
O Cloud Firestore sempre armazena números como duplos, independentemente do tipo de
número que você usa no código.
Java Kotlin+KTX
Android Android
( )( )
const data = {
stringExample: 'Hello, World!',
booleanExample: true,
numberExample: 3.14159265,
dateExample: admin.firestore.Timestamp.fromDate(new Date('December 10, 1815
arrayExample: [5, true, 'hello'],
nullExample: null,
objectExample: {
a: 5,
b: true
}
};
const res = await db.collection('data').doc('one').set(data);

Objetos personalizados
Geralmente, usar os objetos Map ou Dictionary para representar seus documentos não é
muito conveniente. Por isso, o Cloud Firestore é compatível com a gravação de
documentos com classes personalizadas. O Cloud Firestore converte os objetos em tipos
de dados compatíveis.
Usando classes personalizadas, é possível reescrever o exemplo inicial da seguinte

maneira:
Java Kotlin+KTX
Android Android
( )( )
Java Kotlin+KTX
Android Android
( )( )
Adicionar um documento
Ao usar set() para criar um documento, você precisa especi car um ID para ele. Exemplo:
Java Kotlin+KTX
Android Android
( )( )
await db.collection('cities').doc('new-city-id').set(data);
No entanto, às vezes não há um ID signi cativo para o documento. É mais prático que o
Cloud Firestore gere um automaticamente para você. Para fazer isso, basta chamar add():
Java Kotlin+KTX
Android Android
W b( b)S i ( if )Obj i C( bj i ) J ( j )P
// Add a new document with a generated id.

const res = await db.collection('cities').add({
name: 'Tokyo',
country: 'Japan'
});
console.log('Added document with ID: ', res.id);

tante: ao contrário dos "IDs de push" do Firebase Realtime Database, os códigos IDs gerados automaticam
loud Firestore não têm ordenação automática. Para ordenar seus documentos por data de criação, você
a armazenar nos documentos um carimbo de data/hora como um campo.
Em alguns casos, pode ser útil criar uma referência de documento com um ID gerado
automaticamente, para usá-la mais tarde. Para este caso de uso, chame doc():
Java Kotlin+KTX
Android Android
( )( )
const newCityRef = db.collection('cities').doc();
// Later...
const res = await newCityRef.set({
// ...
});
Nos bastidores, .add(...) e .doc().set(...) são completamente equivalentes,

portanto, use o que for mais conveniente.
Atualizar um documento
Para atualizar alguns campos de um documento sem substituir o documento inteiro, use o
método update():
Java Kotlin+KTX
Web (#web)Swi (#swift)Objective-C (#objective-c) A d id A d id
Java (#java)P
const cityRef = db.collection('cities').doc('DC');
// Set the 'capital' field of the city

const res = await cityRef.update({capital: true});
Carimbo de data/hora do servidor
É possível con gurar um campo no seu documento como um carimbo de data/hora do

servidor que detecta quando o servidor recebe a atualização.
Java Kotlin+KTX
Android Android
( )( )
// Get the `FieldValue` object

const FieldValue = admin.firestore.FieldValue;
// Create a document reference

const docRef = db.collection('objects').doc('some-id');
// Update the timestamp field with the value from the server
const res = await docRef.update({
timestamp: FieldValue.serverTimestamp()
});
Atualizar campos em objetos aninhados
Se o documento contiver objetos aninhados, será possível usar "notação por pontos" para
se referir a campos aninhados no documento quando chamar update():
Java Kotlin+KTX
Android Android
( )( )
const initialData = {
name: 'Frank',
age: 12,
favorites: {
food: 'Pizza',
color: 'Blue',
subject: 'recess'
}
};
// ...
const res = await db.collection('users').doc('Frank').update({
age: 13,
'favorites.color': 'Red'
});
tante: ao tentar atualizar campos aninhados em um documento, é importante estar ciente de que existe u
nça semântica sutil entre as opções disponíveis.
A notação por pontos permite que você atualize um único campo aninhado sem substituir
outro campo aninhado. Se você atualizar um campo aninhado sem a notação por pontos,
todo o campo mapa será substituído, por exemplo:
Web
( )
// Create our initial doc

db.collection("users").doc("frank").set({
name: "Frank",
favorites: {
food: "Pizza",
color: "Blue",
subject: "Recess"
},
age: 12
}).then(function() {
console.log("Frank created");
});
// Update the doc without using dot notation.

// Notice the map value for favorites.
db.collection("users").doc("frank").update({
favorites: {
food: "Ice Cream"
}
}).then(function() {
console.log("Frank food updated");
});
/*
Ending State, favorite.color and favorite.subject are no longer present:
/users
/frank
{
name: "Frank",
favorites: {
food: "Ice Cream",
},
age: 12
}
*/
Atualizar elementos em uma matriz
Se o documento contiver um campo de matriz, use arrayUnion() e arrayRemove() para

adicionar e remover elementos. arrayUnion() adiciona elementos a uma matriz, mas
apenas elementos que ainda não estejam presentes. arrayRemove() remove todas as
instâncias de cada elemento especi cado.
Java Kotlin+KTX
Android Android
( )( )

// ...
const washingtonRef = db.collection('cities').doc('DC');
// Atomically add a new region to the "regions" array field.

const unionRes = await washingtonRef.update({
regions: admin.firestore.FieldValue.arrayUnion('greater_virginia')
});
// Atomically remove a region from the "regions" array field.
const removeRes = await washingtonRef.update({
regions: admin.firestore.FieldValue.arrayRemove('east_coast')
});
Aumentar um valor numérico
É possível aumentar ou diminuir um valor de campo numérico conforme mostrado no

exemplo a seguir. Uma operação de incremento aumenta ou diminui o valor atual de um
campo de acordo com o valor especi cado. Se o campo não existir, ou se o valor do campo
atual não for numérico, a operação de nirá o campo como o valor determinado.
Java Kotlin+KTX
Android Android
( )( )

// ...
const washingtonRef = db.collection('cities').doc('DC');
// Atomically increment the population of the city by 50.

const res = await washingtonRef.update({
population: admin.firestore.FieldValue.increment(50)
});
As operações de incremento são úteis para implementar contadores. No entanto, lembre-

se de que só é possível atualizar um único documento apenas uma vez por segundo. Se for
necessário atualizar o contador acima dessa taxa, consulte a página Contadores
distribuídos (https:// rebase.google.com/docs/ restore/solutions/counters?authuser=0).
14/07/2020 Transações e gravações em lote | Firebase
Transações e gravações em lote
How do Transactions Work…

Work…
O Cloud Firestore é compatível com operações atômicas para leitura e gravação de dados.
Em um conjunto de operações atômicas, todas as operações são bem-sucedidas ou
nenhuma delas é aplicada. Há dois tipos de operações atômicas no Cloud Firestore:
Transações: uma transação (#transactions) é um conjunto de operações de leitura e

gravação em um ou mais documentos.
Gravações em lote: uma gravação em lote (#batched-writes) é um conjunto de

operações de gravação em um ou mais documentos.
Em cada transação ou lote de gravações, é possível realizar gravações em no máximo 500

documentos. Para saber mais sobre limites adicionais de gravação, consulte Cotas e
limites (https:// rebase.google.com/docs/ restore/quotas?authuser=0#writes_and_transactions).
Como atualizar dados com transações
É possível agrupar várias operações em uma única transação, basta usar as bibliotecas de
cliente do Cloud Firestore. As transações são úteis quando você quer atualizar o valor de
um campo com base no valor atual dele ou de algum outro.
Uma transação consiste em qualquer número de operações get() seguidas por qualquer
número de operações de gravação, como set(), update() ou delete(). No caso de uma
edição simultânea, o Cloud Firestore executa a transação inteira novamente. Por exemplo,
se uma transação lê documentos e outro cliente modi ca qualquer um desses
documentos, o Cloud Firestore tentará a transação novamente. Esse recurso garante que a
transação funcione com dados atualizados e consistentes.
As gravações nunca são aplicadas parcialmente pelas transações. Todas as gravações são
executadas no nal de uma transação bem-sucedida.
Ao usar transações, observe que:
https://firebase.google.com/docs/firestore/manage-data/transactions?authuser=0 1/7
as operações de leitura precisam vir antes das operações de gravação;
uma função que chama uma transação (função de transação) pode ser executada
mais de uma vez se uma edição simultânea afetar um documento lido pela
transação;
as funções de transação não devem modi car diretamente o estado do aplicativo;
as transações apresentarão falha quando o cliente estiver desconectado.
O exemplo a seguir mostra como criar e executar uma transação:
Java Kotlin
Android Android
( )( )
// Initialize document
let setCity = cityRef.set({
name: 'San Francisco',
state: 'CA',
country: 'USA',
capital: false,
population: 860000
});
let transaction = db.runTransaction(t => {

return t.get(cityRef)
.then(doc => {
// Add one person to the city population.
// Note: this could be done without a transaction
// by updating the population using FieldValue.increment()
let newPopulation = doc.data().population + 1;
t.update(cityRef, {population: newPopulation});
});
}).then(result => {
console.log('Transaction success!');
}).catch(err => {
console.log('Transaction failure:', err);
});
Como transmitir informações para fora das transações
Não modi que o estado do aplicativo dentro de suas funções de transação. Isso resultará
em problemas de simultaneidade, porque as funções de transação podem ser executadas
várias vezes e não têm garantia de execução na thread de IU. Em vez disso, transmita as
informações que você precisa para fora de suas funções de transação. O exemplo a seguir
baseia-se no exemplo anterior para mostrar como transmitir informações de uma
transação:
Java Kotlin
Android Android
( )( )

let transaction = db.runTransaction(t => {
return t.get(cityRef)
.then(doc => {
let newPopulation = doc.data().population + 1;
if (newPopulation <= 1000000) {
t.update(cityRef, {population: newPopulation});
return Promise.resolve('Population increased to ' + newPopulation);
} else {
return Promise.reject('Sorry! Population is too big.');
}
});
}).then(result => {
console.log('Transaction success', result);
}).catch(err => {
console.log('Transaction failure:', err);
});
Falha na transação
Uma transação pode apresentar falha pelos seguintes motivos:
A transação contém operações de leitura, após operações de gravação. As operações

de leitura sempre têm que vir antes de qualquer operação de gravação.
A transação leu um documento que foi modi cado fora da transação. Nesse caso, a
transação é executada novamente de maneira automática. As novas tentativas da
transação ocorrem em um número nito de vezes.
A transação excedeu o tamanho máximo da solicitação de 10 MiB.
O tamanho da transação depende dos tamanhos de documentos e entradas de índice

que ela modi ca. Em uma operação de exclusão, isso inclui os tamanhos do
documento de destino e das entradas de índice excluídas em resposta à operação.
Em uma transação com falha, um erro é retornado e nada é gravado no banco de dados.
Você não precisa reverter a transação, isso é feito automaticamente pelo Cloud Firestore.
Gravações em lote
Se você não precisar ler documentos no conjunto de operações, poderá executar várias
operações de gravação como um único lote contendo qualquer combinação de operações
set(), update() ou delete(). Um lote de gravações é concluído atomicamente e pode
gravar em vários documentos. No exemplo a seguir, você descobre como criar e con rmar
um lote de gravação:
Java Kotlin
Android Android
( )( )
// Get a new write batch

let batch = db.batch();
// Set the value of 'NYC'

let nycRef = db.collection('cities').doc('NYC');
batch.set(nycRef, {name: 'New York City'});
// Update the population of 'SF'

let sfRef = db.collection('cities').doc('SF');
batch.update(sfRef, {population: 1000000});
// Delete the city 'LA'

let laRef = db.collection('cities').doc('LA');
batch.delete(laRef);
// Commit the batch

return batch.commit().then(function () {
// ...
});
Uma gravação em lote pode conter até 500 operações. Cada uma dessas operações é
contabilizada separadamente no uso do Cloud Firestore. Em uma operação de gravação,
transformações de campo como serverTimestamp, arrayUnion e increment contam,

cada uma, como uma operação extra.
Assim como as transações, as gravações em lote são atômicas. Ao contrário das

transações, as gravações em lote não precisam garantir que os documentos gravados
permaneçam sem modi cações, o que gera menos casos de falha. Elas não estão sujeitas
a novas tentativas ou falhas por conta do excesso de tentativas. As gravações em lotes
são executadas mesmo quando o dispositivo do usuário está off-line.
vação: para entrada de dados em massa, use uma biblioteca cliente do servidor
:// rebase.google.com/docs/ restore/client/libraries?authuser=0#server_client_libraries) com gravações
uais em paralelo. As gravações em lote apresentam melhor desempenho do que aquelas em série, mas n
r do que as executadas em paralelo. Use uma biblioteca de cliente do servidor para operações de dados e
a e não um SDK da Web/para dispositivos móveis.
Validação de dados em operações atômicas
Para bibliotecas de cliente da Web/dispositivos móveis, é possível validar dados usando as

regras de segurança do Cloud Firestore
(https:// rebase.google.com/docs/ restore/security/get-started?authuser=0). Garanta que os
documentos relacionados sejam sempre atualizados atomicamente e sempre como parte
de uma transação ou gravação em lote. Use a função da regra de segurança getAfter()
(https:// rebase.google.com/docs/reference/rules/rules. restore?authuser=0#.getAfter) para
acessar e validar o estado de um documento após a conclusão de um conjunto de
operações, mas antes que o Cloud Firestore con rme as operações.
Por exemplo, imagine que o banco de dados do exemplo cities também contenha uma
coleção countries. Cada documento country usa um campo last_updated para
acompanhar a última vez em houve atualização de qualquer cidade relacionada a esse
país. As seguintes regras de segurança a seguir exigem que uma atualização de um
documento city também atualize atomicamente o campo last_updated do país
relacionado:
ice cloud.firestore {
tch /databases/{database}/documents {
// If you update a city doc, you must also
// update the related country's last_updated field.
match /cities/{city} {
allow write: if request.auth.uid != null &&
getAfter(
/databases/$(database)/documents/countries/$(request.resource.data.count
).data.last_updated == request.time;
}
match /countries/{country} {
allow write: if request.auth.uid != null;
}
Limites de regras de segurança
Nas regras de segurança de transações ou gravações em lote, há um limite

(https:// rebase.google.com/docs/ restore/quotas?authuser=0#security_rules) de 20 chamadas de
acesso a documentos em toda a operação atômica. Ele é somado ao limite normal de 10
chamadas para cada operação de documento no lote.
Por exemplo, pense nas regras a seguir de um aplicativo de bate-papo:
ice cloud.firestore {
tch /databases/{db}/documents {
function prefix() {
return /databases/{db}/documents;
}
match /chatroom/{roomId} {
allow read, write: if roomId in get(/$(prefix())/users/$(request.auth.uid)).
|| exists(/$(prefix())/admins/$(request.auth.uid));
}
match /users/{userId} {
allow read, write: if userId == request.auth.uid
|| exists(/$(prefix())/admins/$(request.auth.uid));
}
match /admins/{userId} {
allow read, write: if exists(/$(prefix())/admins/$(request.auth.uid));
}
Nos snippets abaixo, é exibido o número de chamadas de acesso a documentos usadas

em alguns padrões de acesso a dados:
document access calls used, because the rules evaluation short-circuits

efore the exists() call is invoked.
ollection('user').doc('myuid').get(...);
document access call used. The maximum total allowed for this call
s 10, because it is a single document request.
ollection('chatroom').doc('mygroup').get(...);
nitializing a write batch...

batch = db.batch();
document access calls used, 10 allowed.

group1Ref = db.collection("chatroom").doc("group1");
h.set(group1Ref, {msg: "Hello, from Admin!"});
document access call used, 10 allowed.

newUserRef = db.collection("users").doc("newuser");
h.update(newUserRef, {"lastSignedIn": new Date()});
document access call used, 10 allowed.

removedAdminRef = db.collection("admin").doc("otheruser");
h.delete(removedAdminRef);
he batch used a total of 2 + 1 + 1 = 4 document access calls, out of a total

0 allowed.
h.commit();
14/07/2020 Excluir dados do Cloud Firestore | Firebase
Excluir dados do Cloud Firestore

Nos exemplos a seguir, mostramos como excluir documentos, campos e coleções.
Excluir documentos
Para excluir um documento, use o método delete():
Java Kotlin
Android Android
( )( )
let deleteDoc = db.collection('cities').doc('DC').delete();

a exclusão de um documento não remove as subcoleções dele.
Quando você exclui um documento, o Cloud Firestore não remove automaticamente os

documentos nas subcoleções dele. Ainda é possível acessar os documentos da
subcoleção para ns de consulta. Por exemplo, é possível acessar o documento no
caminho /mycoll/mydoc/mysubcoll/mysubdoc, mesmo se você excluir o documento
ancestral em /mycoll/mydoc.
Os documentos ancestrais inexistentes são exibidos no console

(https:// rebase.google.com/docs/ restore/using-console?authuser=0#non-
existent_ancestor_documents)
, mas não aparecem nos resultados de consulta e snapshots.
Se quiser excluir um documento e todos os que estão contidos nas subcoleções dele, você
precisará fazer isso manualmente. Para mais informações, consulte Excluir coleções
(#collections).
Excluir campos
Para excluir campos especí cos de um documento, use o método FieldValue.delete()

ao atualizá-lo:
https://firebase.google.com/docs/firestore/manage-data/delete-data?authuser=0 1/4
Java Kotlin
Site (#site)Swi (#swift)Objective-C (#objective-c) Android Android
Java (#java)Python
// Get the `FieldValue` object

let FieldValue = require('firebase-admin').firestore.FieldValue;
// Create a document reference

let cityRef = db.collection('cities').doc('BJ');
// Remove the 'capital' field from the document

let removeCapital = cityRef.update({
capital: FieldValue.delete()
});
Excluir coleções
Para excluir uma coleção ou subcoleção completa no Cloud Firestore, recupere todos os
documentos dentro da coleção ou subcoleção e os exclua. Se você tem coleções maiores,
exclua os documentos em lotes menores para evitar erros de falta de memória. Repita o
processo até excluir toda a coleção ou subcoleção.
A exclusão de uma coleção exige a coordenação de um número ilimitado de solicitações

de exclusão individuais. Se você precisar excluir coleções inteiras, faça isso somente a
partir de um ambiente de servidor con ável. É possível excluir uma coleção de um cliente
da Web /dispositivos móveis, mas isso tem implicações negativas para a segurança e o
desempenho.
Os snippets abaixo estão simpli cados e não incluem processamento de erros, segurança,
exclusão de subcoleções ou aumento de desempenho. Para saber mais sobre uma
abordagem recomendada para excluir coleções em produção, consulte Como excluir
coleções e subcoleções
(https:// rebase.google.com/docs/ restore/solutions/delete-collections?authuser=0).
Java Kotlin
Android Android
( )( )
function deleteCollection(db, collectionPath, batchSize) {

let collectionRef = db.collection(collectionPath);
let query = collectionRef.orderBy('__name__').limit(batchSize);
return new Promise((resolve, reject) => {

deleteQueryBatch(db, query, batchSize, resolve, reject);
});
}
function deleteQueryBatch(db, query, batchSize, resolve, reject) {

query.get()
.then((snapshot) => {
// When there are no documents left, we are done
if (snapshot.size == 0) {
return 0;
}
// Delete documents in a batch

let batch = db.batch();
snapshot.docs.forEach((doc) => {
batch.delete(doc.ref);
});
return batch.commit().then(() => {

return snapshot.size;
});
}).then((numDeleted) => {
if (numDeleted === 0) {
resolve();
return;
}
// Recurse on the next process tick, to avoid

// exploding the stack.
process.nextTick(() => {
deleteQueryBatch(db, query, batchSize, resolve, reject);
});
})
.catch(reject);
}
Excluir dados com a Firebase CLI
Também é possível usar a Firebase CLI (// rebase.google.com/docs/cli?authuser=0) para excluir

documentos e coleções. Use o comando a seguir para excluir dados:
base firestore:delete [options] <<path>>
14/07/2020 Tipos de índices no Cloud Firestore | Firebase
Tipos de índices no Cloud Firestore

Os índices são um fator importante no desempenho de um banco de dados. Semelhantes
aos índices de livros que correlacionam os tópicos às páginas, os índices de bancos de
dados referenciam os itens aos locais deles no banco de dados. Quando você faz uma
consulta em um banco de dados, ele pode usar um índice para procurar rapidamente os
locais dos itens solicitados.
Veja nesta página os dois tipos de índice usados pelo Cloud Firestore: índices de campo
único (#single- eld_indexes) e compostos (#composite_indexes).
Um índice para cada consulta
Caso não haja um índice em uma consulta, a maioria dos bancos de dados rastreará o
conteúdo item por item, um processo demorado que ca ainda mais lento à medida que o
banco de dados cresce. O Cloud Firestore garante alto desempenho de consulta usando
índices em todas as consultas. Como resultado, o desempenho da consulta depende do
tamanho do conjunto de resultados e não do número de itens inclusos no banco de dados.
Menos gerenciamento de índices, mais desenvolvimento de apps
O Cloud Firestore inclui recursos que reduzem o tempo necessário para gerenciar os
índices. Os índices necessários para as consultas mais básicas são criados
automaticamente. À medida que você usa e testa seu app, o Cloud Firestore ajuda a
identi car e criar outros índices
(https:// rebase.google.com/docs/ restore/query-data/indexing?authuser=0) que sejam
necessários para ele.
Tipos de índice
O Cloud Firestore usa dois tipos de índices, de campo único e compostos. O número de
campos indexados não é a única diferença entre esses índices, o gerenciamento deles
também é diferente.
Índices de campo único
Um índice de campo único armazena um mapeamento ordenado de todos os documentos

em um conjunto com um campo especí co. Cada entrada em um índice de campo único
https://firebase.google.com/docs/firestore/query-data/index-overview?authuser=0 1/14
registra o valor de um documento para um campo especí co e o local do documento no

banco de dados. O Cloud Firestore usa esses índices para realizar muitas consultas
básicas. É preciso de nir as con gurações de indexação automática e a isenção de índice
para gerenciar índices de campo único.
Indexação automática
Por padrão, o Cloud Firestore mantém automaticamente os índices de campo único para
cada campo em um documento e cada subcampo em um mapa. O Cloud Firestore usa as
seguintes con gurações padrão para índices de campo único:
Para cada campo que não seja de matriz ou de mapa, o Cloud Firestore de ne dois
índices de campo único do escopo da coleção, um em modo crescente e o outro em
modo decrescente.
Para cada campo de mapa, o Cloud Firestore cria um índice crescente do escopo da
coleção e um índice decrescente para cada subcampo no mapa que não seja de
matriz ou de mapa.
Para cada campo de matriz em um documento, o Cloud Firestore cria e mantém um

índice "array-contains" do escopo da coleção.
Índices de campo único com escopo de grupo de coleções não são mantidos por
padrão.
Isenções de índice de campo único
É possível isentar um campo usando as con gurações de indexação automática

(#automatic_indexing), basta criar uma isenção de índice de campo único. Uma isenção de
indexação substitui as con gurações de índice automático em todo o banco de dados.
Uma isenção pode ativar um índice de campo único que suas con gurações de indexação
automática geralmente desativariam, ou desativar um índice de campo único que a
indexação automática geralmente ativaria. Para ver casos em que as isenções podem ser
úteis, consulte as práticas recomendadas de indexação (#indexing_best_practices).
Se você criar uma isenção para um índice de campo único no campo do mapa, os
subcampos do mapa herdarão essas con gurações. No entanto, é possível de nir as
isenções para um índice de campo único em subcampos especí cos. Se você excluir a
isenção de um subcampo, ele herdará as con gurações de isenção do campo pai. Se essas
con gurações não existirem, ele herdará as con gurações gerais do banco de dados.
vação: uma isenção se aplica somente às con gurações de índice automático. Um campo isento da index
mpo único ainda pode ser indexado como parte de um índice composto.
Para criar e gerenciar isenções de índice de campo único, consulte Como gerenciar índices
no Cloud Firestore
(https:// rebase.google.com/docs/ restore/query-data/indexing?authuser=0#exemptions).
Índices compostos
Um índice composto armazena um mapeamento classi cado de todos os documentos em

uma coleção que contém vários campos especí cos, em vez de apenas um.
vação: é possível ter no máximo um campo de matriz por índice composto.
O Cloud Firestore usa índices compostos para oferecer suporte às consultas que ainda não
aceitam índices de campo único.
O Cloud Firestore não cria índices compostos automaticamente, como faria para os índices
de campo único, devido ao grande número de combinações de campos possíveis. Em vez
disso, ele ajuda a identi car e criar os índices compostos necessários
(https:// rebase.google.com/docs/ restore/query-data/indexing?authuser=0) à medida que você
cria seu app.
Se você zer a consulta acima sem antes criar o índice necessário, o Cloud Firestore
retornará uma mensagem de erro com um link que pode ser acessado para criar o índice
ausente. Isso acontecerá sempre que você zer uma consulta que não for compatível com
um índice. Também é possível criar e gerenciar índices compostos manualmente usando o
console ou a Firebase CLI (// rebase.google.com/docs/cli?authuser=0). Para mais informações
sobre esses processos, consulte Como gerenciar índices
(https:// rebase.google.com/docs/ restore/query-data/indexing?authuser=0).
Modos de índice e escopos de consulta
A con guração de índices compostos e de campo único é feita de maneira diferente, mas
ambos exigem que você con gure modos de índice e escopos de consulta para seus
índices.
Modos de índice
Ao de nir um índice, você seleciona um modo de índice para cada campo indexado. O
modo de índice de cada campo é compatível com cláusulas de consulta especí cas nesse
campo. É possível selecionar os seguintes modos de índice:
Modo de
Descrição
índice
Crescente Compatível com cláusulas de consulta <, <=, ==, >= e > no campo e com a classi cação
 dos resultados em ordem crescente com base no valor desse campo.
Decrescente Compatível com cláusulas de consulta <, <=, ==, >= e > no campo e com a classi cação
 dos resultados em ordem decrescente com base no valor desse campo.
Matriz Compatível com cláusulas de consulta array_contains

contém (https:// rebase.google.com/docs/ restore/query-data/queries?
authuser=0#array_contains)
no campo.
Escopos da consulta
Cada índice tem um escopo delimitado a uma coleção ou a um grupo de coleções. Isso é
conhecido como o escopo da consulta do índice:
Escopo da coleção
O Cloud Firestore cria índices com um escopo de coleção por padrão. Esses índices
são compatíveis com consultas que retornam resultados de uma única coleção.
Escopo do grupo de coleções
Um grupo de coleções inclui todas as coleções com o mesmo código. Para executar
uma consulta do grupo de coleções
(https:// rebase.google.com/docs/ restore/query-data/queries?authuser=0#collection-group-
query)
que retorne resultados ltrados ou ordenados a partir de um grupo, você precisa criar
um índice correspondente com o escopo do grupo de coleções.
Exemplo de indexação
Ao criar índices de campo único automaticamente para você, o Cloud Firestore permite que
seu aplicativo dê suporte rapidamente às consultas mais básicas no banco de dados. Com
os índices de campo único, é possível realizar consultas simples com base nos valores de
campo e nos comparadores <, <=, ==, >= e >. Para campos de matriz, eles permitem que
você execute consultas array_contains.
Para entender melhor, examine os exemplos a seguir do ponto de vista da criação do

índice. O snippet a seguir cria alguns documentoscity em uma coleção cities e de ne
name, state, country, capital, population e tags campos para cada documento:
Site
( )
var citiesRef = db.collection("cities");
citiesRef.doc("SF").set({
name: "San Francisco", state: "CA", country: "USA",
capital: false, population: 860000,
regions: ["west_coast", "norcal"] });
citiesRef.doc("LA").set({
name: "Los Angeles", state: "CA", country: "USA",
regions: ["west_coast", "socal"] });
citiesRef.doc("DC").set({
name: "Washington, D.C.", state: null, country: "USA",
capital: true, population: 680000,
regions: ["east_coast"] });
citiesRef.doc("TOK").set({
name: "Tokyo", state: null, country: "Japan",
regions: ["kanto", "honshu"] });
citiesRef.doc("BJ").set({
name: "Beijing", state: null, country: "China",
regions: ["jingjinji", "hebei"] });
test.firestore.js (https://github.com/ rebase/snippets-web/blob/690e78f3464926289034441e24
Considerando as con gurações de indexação automática padrão, o Cloud Firestore

atualiza um índice de campo único crescente por campo que não seja de matriz, um índice
de campo único decrescente por campo que não seja de matriz e um índice de campo
único "array-contains" para o campo de matriz. Cada linha na tabela a seguir representa
uma entrada em um índice de campo único:
Coleção Campo indexado Escopo da consulta
Coleção Campo indexado Escopo da consulta
cidades Nome de  Coleção
cidades
 estado Coleção
cidades
país Coleção
cidades
 capital Coleção
cidades
 população Coleção
cidades Nome de  Coleção
cidades
 estado Coleção
cidades
 país Coleção
cidades
 capital Coleção
cidades
 população Coleção
cidades array-contains regiões Coleção
Consultas compatíveis com índices de campo único
Ao usar esses índices de campo único criados automaticamente, é possível executar

consultas simples como as seguintes:
Site
( )
citiesRef.where("state", "==", "CA")

citiesRef.where("population", "<", 100000)
citiesRef.where("name", ">=", "San Francisco")
O índice array_contains permite consultar o campo de matriz regions:
Site
( )
citiesRef.where("regions", "array-contains", "west_coast")

Você também pode criar consultas compostas com base em igualdades (==):
Site
( )
citiesRef.where("state", "==", "CO").where("name", "==", "Denver")

citiesRef.where("country", "==", "USA").where("capital", "==", false).where("
Se você precisar executar uma consulta composta que usa uma comparação de intervalo
(<, <=, > ou >=) ou classi car por um campo diferente, crie um índice composto
(#composite_indexes) para essa consulta.
Consultas compatíveis com índices compostos
O Cloud Firestore usa índices compostos para oferecer suporte a consultas compostas
que ainda não aceitam índices de campo único. Por exemplo, você precisaria de um índice
composto para as seguintes consultas:
Site
( )
citiesRef.where("country", "==", "USA").orderBy("population", "asc")

citiesRef.where("country", "==", "USA").where("population", "<", 3800000)
citiesRef.where("country", "==", "USA").where("population", ">", 690000)
Essas consultas exigem o índice composto abaixo. Como a consulta usa uma igualdade
para o campo country, o modo de índice dele pode ser decrescente ou crescente. Por
padrão, as consultas de desigualdade aplicarão uma ordem de classi cação crescente
com base no campo da cláusula de desigualdade.
Coleção Campos indexados Escopo da consulta
cidades
 (ou ) país, população Coleção
Se você quiser executar as mesmas consultas, mas com uma ordem de classi cação
decrescente, será necessário um índice composto na direção decrescente para
population:
Site
( )
citiesRef.where("country", "==", "USA").orderBy("population", "desc")
citiesRef.where("country", "==", "USA")

.where("population", "<", 3800000)
.orderBy("population", "desc")
citiesRef.where("country", "==", "USA")

.where("population", ">", 690000)
.orderBy("population", "desc")
cidades
 país, população Coleção
cidades
 país,  população Coleção
Também será necessário criar um índice composto se você quiser combinar uma consulta
array_contains com cláusulas adicionais.
Site
( )
citiesRef.where("regions", "array_contains", "east_coast")

.where("capital", "==", true)
cidades A matriz contém tags,  (ou ) capital Coleção
Consultas compatíveis com índices de grupo de coleções
Para demonstrar um índice com escopo de grupo de coleções, adicione uma subcoleção
landmarks a alguns dos documentos city:
Site
( )
var citiesRef = db.collection("cities");
citiesRef.doc("SF").collection("landmarks").doc().set({
name: "Golden Gate Bridge",
category : "bridge" });
citiesRef.doc("SF").collection("landmarks").doc().set({
name: "Golden Gate Park",
category : "park" });
citiesRef.doc("DC").collection("landmarks").doc().set({
name: "National Gallery of Art",
category : "museum" });
citiesRef.doc("DC").collection("landmarks").doc().set({
name: "National Mall",
category : "park" });
Ao usar o seguinte índice de campo único com escopo do conjunto, é possível consultar
pontos de referência park em uma única cidade:
pontos de referência
 (ou ) categoria Coleção
Site
( )
citiesRef.doc("SF").collection("landmarks").where("category", "==", "park")
Agora, imagine que você tem interesse em pontos de referência park em todas as cidades.
Para executar essa consulta no grupo que consiste em todos os conjuntos landmarks,
você precisa ativar um índice de campo único landmarks com escopo do grupo de
conjuntos:
pontos de referência
 (ou ) categoria Grupo de coleção
Com esse índice ativado, é possível consultar o grupo de conjuntoslandmarks:
Site
( )
var landmarksGroupRef = db.collectionGroup("landmarks");
landmarksGroupRef.where("category", "==", "park")
Para executar uma consulta de grupo de coleções que retorne resultados ltrados ou
ordenados, é necessário ativar um índice correspondente composto ou de campo único
com o escopo do grupo de coleções. No entanto, as consultas de grupo de coleções que
não ltram ou ordenam os resultados não exigem de nições de índice adicionais.
Por exemplo, é possível executar a seguinte consulta de grupo de coleções sem ativar um
índice adicional:
Site
( )
db.collectionGroup("landmarks").get()
Índices e preços
Os índices são contabilizados nos custos de armazenamento

(https:// rebase.google.com/docs/ restore/pricing?authuser=0#storage-size) do seu aplicativo.
Para saber mais sobre como é calculado o tamanho do armazenamento para índices,
consulte o tamanho da entrada de índices
(https:// rebase.google.com/docs/ restore/storage-size?authuser=0#index-entry-size).
Como usar a mesclagem de índices
Embora o Cloud Firestore use um índice para cada consulta, ele não exige necessariamente
um índice por consulta. Para consultas com múltiplas cláusulas de igualdade (==) e,
opcionalmente, uma cláusula orderBy, o Cloud Firestore pode reutilizar índices existentes.
O Cloud Firestore pode mesclar os índices de ltros de igualdade simples para criar os
índices compostos necessários a consultas de igualdade maiores.
É possível reduzir os custos de indexação ao identi car situações em que é possível

aproveitar a mesclagem de índices. Por exemplo, imagine um conjunto restaurants para
um app de classi cação de restaurantes:
 restaurants
 burgerthyme
name : "Burger Thyme"
category : "burgers"
city : "San Francisco"
editors_pick : true
star_rating : 4
Agora imagine que esse app use consultas como as mostradas abaixo. Observe que ele
usa combinações de cláusulas de igualdade para category, city e editors_pick
enquanto sempre classi ca por crescente star_rating:
Site
( )
db.collection("restaurants").where("category", "==", "burgers")

.orderBy("star_rating")
db.collection("restaurants").where("city", "==", "San Francisco")


.where("city", "==", "San Francisco")

.where("city", "==" "San Francisco")
.where("editors_pick", "==", true )
Você poderia criar um índice para cada consulta:
restaurants
 categoria, avaliação com estrelas Coleção
restaurants
 cidade, avaliação com estrelas Coleção
restaurants
 categoria, cidade, avaliação com estrelas Coleção
restaurants
 categoria, cidade, sugestões dos editores, avaliação com estrelas Coleção
Uma solução melhor seria reduzir o número de índices aproveitando o recurso de

mesclagem de cláusulas de igualdade do Cloud Firestore:
restaurants
 categoria, avaliação com estrelas Coleção
restaurants
 cidade, avaliação com estrelas Coleção
restaurants
 sugestões dos editores, avaliação com estrelas Coleção
Esse conjunto de índices é menor e também aceita uma consulta adicional:
Site
( )
db.collection("restaurants").where("editors_pick", "==", true)

Limites de indexação
Os limites a seguir são aplicáveis aos índices. Para mais informações sobre cotas e limites,
consulte Cotas e limites (https:// rebase.google.com/docs/ restore/quotas?authuser=0).
Limite Detalhes
Número máximo de índices compostos 200

de um projeto
Número máximo de isenções de índice 200

de campo único para um banco de dados
Número máximo de entradas de índice 40.000

para cada documento
O número de entradas de índice é a soma do valor a seguir
para um documento:
número de entradas de índice de campo único
número de entradas de índice composto
Limite Detalhes
Tamanho máximo de uma entrada de 7,5 KiB

índice
Para ver como o Cloud Firestore calcula o tamanho da entrada
do índice, consulte o tamanho da entrada do índice
(https:// rebase.google.com/docs/ restore/storage-size?
authuser=0#index-entry-size)
.
Soma máxima dos tamanhos das 8 MiB

entradas de índice de um documento
O tamanho total é a soma dos seguintes itens para um
documento:
A soma do tamanho das entradas de índice de campo

único de um documento
A soma do tamanho das entradas de índice composto de

um documento
Tamanho máximo de um valor de campo 1.500 bytes

indexado
Valores de campo acima de 1500 bytes são truncados.
Consultas que envolvem valores de índice truncados podem
retornar resultados inconsistentes.
Práticas recomendadas de indexação
Para a maioria dos aplicativos, você pode con ar na indexação automática e nos links de
mensagens de erro para gerenciar seus índices. No entanto, você pode querer adicionar
isenções de campo único nos seguintes casos:
Caso Descrição
Campos de string Se você tiver um campo de string que geralmente armazena valores de string
grandes longos que você não usa para consulta, é possível reduzir os custos de
armazenamento com a isenção da indexação no campo.
Caso Descrição
Taxas de gravação Se você indexar um campo que aumenta ou diminui sequencialmente entre
altas em uma documentos em uma coleção, como um carimbo de data/hora, a taxa máxima de
coleção que contém gravação para a coleção será de 500 gravações por segundo. Se você não zer
documentos com consultas com base no campo com valores sequenciais, poderá isentar o campo
valores sequenciais da indexação para ignorar esse limite.
Em um caso de uso de Internet das Coisas (IoT, na sigla em inglês) com uma alta
taxa de gravação, por exemplo, uma coleção que contém documentos com um
campo de carimbo de data/hora pode se aproximar do limite de 500 gravações por
segundo.
Campos grandes de Campos grandes de matriz ou de mapa podem se aproximar do limite de 20.000
matriz ou de mapa entradas de índice por documento. Se você não estiver fazendo consultas com
base em um campo grande de matriz ou de mapa, recomendamos isentá-lo da
indexação.
14/07/2020 Ordenar e limitar dados com o Cloud Firestore | Firebase
Ordenar e limitar dados com o Cloud

Firestore
O Cloud Firestore oferece uma poderosa funcionalidade de consulta para especi car quais
documentos você quer recuperar em uma coleção. Essas consultas também podem ser
usadas com get() ou addSnapshotListener(), conforme descrito em Receber dados
(https:// rebase.google.com/docs/ restore/query-data/get-data?authuser=0).
Ordenar e limitar dados
Por padrão, uma consulta recupera todos os documentos que atendem a ela em ordem
crescente por ID. Use orderBy() para especi car a ordem de classi cação dos dados e
limit()para limitar o número de documentos recuperados.
vação: uma cláusula orderBy() também ltra a existência do campo especi cado. O conjunto de resulta
cluirá documentos que não contenham o campo especi cado.
Por exemplo, para consultar as três primeiras cidades em ordem alfabética, use:
Java Kotlin
Android Android
( )( )
let firstThree = citiesRef.orderBy('name').limit(3);

Para ver as três últimas cidades, classi que em ordem decrescente:
Java Kotlin
Android Android
( )( )
let lastThree = citiesRef.orderBy('name', 'desc').limit(3);

https://firebase.google.com/docs/firestore/query-data/order-limit-data?authuser=0 1/3
Também é possível ordenar por vários campos. Por exemplo, se você quiser ordenar por
estado e, em cada ordenação por estado, ordenar por população em ordem decrescente:
Java Kotlin
Android Android
( )( )
let byStateByPop = citiesRef.orderBy('state').orderBy('population', 'desc');

É possível combinar ltros where() com orderBy() e limit(). No exemplo a seguir, as

consultas de nem um limite para população, ordenam por esse valor em ordem crescente
e retornam apenas os primeiros resultados que excedem o limite:
Java Kotlin
Android Android
( )( )
let biggest = citiesRef.where('population', '>', 2500000)

.orderBy('population').limit(2);
No entanto, se você tiver um ltro com uma comparação de intervalo (<, <=, >, >=), será
preciso que sua primeira ordenação esteja no mesmo campo:
 Válido: ltro de intervalo e orderBy no mesmo campo
Java Kotlin
Android Android
( )( )
citiesRef.where('population', '>', 2500000).orderBy('population');

 Inválido: ltro de intervalo e primeiro orderBy em campos diferentes
Java Kotlin
citiesRef.where('population', '>', 2500000).orderBy('country');

14/07/2020 Paginar dados com cursores de consulta | Firebase
Paginar dados com cursores de consulta
How Do I Paginate My Data…

Data…
Com os cursores de consulta no Cloud Firestore, é possível dividir os dados retornados por
uma consulta em lotes de acordo com os parâmetros de nidos.
Os cursores de consulta de nem os pontos inicial e nal de uma consulta, permitindo que
você:
retorne um subconjunto dos dados;
execute a paginação dos resultados da consulta.
No entanto, para de nir um intervalo especí co de uma consulta, use o método where(),
descrito em Consultas simples
(https:// rebase.google.com/docs/ restore/query-data/queries?authuser=0#simple_queries).
Adicionar um cursor simples a uma consulta
Use os métodos startAt() ou startAfter() para de nir o ponto inicial de uma consulta.
O método startAt() inclui o ponto inicial e o método startAfter() o exclui.
Por exemplo, se você usar startAt(A) em uma consulta, será retornado todo o alfabeto.
Mas se você usar startAfter(A), será retornado B-Z.
Java Kotlin+KTX
Android Android
( )( )
const startAtRes = await db.collection('cities')

.orderBy('population')
.startAt(1000000)
.get();
https://firebase.google.com/docs/firestore/query-data/query-cursors?authuser=0 1/4
Da mesma forma, use os métodos endAt() ou endBefore() para de nir um ponto nal
para os resultados da consulta.
Java Kotlin+KTX
Android Android
( )( )
const endAtRes = await db.collection('cities')

.endAt(1000000)
.get();
Usar um instantâneo de documento para de nir o cursor de

consulta
Você também pode transferir um snapshot de documento para a cláusula do cursor como
o ponto inicial ou nal do cursor de consulta. Os valores no snapshot do documento
servem como valores no cursor de consulta.
Por exemplo, tire um snapshot de um documento "San Francisco" no seu conjunto de

dados de cidades e populações. Em seguida, use esse snapshot do documento como o
ponto inicial para seu cursor de consulta de população. Sua consulta retornará todas as
cidades com uma população maior ou igual a de San Francisco, conforme de nido no
instantâneo do documento.
Java Kotlin+KTX
Android Android
( )( )
const docRef = db.collection('cities').doc('SF');

const snapshot = await docRef.get();
const startAtSnapshot = db.collection('cities')
.startAt(snapshot);
await startAtSnapshot.limit(10).get();
Paginar uma consulta
Pagine consultas combinando cursores de consulta com o método limit(). Por exemplo,
use o último documento em um lote como o início de um cursor para o próximo lote.
Java Kotlin+KTX
Android Android
( )( )
const first = db.collection('cities')

.limit(3);
const snapshot = await first.get();
// Get the last document

const last = snapshot.docs[snapshot.docs.length - 1];
// Construct a new query starting at this document.

// Note: this will not have the desired effect if multiple
// cities have the exact same population value.
const next = db.collection('cities')
.startAfter(last.data().population)
.limit(3);
// Use the query for pagination

// ...
De nir o cursor com base em vários campos
Ao usar um cursor baseado em um valor de campo, e não um SnapshotdeDocumento, é

possível tornar a posição do cursor mais precisa ao adicionar outros campos. Isso é
particularmente útil se seu conjunto de dados incluir vários documentos que tenham o
mesmo valor para o campo de cursor, tornando a posição do cursor ambígua. Também é
possível adicionar outros valores de campo ao cursor para especi car ainda mais o ponto
inicial ou nal e reduzir a ambiguidade.
Por exemplo, em um conjunto de dados contendo todas as cidades chamadas "Spring eld"
nos Estados Unidos, haveria vários pontos de partida para um conjunto de consultas
iniciado em "Spring eld":
Cidades
Nome Estado
Spring eld Massachusetts
Spring eld Missouri
Spring eld Wisconsin
Para começar em uma Spring eld especí ca, você pode adicionar o estado como uma
condição secundária na sua cláusula de cursor.
Java Kotlin+KTX
Android Android
( )( )
// Will return all Springfields

const startAtNameRes = await db.collection('cities')
.orderBy('name')
.orderBy('state')
.startAt('Springfield')
.get();
// Will return 'Springfield, Missouri' and 'Springfield, Wisconsin'

const startAtNameAndStateRes = await db.collection('cities')
.orderBy('name')
.orderBy('state')
.startAt('Springfield', 'Missouri')
.get();
14/07/2020 Executar consultas simples e compostas no Cloud Firestore | Firebase
Executar consultas simples e compostas no

Cloud Firestore
O Cloud Firestore tem uma funcionalidade de consulta e ciente que permite a você
especi car os documentos que pretende recuperar de uma coleção ou grupo de coleções.
Essas consultas também podem ser usadas com get() ou addSnapshotListener(),
conforme descrito em Receber dados
(https:// rebase.google.com/docs/ restore/query-data/get-data?authuser=0) e Receber
atualizações em tempo real
(https:// rebase.google.com/docs/ restore/query-data/listen?authuser=0).
Dados de exemplo
Para começar, escreva alguns dados sobre cidades para demonstrarmos diversas formas
de leitura:
Java Kotlin
Android Android
( )( )
let setSf = citiesRef.doc('SF').set({

name: 'San Francisco', state: 'CA', country: 'USA',
regions: ['west_coast', 'norcal']
});
let setLa = citiesRef.doc('LA').set({
name: 'Los Angeles', state: 'CA', country: 'USA',
regions: ['west_coast', 'socal']
});
let setDc = citiesRef.doc('DC').set({
name: 'Washington, D.C.', state: null, country: 'USA',
regions: ['east_coast']
});
let setTok = citiesRef.doc('TOK').set({
https://firebase.google.com/docs/firestore/query-data/queries?authuser=0 1/8
name: 'Tokyo', state: null, country: 'Japan',

regions: ['kanto', 'honshu']
});
let setBj = citiesRef.doc('BJ').set({
name: 'Beijing', state: null, country: 'China',
regions: ['jingjinji', 'hebei']
});
Consultas simples
A seguinte consulta mostra todas as cidades do estado CA:
Java Kotlin
Android Android
( )( )
// Create a reference to the cities collection

// Create a query against the collection

let queryRef = citiesRef.where('state', '==', 'CA');
A consulta a seguir retorna todas as capitais:
Java Kotlin
Android Android
( )( )
// Create a reference to the cities collection

// Create a query against the collection

let queryRef = citiesRef.where('capital', '==', true);
Executar uma consulta
Depois de criar um objeto de consulta, use a função get() para recuperar os resultados:
Java Kotlin
Android Android
( )( )

let query = citiesRef.where('capital', '==', true).get()
.then(snapshot => {
if (snapshot.empty) {
console.log('No matching documents.');
return;
}
});
})
.catch(err => {
});
Consulte Receber dados

(https:// rebase.google.com/docs/ restore/query-data/get-data?authuser=0) para conseguir mais
informações sobre como recuperar os resultados da consulta. Também é possível
adicionar um listener (https:// rebase.google.com/docs/ restore/query-data/listen?authuser=0) a
uma consulta para receber os resultados atuais e detectar futuras atualizações.
Operadores de consulta
O método where() usa três parâmetros: um campo para ltrar, uma operação de
comparação e um valor. A comparação pode ser <, <=, ==, >, >= ou array-contains. Para
iOS, Android e Java, o operador de comparação é nomeado explicitamente no método.
Alguns exemplos de ltros:
Java Kotlin
Android Android
( )( )
let stateQuery = citiesRef.where('state', '==', 'CA');

let populationQuery = citiesRef.where('population', '<', 1000000);
let nameQuery = citiesRef.where('name', '>=', 'San Francisco');
Associação de matriz
Use o operador array-contains para ltrar com base nos valores da matriz. Exemplo:
Java Kotlin
Android Android
( )( )
let westCoastCities = citiesRef.where('regions', 'array-contains',

'west_coast');
Essa consulta retorna todos os documentos city em que o campo regions é uma matriz
contendo west_coast. Se você consultar um valor que tiver várias instâncias na matriz, o
documento será incluído nos resultados apenas uma vez.
Consultas compostas
É possível encadear vários métodos where() para criar consultas mais especí cas (lógica
AND). No entanto, para combinar o operador de igualdade (==) com uma cláusula range ou
array-contains (<, <=, >, >= ou array-contains), não se esqueça de criar um índice
composto (https:// rebase.google.com/docs/ restore/query-data/indexing?authuser=0).
Java Kotlin
Android Android
( )( )
citiesRef.where('state', '==', 'CO').where('name', '==', 'Denver');citiesRef.

Só podem ser feitas comparações de intervalo (<, <=, >, >=) em um campo único e incluir
no máximo uma cláusula array-contains em uma consulta composta:
 Válido: ltros de intervalo em apenas um campo
Java Kotlin
Android Android
( )( )
citiesRef.where('state', '>=', 'CA').where('state', '<=', 'IN');

citiesRef.where('state', '==', 'CA').where('population', '>', 1000000);
 Inválido: ltros de intervalos em campos diferentes
Java Kotlin
Android Android
( )( )
citiesRef.where('state', '>=', 'CA').where('population', '>', 1000000);

Consultas do grupo de coleções
Um grupo de coleções é composto de todos os conjuntos com o mesmo ID. Por padrão,
por meio das consultas são recuperados resultados de uma única coleção no seu banco de
dados. Use uma consulta do grupo de coleções para recuperar documentos de um grupo
em vez de uma única coleção.
Por exemplo, é possível criar um grupo de coleções de landmarks com a adição de uma
subcoleção de pontos de referência a cada cidade:
Java Kotlin
Android Android
( )( )
let landmarks = Promise.all([

citiesRef.doc('SF').collection('landmarks').doc().set({
name: 'Golden Gate Bridge',
type: 'bridge'
}),
citiesRef.doc('SF').collection('landmarks').doc().set({
name: 'Legion of Honor',
type: 'museum'
}),
citiesRef.doc('LA').collection('landmarks').doc().set({
name: 'Griffith Park',
type: 'park'
}),
citiesRef.doc('LA').collection('landmarks').doc().set({
name: 'The Getty',
type: 'museum'
}),
citiesRef.doc('DC').collection('landmarks').doc().set({
name: 'Lincoln Memorial',
type: 'memorial'
}),
citiesRef.doc('DC').collection('landmarks').doc().set({
name: 'National Air and Space Museum',
type: 'museum'
}),
citiesRef.doc('TOK').collection('landmarks').doc().set({
name: 'Ueno Park',
type: 'park'
}),
citiesRef.doc('TOK').collection('landmarks').doc().set({
name: 'National Museum of Nature and Science',
type: 'museum'
}),
citiesRef.doc('BJ').collection('landmarks').doc().set({
name: 'Jingshan Park',
type: 'park'
}),
citiesRef.doc('BJ').collection('landmarks').doc().set({
name: 'Beijing Ancient Observatory',
type: 'museum'
})
]);
Podemos usar a consulta simples e a composta descritas anteriormente para consultar a

subcoleção landmarks de uma cidade, mas também é possível recuperar os resultados da
subcoleção de cada cidade ao mesmo tempo.
No grupo de coleções landmarks estão todos os conjuntos com o ID . Para consultá-lo,

basta fazer uma consulta de grupo de coleções. Por exemplo, com esta consulta de grupo
de coleções são recuperados todos os pontos de referência museum em todas as cidades:
Java Kotlin
Android Android
( )( )
let museums = db.collectionGroup('landmarks').where('type', '==', 'museum');

museums.get().then(function(querySnapshot) {
querySnapshot.forEach(function(doc) {
console.log(doc.id, ' => ', doc.data());
});
});
Antes de usar uma consulta do grupo de coleções, é preciso criar um índice compatível
com ela. Faça isso por meio de uma mensagem de erro, do console ou da Firebase CLI
No caso de SDKs da Web e para dispositivos móveis, você também precisa criar regras que
permitam consultas do grupo de coleções
(https:// rebase.google.com/docs/ restore/security/rules-query?
authuser=0#secure_and_query_documents_based_on_collection_groups)
.
Limitações de consulta
O Cloud Firestore não aceita os tipos de consultas a seguir:
Consultas com ltros de intervalo em campos diferentes, conforme descrito na seção

anterior.
Consultas com operador lógico OR. Nesse caso, crie uma consulta separada para
cada condição OR e mescle os resultados da consulta no seu app.
Consultas com uma cláusula !=. Nesse caso, divida a consulta em duas: uma do tipo
“maior que” e outra do tipo “menor que”. Por exemplo, a cláusula de consulta
where("age", "!=", "30") não é aceita, mas é possível conseguir o mesmo
conjunto de resultados combinando duas consultas, uma com a cláusula
where("age", "<", "30") e outra com a cláusula where("age", ">", 30).
14/07/2020 Locais do Cloud Firestore | Firebase
Locais do Cloud Firestore

Antes de usar o Cloud Firestore, escolha um local para seu banco de dados. Para reduzir a
latência e aumentar a disponibilidade, armazene os dados próximo dos usuários e dos
serviços que precisam deles. Essa con guração é o local padrão dos recursos do Google
Cloud Platform (GCP) (#default-cloud-location) no seu projeto.
Saiba que o local padrão dos recursos do GCP pode ter sido de nido anteriormente durante
a criação do projeto ou quando outro serviço que precisa dessa con guração foi ajustado
(veja abaixo).
tante: o local padrão dos recursos do GCP é usado em serviços da plataforma no projeto que exigem uma
uração de local, especi camente, no intervalo padrão do Cloud Storage e no aplicativo do App Engine, que
sário se você usa o Cloud Scheduler.
Local padrão dos recursos do GCP
Vários serviços disponíveis para o aplicativo exigem uma con guração especí ca que é o
local padrão dos recursos do Google Cloud Platform (GCP) no seu projeto. Esse local é onde
seus dados são armazenados para serem usados por serviços do GCP que exigem essa
con guração.
de nir o local para um dos seguintes serviços também de ne o local dos outros. Depois de de nir o loca
ossível alterá-lo.
Os seguintes produtos compartilham o mesmo local padrão dos recursos do GCP:
Cloud Firestore
Observe que o local padrão do recurso do GCPnão se aplica ao Firebase Realtime
Database (https:// rebase.google.com/docs/database/?authuser=0).
Cloud Storage
Observe que o local padrão do recurso do GCP só se aplica ao intervalo padrão do
Cloud Storage (https:// rebase.google.com/docs/storage?authuser=0). Se você estiver no
plano Blaze, poderá criar vários intervalos, cada um com seu próprio local
(//cloud.google.com/storage/docs/bucket-locations?authuser=0).
https://firebase.google.com/docs/firestore/locations?authuser=0 1/5
Aplicativo do Google App Engine (GAE)

Se você con gurar um aplicativo do Google App Engine
(https://cloud.google.com/appengine/docs/?authuser=0), o local dele será o mesmo do
local padrão do recurso do GCP. Se você usar o Cloud Scheduler, por exemplo, para
executar funções programadas
(https:// rebase.google.com/docs/functions/schedule-functions?authuser=0), será necessário
ter um aplicativo do App Engine no seu projeto.
Tipos de locais
É possível armazenar seus dados do Cloud Firestore em um local com várias regiões
(#location-mr) ou em um local regional (#location-r).
Se você já tiver um aplicativo do App Engine com uma localização que seja us-central ou
europe-west, seu banco de dados do Cloud Firestore será considerado multirregional
(#location-mr).
Locais multirregionais
Um local multirregional é uma área geográ ca geral, como os Estados Unidos. Os dados
em um local multirregional são replicados em várias regiões
(https://cloud.google.com/docs/geography-and-regions?authuser=0#regions_and_zones). Em uma
região, os dados são replicados nas zonas
(https://cloud.google.com/docs/geography-and-regions?authuser=0#regions_and_zones).
Selecione um local multirregional para aumentar a disponibilidade e a durabilidade do seu

banco de dados. Os locais multirregionais podem suportar a perda de regiões inteiras e
manter a disponibilidade sem perder dados.
O Firebase é compatível com os seguintes locais multirregionais dos recursos do GCP:
Nome do local Descrição

Regiões constituintes
multirregional multirregional
eur3 Europa europe-west1, europe-west4
nam5 Estados Unidos us-central1, us-central2 (Oklahoma: região privada

do GCP)
Locais regionais
Um local regional é um lugar geográ co especí co, como a Carolina do Sul. Os dados em
um local regional são replicados em várias zonas em uma região
(https://cloud.google.com/docs/geography-and-regions?authuser=0#regional_resources). A distância
entre todos os locais regionais é de pelo menos 160 quilômetros.
Selecione um local regional para reduzir os custos, diminuir a latência de gravação se o

aplicativo for sensível à latência ou para compartilhar o local com outros recursos do GCP
(https://cloud.google.com/about/locations/?authuser=0#products-available-by-region).
O Firebase é compatível com os seguintes locais regionais dos recursos do GCP:
Nome da região Descrição da região
América do Norte
us-west2 Los Angeles
northamerica-northeast1 Montreal
us-east1 Carolina do Sul
us-east4 Virgínia do Norte
América do Sul
southamerica-east1 São Paulo
Europa
europe-west2 Londres
europe-west3 Frankfurt
europe-west6 Zurique
Ásia
asia-south1 Mumbai
asia-east2 Hong Kong
asia-northeast1 Tóquio
asia-northeast2 Osaka
Austrália
australia-southeast1 Sydney
Contrato de nível de serviço (SLA, na sigla em inglês) do loca
Seu tipo de local do Cloud Firestore determina a porcentagem de tempo de atividade do

Contrato de nível de serviço (SLA) (https://cloud.google.com/ restore/sla?authuser=0):
Serviço coberto Porcentagem de tempo de atividade mensal
Cloud Firestore multirregional >= 99,999%
Cloud Firestore regional >= 99,99%
Preços do local
Seu local do Cloud Firestore determina o custo das operações do banco de dados.
Para uma explicação detalhada sobre os preços por região e por tipo de região, consulte a
página Noções básicas do faturamento do Cloud Firestore
(https:// rebase.google.com/docs/ restore/pricing?authuser=0).
Ver a con guração de local do seu projeto
No Console do Firebase, acesse as Con gurações do projeto

(https://console. rebase.google.com/project/_/settings/general/?authuser=0).
Próximas etapas
Para criar um banco de dados do Cloud Firestore em um local especí co, consulte
Primeiros passos com o Cloud Firestore
(https:// rebase.google.com/docs/ restore/quickstart?authuser=0).
Para mais informações sobre como criar aplicativos para atender às suas
necessidades de latência, disponibilidade e durabilidade, consulte a página Geogra a
e regiões
(https://cloud.google.com/docs/geography-and-regions?authuser=0#multi-regional_resources).

14/07/2020 Gerenciar o Cloud Firestore com o Console do Firebase
Gerenciar o Cloud Firestore com o Console

do Firebase
É possível executar as ações a seguir no Cloud Firestore ao usar o Console do Firebase
(https://console. rebase.google.com/project/_/database/ restore/data?authuser=0):
Ver, adicionar, editar e excluir dados.
Criar e atualizar regras de segurança do Cloud Firestore.
Gerenciar índices.
Monitorar o uso.
Ver dados
É possível ver todos os dados do Cloud Firestore no Console do Firebase. Na guia Dados
(https://console. rebase.google.com/project/_/database/ restore/data?authuser=0) do Cloud
Firestore, clique em um documento ou coleção para abrir os dados aninhados nesse item.
Abrir um caminho especí co
Para abrir um documento ou coleção em um caminho especí co, use o botão Editar
caminho :
Filtrar documentos em uma coleção
Para ltrar os documentos listados em uma coleção, use o botão Filtrar lista :
https://firebase.google.com/docs/firestore/using-console?authuser=0 1/6
Documentos ancestrais inexistentes
Um documento pode existir mesmo se um ou mais dos seus ancestrais estiverem

ausentes. Por exemplo, o documento no caminho /mycoll/mydoc/mysubcoll/mysubdoc
pode existir mesmo que o ancestral /mycoll/mydoc esteja ausente. No visualizador de
dados do Cloud Firestore, um documento ancestral inexistente é exibido assim:
Na lista de documentos de uma coleção, os IDs de documentos ancestrais

inexistentes estão em itálico.
Em um painel de informações de um documento ancestral inexistente, o visualizador

de dados indica que ele está ausente.
os documentos ancestrais inexistentes são exibidos no console, mas eles não aparecem em consultas e
tâneos. Você precisa criar o documento para incluí-lo nos resultados da consulta.
Gerenciar dados
No Cloud Firestore, você armazena dados em documentos que podem ser organizados em
coleções. Antes de começar a adicionar dados, saiba mais sobre o modelo de dados do
Cloud Firestore (https:// rebase.google.com/docs/ restore/data-model?authuser=0).
É possível adicionar, editar e excluir documentos e coleções no Console do Firebase. Para

gerenciar os dados, abra a guia Dados
(https://console. rebase.google.com/project/_/database/ restore/data?authuser=0) na seção Banco
de dados:
vação: as operações realizadas no console são contabilizadas como uso do Cloud Firestore.
Adicionar dados
1. Clique em Adicionar coleção e digite o nome da coleção. Em seguida, clique em

Próxima.
2. Digite um código de documento especí co ou clique em Código automático e, em

seguida, adicione campos para os dados do seu documento.
3. Clique em Salvar. Sua nova coleção e documento aparecem na visualização de

dados.
4. Para adicionar mais documentos à coleção, clique em Adicionar documento.
Editar dados
1. Clique em uma coleção para exibir os documentos dela. Depois, clique em um

documento para ver os campos e subcoleções dele.
2. Clique em um campo para editar o valor dele. Para adicionar campos ou subcoleções
ao documento selecionado, clique em Adicionar campo ou Adicionar coleção.
Excluir dados
Para excluir uma coleção, faça o seguinte:
1. Selecione a coleção que você quer excluir.
2. Clique no ícone de menu na parte superior da coluna de documentos e depois clique

em Excluir coleção.
Para excluir um documento ou todos os campos dele, faça o seguinte:
1. Selecione o documento que você quer excluir.
2. Clique no ícone de menu na parte superior da coluna de detalhes do documento.

Selecione Excluir documento ou Excluir campos do documento.
Ao excluir um documento, você também exclui todos os dados e as subcoleções dele.

Porém, excluir os campos de um documento não exclui as subcoleções.
Para excluir um campo especí co de um documento, faça o seguinte:
1. Selecione o documento para ver os campos dele.
2. Clique no ícone de exclusão ao lado do campo que você quer remover.
Gerenciar regras de segurança do Cloud Firestore
Para adicionar, editar e excluir regras de segurança no Cloud Firestore por meio do Console
do Firebase, acesse a guia Regras
(https://console. rebase.google.com/project/_/database/ restore/rules?authuser=0) na seção
Banco de dados. Saiba mais sobre como con gurar e personalizar regras
(https:// rebase.google.com/docs/ restore/security/get-started?authuser=0).
Gerenciar índices
Para criar novos índices para suas consultas e gerenciar índices atuais usando o Console
do Firebase, acesse a guia Índices
(https://console. rebase.google.com/project/_/database/ restore/indexes?authuser=0) na seção
Banco de dados. Saiba mais sobre como gerenciar índices
Monitorar o uso
Para monitorar o uso do Cloud Firestore, abra a guia Uso

(https://console. rebase.google.com/project/_/database/ restore/usage?authuser=0) no Console do
Firebase. Utilize o painel para avaliar o uso em diferentes períodos.
14/07/2020 Tipos de dados compatíveis | Firebase
Tipos de dados compatíveis

Veja nesta página os tipos de dados compatíveis com o Cloud Firestore.
Tipos de dados
A tabela a seguir lista os tipos de dados com suporte no Cloud Firestore. Também
descreve a ordem de classi cação usada ao comparar valores do mesmo tipo:
Tipo de Ordem de
Observações
dados classi cação
Matriz Por valores de Uma matriz não pode conter outro valor de matriz como um de seus
elemento elementos.
Dentro de uma matriz, os elementos mantêm a posição atribuída a eles. Ao

classi car duas ou mais matrizes, elas são ordenadas com base nos seus
valores de elemento.
Ao comparar duas matrizes, os primeiros elementos de cada uma delas são

comparados. Se os primeiros elementos forem iguais, os segundos
elementos serão comparados, e assim por diante, até que uma diferença
seja encontrada. Se uma matriz car sem elementos para comparar, mas for
igual até esse ponto, a matriz mais curta será ordenada antes da matriz
mais longa.
Por exemplo, [1, 2, 3] < [1, 2, 3, 1] < [2]. A matriz [2] tem o
maior valor no primeiro elemento. A matriz [1, 2, 3] tem elementos
iguais aos primeiros três elementos de [1, 2, 3, 1], mas é menor em
comprimento.
Booleano false < true —
Bytes Ordem de bytes Até 1.048.487 bytes (1 MiB — 89 bytes). Somente os primeiros 1.500 bytes
são considerados nas consultas.
Data e Cronológica Quando armazenados no Cloud Firestore, têm precisão somente para
hora microssegundos. Qualquer precisão adicional é arredondada para baixo.
Número Numérica Precisão dupla de 64 bits, IEEE 754.

de ponto
utuante
Ponto Por latitude e —

geográ co depois longitude
https://firebase.google.com/docs/firestore/manage-data/data-types?authuser=0 1/3
Tipo de Ordem de
Observações
dados classi cação
Número Numérica 64 bits, assinado.

inteiro
Mapa Por chaves e, Representa um objeto incorporado em um documento. Quando indexado, é

em seguida, por possível consultar subcampos. Se você excluir esse valor da indexação,
valor todos os subcampos também serão excluídos.
A ordenação das chaves é sempre classi cada. Por exemplo, se você

escrever {c: "foo", a: "bar", b: "qux"}, o mapa será classi cado
por chave e salvo como {a: "foo", b: "bar", c: "qux"}.
Os campos do mapa são classi cados por chave e comparados por pares
de chave-valor, primeiro comparando as chaves e, em seguida, os valores. Se
os primeiros pares de chave-valor forem iguais, os próximos pares serão
comparados e assim por diante. Se dois mapas começarem com os
mesmos pares de chave-valor, o tamanho do mapa será considerado. Por
exemplo, os mapas a seguir estão em ordem crescente:
{a: "aaa", b: "baz"}

{a: "foo", b: "bar"}
{a: "foo", b: "bar", c: "qux"}
{a: "foo", b: "baz"}
{b: "aaa", c: "baz"}
{c: "aaa"}
Nulo Nenhuma —
ReferênciaPor elementos Por exemplo: projects/[PROJECT_ID]/databases/[DATABASE_ID]/

do caminho documents/[DOCUMENT_PATH].
(coleção, código
do documento,
coleção, código
do documento…)
String de Ordem de bytes Até 1.048.487 bytes (1 MiB — 89 bytes). Somente os primeiros 1.500 bytes
texto codi cada em da representação UTF-8 são considerados nas consultas.
UTF-8
Ordem de tipo de valor
Quando uma consulta envolve um campo com valores de tipos mistos, o Cloud Firestore
usa uma ordem determinista baseada nas representações internas. A lista a seguir mostra
a ordem:
1. Valores nulos
2. Valores booleanos
3. Valores de inteiros e ponto utuante, classi cados em ordem numérica
4. Valores de data
5. Valores de string de texto
6. Valores de byte
7. Referências do Cloud Firestore
8. Valores de ponto geográ co
9. Valores de matriz
10. Valores de mapa
14/07/2020 Receber atualizações em tempo real com o Cloud Firestore | Firebase
Receber atualizações em tempo real com o

Cloud Firestore
To Realtime or Not? | Get to…

to…
É possível detectar um documento com o método onSnapshot(). Uma chamada inicial

usando o retorno de chamada fornecido cria imediatamente um snapshot do documento
com o conteúdo atual do documento único. Depois, sempre que o conteúdo muda, outra
chamada atualiza o snapshot do documento.
vação:os listeners em tempo real não são compatíveis com a biblioteca de cliente PHP.
Java
Site (#site)Swi (#swift)
Android
Node.js (#)Mais

( ) ( )
let doc = db.collection('cities').doc('SF');
let observer = doc.onSnapshot(docSnapshot => {

console.log(`Received doc snapshot: ${docSnapshot}`);
// ...
}, err => {
console.log(`Encountered error: ${err}`);
});
Eventos para alterações locais
As gravações locais no seu app chamarão listeners de snapshots imediatamente. Isso

ocorre devido a um recurso importante, chamado "compensação de latência". Quando você
executa uma gravação, seus listeners são noti cados com os novos dados antes que os
dados sejam enviados ao back-end.
https://firebase.google.com/docs/firestore/query-data/listen?authuser=0 1/6
Os documentos recuperados têm uma propriedade metadata.hasPendingWrites que

indica se o documento tem alterações locais que ainda não foram gravadas no back-end.
Use essa propriedade para determinar a origem dos eventos recebidos pelo seu listener de
snapshot:
Java Kotlin
Android Android
( )( )
// Not yet supported in the Node.js client library
Eventos para alterações de metadados
Ao detectar as alterações em um documento, coleção ou consulta, é possível transmitir

opções para controlar a granularidade dos eventos que seu listener receberá.
Por padrão, os listeners não são noti cados sobre alterações que afetam apenas
metadados. Pense no que acontece quando seu aplicativo grava um novo documento:
1. Um evento de alteração é imediatamente enviado com os novos dados. O documento

ainda não foi gravado no back-end, por isso, a sinalização de gravações pendentes é
true.
2. O documento é gravado no back-end.
3. O back-end noti ca o cliente sobre a gravação bem-sucedida. Não há alterações nos

dados do documento, mas há uma alteração de metadados porque a sinalização de
"gravações pendentes" agora é false.
Se você quiser receber eventos de snapshots quando os metadados do documento ou da

consulta forem alterados, transmita um objeto de opções de detecção ao anexar seu
listener:
Java Kotlin
Android Android
( )( )
// Not yet supported the Node.js client library
vação: se você quiser apenas saber quando sua gravação foi concluída, poderá ouvir o retorno de chamad
usão em vez de usar hasPendingWrites. Em JavaScript, use o Promise retornado da operação de gravaçã
anexar um retorno de chamada .then(). No Swift, trans ra um retorno de chamada de conclusão para su
o de gravação.
Detectar vários documentos em uma coleção
Assim como nos documentos, é possível usar onSnapshot() em vez de get() para
detectar os resultados de uma consulta. Isso cria um snapshot da consulta. Por exemplo,
para detectar os documentos com o estado CA:
Java Kotlin
Android Android
( )( )
let query = db.collection('cities').where('state', '==', 'CA');
let observer = query.onSnapshot(querySnapshot => {

console.log(`Received query snapshot of size ${querySnapshot.size}`);
// ...
}, err => {
console.log(`Encountered error: ${err}`);
});
O gerenciador de snapshots recebe um novo snapshot de consulta sempre que os

resultados dela mudam, ou seja, quando um documento é adicionado, removido ou
modi cado.
tante: conforme explicado acima em Eventos para alterações locais (#events-local-changes), você recebe
os imediatamente para suas gravações locais. Seu listener pode usar o campo metadata.hasPendingWri
da documento para determinar se o documento tem alterações locais que ainda não foram gravadas no b
Ver alterações entre snapshots
Muitas vezes, é útil ver as alterações reais nos resultados da consulta entre snapshots da
consulta, em vez de simplesmente usar o snapshot inteiro da consulta. Por exemplo, talvez
você queira manter um cache à medida que documentos individuais forem adicionados,
removidos e modi cados.
Java Kotlin
Site (#site)Swi (#swift)Objective-C (#objective-c) Android Android
Java (#java)Python
let observer = db.collection('cities').where('state', '==', 'CA')

.onSnapshot(querySnapshot => {
querySnapshot.docChanges().forEach(change => {
if (change.type === 'added') {
console.log('New city: ', change.doc.data());
}
if (change.type === 'modified') {
console.log('Modified city: ', change.doc.data());
}
if (change.type === 'removed') {
console.log('Removed city: ', change.doc.data());
}
});
});
tante: o primeiro snapshot da consulta contém added eventos para todos os documentos atuais
pondentes à consulta. Isso ocorre porque você está recebendo um conjunto de alterações que atualizam
hot da consulta em relação ao estado inicial dela. Isso permite, por exemplo, que você preencha diretame
das mudanças recebidas no snapshot da primeira consulta, sem precisar adicionar uma lógica especial p
ssar o estado inicial.
O estado inicial pode vir diretamente do servidor ou de um cache local. Se houver um

estado disponível em um cache local, o snapshot da consulta será preenchido inicialmente
com os dados armazenados em cache e, em seguida, atualizado com os dados do servidor
quando o cliente tiver alcançado o estado do servidor.
Remover um listener
Quando não estiver mais interessado em detectar os seus dados, remova o listener para
que os retornos de chamada do evento parem de ser chamados. Isso permite que o cliente
pare de usar largura de banda para receber atualizações. Exemplo:
Java Kotlin
Android Android
( )( )
let unsub = db.collection('cities').onSnapshot(() => {

});
// ...
// Stop listening for changes

unsub();
Gerenciar erros de detecção
Às vezes, uma detecção pode falhar, por exemplo, devido a permissões de segurança ou se
você tentar detectar uma consulta inválida. Saiba mais sobre consultas válidas e inválidas
(https:// rebase.google.com/docs/ restore/query-data/queries?authuser=0#compound_queries). Para
lidar com essas falhas, é possível fornecer um retorno de chamada de erro ao incluir o
listener de snapshots. Após um erro, o listener não receberá mais eventos e não será
necessário removê-lo.
Java Kotlin
Android Android
( )( )
db.collection('cities')
.onSnapshot((snapshot) => {
//...
}, (error) => {
//...
});
A seguir
Combine listeners com consultas simples e compostas

(https:// rebase.google.com/docs/ restore/query-data/queries?authuser=0).
Ordene e limite os documentos recuperados

(https:// rebase.google.com/docs/ restore/query-data/order-limit-data?authuser=0).
Entenda o faturamento dos listeners

(https:// rebase.google.com/docs/ restore/pricing?authuser=0#operations).
18/07/2020 Chamar funções via solicitações HTTP | Firebase
Chamar funções via solicitações HTTP

É possível acionar uma função por meio de uma solicitação HTTP usando
functions.https. Isso permite que você invoque uma função síncrona por meio dos
seguintes métodos HTTP compatíveis: GET, POST, PUT, DELETE e OPTIONS.
Os exemplos desta página foram criados com base em uma função de amostra
(https://github.com/ rebase/functions-samples/tree/master/quickstarts/time-server) (em inglês)
que é acionada quando você envia uma solicitação HTTP GET para o ponto de extremidade
das funções. A função de amostra recupera a hora atual do servidor, formata a hora
conforme especi cado em um parâmetro de consulta de URL e envia o resultado na
resposta HTTP.
Acionar uma função com uma solicitação HTTP
Use functions.https (/docs/reference/functions/cloud_functions_#https-function) para criar

uma função que gerencie eventos HTTP. O manipulador de uma função HTTP detecta o
evento onRequest() (/docs/reference/functions/providers_https_#onrequest), que é compatível
com roteadores e apps gerenciados pelo framework da Web Express (https://expressjs.com/)
(em inglês).
Como usar objetos de solicitação e resposta da Express
Usado na forma de argumentos de onRequest(), o objeto de solicitação

(http://expressjs.com/en/4x/api.html#req) (em inglês) concede acesso às propriedades da
solicitação HTTP enviada pelo cliente, e o objeto de resposta
(http://expressjs.com/en/4x/api.html#res) (em inglês) permite retornar uma resposta a ele.
rts.date = functions.https.onRequest((req, res) => {

...
tante: todas as funções HTTP precisam ser encerradas corretamente. Ao encerrar as funções corretamen
pode evitar cargas excessivas de funções que funcionam por muito tempo. Encerre funções HTTP com
edirect(), res.send() ou res.end().
https://firebase.google.com/docs/functions/http-events 1/6
Como usar apps Express existentes
Ao usar o app (http://expressjs.com/en/4x/api.html#req.app) (em inglês) como argumento de

onRequest(), é possível transmitir um app Express completo para uma função HTTP. O
código de texto clichê pode ser movido para o middleware como mostrado abaixo:
t express = require('express');
t cors = require('cors');
t app = express();
utomatically allow cross-origin requests

use(cors({ origin: true }));
dd middleware to authenticate requests

use(myMiddleware);
uild multiple CRUD interfaces:

get('/:id', (req, res) => res.send(Widgets.getById(req.params.id)));
post('/', (req, res) => res.send(Widgets.create()));
put('/:id', (req, res) => res.send(Widgets.update(req.params.id, req.body)));
delete('/:id', (req, res) => res.send(Widgets.delete(req.params.id)));
get('/', (req, res) => res.send(Widgets.list()));
xpose Express API as a single Cloud Function:

rts.widgets = functions.https.onRequest(app);
Invocar uma função HTTP
Depois de implantar uma função HTTP, você pode invocá-la por meio do URL exclusivo
dela. O URL inclui as informações abaixo na ordem mostrada:
A região (ou regiões) em que você implantou sua função Algumas funções de
produção podem precisar de nir explicitamente o local (/docs/functions/locations) para
minimizar a latência da rede
seu código do projeto do Firebase
cloudfunctions.net
O nome da sua função
Por exemplo, o URL de invocação date() terá a seguinte aparência:
s://us-central1-<project-id>.cloudfunctions.net/date
do: novas funções HTTP e HTTP chamáveis implantadas com qualquer Firebase CLI anterior à versão 7.7
as por padrão e geram erros HTTP 403 quando invocadas. Torne essas funções públicas
ud.google.com/functions/docs/securing/managing-access) explicitamente ou atualize a Firebase CLI
s/cli#setup_update_cli) antes de implantar novas funções.
Se você encontrar erros de permissão ao implantar funções, veri que se os papéis do IAM
(/docs/projects/iam/permissions#functions) apropriados estão atribuídos ao usuário que
executa os comandos de implantação.
Com o roteamento de app do Express, o nome da função é adicionado como um pre xo

aos caminhos do URL no aplicativo de nido por você. Por exemplo, o URL para invocar o
getter no exemplo do app Express acima ca assim:
s://us-central1-<project-id>.cloudfunctions.net/widgets/<id>
Se você invocar funções HTTP protegidas por um rewall ou ltro IP, poderá procurar
(https://cloud.google.com/compute/docs/faq# nd_ip_range) os endereços IP usados pelo Google
para exibir funções HTTP.
Usar módulos de middleware com o Cloud Functions
Se você precisa inserir dependências de middleware para suporte a cookies ou acesso de

origem cruzada (CORS, na sigla em inglês), chame os módulos a partir da função. Por
exemplo, para ativar o suporte a CORS, adicione o seguinte bloco:
nable CORS using the `cors` express middleware.

rn cors(req, res, () => {
...
Ler os valores da solicitação
A tabela a seguir lista alguns cenários comuns:
Tipo de conteúdo Corpo da solicitação Comportamento
application/ '{"name":"John"}'request.body.name = 'John'

json
application/ 'my text' request.body é igual a "6d792074657874", o número bruto

octet-stream de bytes da solicitação. Consulte a documentação do buffer
do Node.js (https://nodejs.org/api/buffer.html) (em inglês)
text/plain 'my text' request.body = 'my text'
application/ 'name=John' request.body.name = 'John'

x-www-form-
urlencoded
Esta análise é feita pelos seguintes analisadores de corpo:
analisador de corpo de arquivos JSON

(https://www.npmjs.com/package/body-parser#bodyparserjsonoptions)
analisador de corpo de arquivos Raw

(https://www.npmjs.com/package/body-parser#bodyparserrawoptions)
analisador de corpo de texto

(https://www.npmjs.com/package/body-parser#bodyparsertextoptions)
analisador de corpo de formulário codi cado pelo URL

(https://www.npmjs.com/package/body-parser#bodyparserurlencodedoptions)
Suponha que sua função seja chamada com a seguinte solicitação:
-X POST -H "Content-Type:application/json" -H "X-MyHeader: 123" YOUR_HTTP_TRI
então, os dados enviados seriam aplicados a:
Propriedade/Método Valor
req.method "POST"
req.get('x-myheader') "123"
req.query.foo "baz"
Propriedade/Método Valor
req.body.text "something"
req.rawBody O número de bytes bruto (não analisados) do pedido
No exemplo de função date(), a função testa o parâmetro de URL e o corpo de um valor de

format para de nir o formato de data/hora a ser usado:
format = req.query.format;
at = req.body.format;
x.js (https://github.com/ rebase/functions-samples/blob/3ed989ff6c4f6b07c0abd9a5c8ec432cd84d36
Terminar funções HTTP
Sempre encerre uma função HTTP com send(), redirect() ou end(). Caso contrário, ela
pode continuar a ser executada e interrompida automaticamente pelo sistema. Veja
também Sincronização, dessincronização e promessas (/docs/functions/terminate-functions).
A função date() será concluída depois que o horário do servidor for recuperado e
formatado com o módulo moment (https://www.npmjs.com/package/moment) (em inglês) do
Node.js e quando o resultado na resposta HTTP for enviado.
t formattedDate = moment().format(format);
ole.log('Sending Formatted date:', formattedDate);
status(200).send(formattedDate);
x.js (https://github.com/ rebase/functions-samples/blob/3ed989ff6c4f6b07c0abd9a5c8ec432cd84d36
Como conectar funções HTTP ao Firebase Hosting
Você pode conectar uma função HTTP ao Firebase Hosting. As solicitações no seu site do
Firebase Hosting podem ser encaminhadas para funções HTTP especí cas. Isso também
permite que você use seu próprio domínio personalizado com uma função HTTP. Saiba
mais sobre Como conectar o Cloud Functions ao Firebase Hosting (/docs/hosting/functions).
Policies (https://developers.google.com/site-policies). Java is a registered trademark of Oracle and/or its
a liates.

Cloud Firestore-Firebase

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Cloud Firestore-Firebase

Enviado por

Direitos autorais:

Formatos disponíveis

Cloud Firestore (Database - Firebase)

Use nosso banco de dados de nuvem NoSQL flexível e escalonável para

O Cloud Firestore é um banco de dados NoSQL

Seguindo o modelo de dados NoSQL do Cloud

Além disso, as consultas no Cloud Firestore são expressivas, eficientes e

Proteja o acesso aos dados no Cloud Firestore com o Firebase Authentication e

Criar um banco de dados do Cloud Firestore

1. Crie um projeto do Firebase, se você ainda não fez isso: no Console do

Ideal para dar os primeiros passos com as bibliotecas de cliente de

Nega todas as leituras e gravações de clientes de dispositivos móveis e

Configurar o ambiente de desenvolvimento

Adicione as dependências e as bibliotecas de cliente necessárias ao aplicativo.

1. Adicione o SDK Admin do Firebase ao seu app:

npm install firebase-admin --save

Inicializar o Cloud Firestore

Inicializar uma instância do Cloud Firestore:

O SDK do Cloud Firestore é inicializado de diferentes maneiras, dependendo do seu ambiente.

• Inicializar no Cloud Functions

• Inicializar no Google Cloud Platform

const admin = require('firebase-admin');

• Inicializar no seu próprio servidor

O Cloud Firestore é um banco de dados NoSQL orientado a documentos. Ao

Cada documento contém um conjunto de pares chave-valor. O Cloud Firestore

É necessário que todos os documentos sejam armazenados em coleções. Os

Coleções e documentos são criados implicitamente no Cloud Firestore. Basta

No Cloud Firestore, a unidade de armazenamento é o documento. Um

Um documento que representa um usuário alovelace pode ser assim:

Observação: O Cloud Firestore é compatível com vários tipos de dados de valores:

Objetos complexos e aninhados em um documento são chamados de mapas.

Os documentos pertencem a coleções, que são

Não é preciso "criar" ou "excluir" coleções. Depois de criar o primeiro

Cada documento no Cloud Firestore é identificado de maneira exclusiva pela

let alovelaceDocumentRef = db.collection('users').doc('alovelace');

É possível também criar referências a coleções:

let usersCollectionRef = db.collection('users');

Observação: referências de coleções e referências de documentos são dois tipos

Por conveniência, também é possível criar referências especificando o caminho

let alovelaceDocumentRef = db.doc('users/alovelace');

Para entender como as estruturas hierárquicas de dados funcionam no Cloud

Crie um conjunto chamado rooms para armazenar salas de bate-papo

Observação: é possível consultar as subcoleções com o mesmo ID de coleção, basta

É possível criar uma subcoleção chamada messages para cada documento da

let messageRef = db.collection('rooms').doc('roomA')

Observe o padrão alternado de coleções e documentos. É importante que suas

As subcoleções permitem que você estruture os dados hierarquicamente,

Documentos em subcoleções também podem conter subcoleções, permitindo

Aviso: a exclusão de um subgrupo não exclui as subcoleções.

O Cloud Firestore armazena dados nos Documentos que são armazenados

Crie uma nova coleção e um documento usando o código de exemplo a seguir.

let docRef = db.collection('users').doc('alovelace');

let setAda = docRef.set({

Agora, adicione outro documento à coleção users. Observe que esse

let aTuringRef = db.collection('users').doc('aturing');

let setAlan = aTuringRef.set({

Para verificar rapidamente se você adicionou dados ao Cloud Firestore, use o

É possível usar o método "get" para recuperar toda a coleção.

Proteger seus dados

Autenticação obrigatóriaModo bloqueadoModo de teste

// Allow read/write access on all documents to any user signed in

Se você estiver usando um dos SDKs do servidor, utilize o Gerenciamento de

Receber dados com o Cloud Firestore

How do queries work in Clo…

Há duas maneiras de recuperar dados armazenados no Cloud Firestore. Qualquer um