Este artigo é um guia detalhado que ajudará você a configurar seu banco de dados do Firebase e a executar operações CRUD simples com ele usando o Python.

O Firebase, como você deve saber, é uma plataforma oferecida pelo Google para acelerar o desenvolvimento de aplicações. Ele oferece BaaS, ou back-end como serviço, o que significa que o Firebase cuida da infraestrutura de nuvem e de todas as suas necessidades de back-end. Isso permite desenvolver e implementar mais rapidamente.

O Firebase oferece vários produtos incríveis, como o Realtime Database (banco de dados em tempo real), a Cloud Firestore (nuvem Firestore) e Authentication (autenticação). Também permite hospedagem e oferece APIs para tarefas de aprendizagem de máquina, como reconhecimento de texto, rotulagem de imagens e muito mais!

Vá até o site deles e se encante com as opções disponíveis.

Como configurar o Realtime Database do Firebase

Crie um projeto no Firebase – vamos chamá-lo de BookStoreProject (projeto de loja de livros). Depois de configurado, crie um Realtime Database selecionando a opção Create Database (criar banco de dados).

Ao clicar em Create Database, você deve especificar a localização do banco de dados e as regras de segurança. Duas regras estão disponíveis:

• locked mode (modo bloqueado), que nega todas leituras e gravações no banco de dados e
• test mode (modo de teste), que permite acesso de leitura e gravação por um período padrão de 30 dias (após o qual todas as leituras e gravações são negadas, a menos que as regras de segurança sejam atualizadas).

Como usaremos o banco de dados para leitura, gravação e edição escolheremos o test mode. Feito isso, o banco de dados está pronto para o nosso uso!

Como gravar no Firebase Realtime Database usando Python

O próximo passo é descobrir como podemos nos conectar com o nosso banco de dados usando Python. Vamos usar a API Admin Database. Você precisará instalar a biblioteca necessária.

Para obter mais informações sobre como usar o firebase_admin para Python, confira a documentação oficial aqui (documentação em inglês).

pip install firebase_admin

Para se conectar ao Firebase, precisamos das seguintes linhas de código:

import firebase_admin

cred_obj = firebase_admin.credentials.Certificate('....path to file')
default_app = firebase_admin.initialize_app(cred_object, {
	'databaseURL':databaseURL
	})

No entanto, para fazer o código funcionar precisamos de alguns pré-requisitos.

Primeiro, precisamos especificar o caminho para uma chave de conta de serviço (em inglês, Service Account Key), que será usada para inicializar o admin SDK.

O Firebase permitirá o acesso às APIs do servidor Firebase a partir das contas de serviço do Google. Para autenticar a conta de serviço, é necessária uma chave privada no formato JSON.

O caminho para esse arquivo JSON deve ser fornecido para criar o objeto de credenciais. Para gerar a chave, vá até as configurações do projeto (Project Settings, em inglês), clique em gerar nova chave privada (Generate new private key, em inglês), baixe o arquivo e coloque-o em sua estrutura de diretórios.

Para um explicação mais detalhada sobre esse processo, consulte a documentação oficial aqui (documentação em inglês).

Em seguida, precisamos de databaseURL, que é simplesmente o URL que dá acesso ao nosso banco de dados. Ele está presente na própria página do Realtime Database no console do Firebase.

Como gravar usando a função set()

from firebase_admin import db

ref = db.reference("/")

Definimos a referência para a root (raiz) do banco de dados (ou também podemos defini-la como um par chave-valor, ou como um par chave-valor filho). A pergunta que surge naturalmente é: qual esquema é permitido para armazenar dados em banco de dados de tempo real?

Todos os dados a serem armazenados devem estar no formato JSON, ou seja, uma sequência de pares chave-valor. Se você precisar de uma chave gerada pelo sistema, poderá optar por usar a função push(), que abordaremos em breve.

Vamos criar um JSON adequado que pode ser salvo no banco de dados. Temos informações sobre quatro livros da seguinte maneira:

{
	"Book1":
	{
		"Title": "The Fellowship of the Ring",
		"Author": "J.R.R. Tolkien",
		"Genre": "Epic fantasy",
		"Price": 100
	},
	"Book2":
	{
		"Title": "The Two Towers",
		"Author": "J.R.R. Tolkien",
		"Genre": "Epic fantasy",
		"Price": 100	
	},
	"Book3":
	{
		"Title": "The Return of the King",
		"Author": "J.R.R. Tolkien",
		"Genre": "Epic fantasy",
		"Price": 100
	},
	"Book4":
	{
		"Title": "Brida",
		"Author": "Paulo Coelho",
		"Genre": "Fiction",
		"Price": 100
	}
}

Carregamos o arquivo JSON necessário e salvamos os dados no banco de dados assim:

import json
with open("book_info.json", "r") as f:
	file_contents = json.load(f)
ref.set(file_contents)

O banco de dados agora tem esta aparência:

Como gravar usando a função push()

O Firebase nos fornece a função push(), que salva dados em uma chave única gerada pelo sistema. Esse método garante que, se várias gravações estiverem sendo executadas na mesma chave, elas não serão substituídas.

Por exemplo, se várias fontes tentarem fazer uma gravação em /Books/Best_Sellers/, então qualquer que seja a fonte que fizer a ultima gravação, esse valor persistirá no banco de dados. Isso introduz a possibilidade de dados serem sobrescritos. push() resolve esse problema usando chaves exclusivas para cada novo "filho" adicionado.

ref = db.reference("/")
ref.set({
	"Books":
	{
		"Best_Sellers": -1
	}
})

ref = db.reference("/Books/Best_Sellers")
import json
with open("book_info.json", "r") as f:
	file_contents = json.load(f)

for key, value in file_contents.items():
	ref.push().set(value)

Observe que push() e set() não são atômicos. Isso significa que não há garantia que ambas as funções serão executadas juntas sem interrupção como uma única unidade indivisível.

Enquanto o banco de dados está sendo atualizado, se tentarmos buscar os dados, pode acontecer que push() tenha terminado, mas set() ainda não. Então, o JSON que recebemos terá uma chave gerada pelo sistema sem um campo de valor.

Como atualizar seu banco de dados do Firebase com Python

Atualizar o banco de dados é tão simples quanto definir a referência no ponto necessário e usar a função update(). Digamos que o preço dos livros de J. R. R. Tolkien seja reduzido para 80 para oferecer um desconto.

ref = db.reference("/Books/Best_Sellers/")
best_sellers = ref.get()
print(best_sellers)
for key, value in best_sellers.items():
	if(value["Author"] == "J.R.R. Tolkien"):
		value["Price"] = 90
		ref.child(key).update({"Price":80})
        
        

Como recuperar dados do Firebase usando Python

Já recuperamos dados usando o método get() quando tentamos atualizar uma chave específica. Agora, veremos mais alguns métodos e agrupamentos para fazer consultas mais complexas.

Vamos colocar todos os livros em ordem, classificando-os por preço usando o método order_by_child(). Para aplicar esse método, primeiramente, temos que definir a chave pela qual estamos ordenando como o campo de índice por meio da regra .indexOn nas regras de segurança do Firebase.

Se quisermos classificar por preço, o preço deve ser listado como índice. Você pode definir o valor assim:

ref = db.reference("/Books/Best_Sellers/")
print(ref.order_by_child("Price").get())

O valor de retorno do método é um OrderedDict. Para ordenar por chave, use order_by_key(). Para obter o livro com o maior preço, utilizamos o método limit_to_last(), da seguinte maneira:

ref.order_by_child("Price").limit_to_last(1).get()

Como alternativa, para obter o livro com menor preço, escrevemos:

ref.order_by_child("Price").limit_to_first(1).get()

Para obter livros com preço igual a 80, usamos:

ref.order_by_child("Price").equal_to(80).get()

Para mais exemplos e métodos de consulta do banco de dados de acordo com seus requisitos, confira a documentação oficial aqui (documentação em inglês).

Como excluir dados do Firebase usando Python

Excluir dados é bem simples. Vamos excluir todos os livros mais vendidos que tenham J.R.R Tolkien como autor.

ref = db.reference("/Books/Best_Sellers")

for key, value in best_sellers.items():
	if(value["Author"] == "J.R.R. Tolkien"):
		ref.child(key).set({})
        
        

Conclusão

Neste artigo, aprendemos como criar um banco de dados usando o Realtime Database do Firebase, como preenchê-lo com dados, excluir, atualizar e consultar os dados usando Python.

Espero poder ter ajudado os desenvolvedores em Python que acabaram de descobrir a utilidade do Firebase, mas que também estão se sentindo sobrecarregados com tantas opções e métodos diferentes para escolher. Se você leu até aqui, muito obrigada! Cuide-se e divirta-se programando!

Escrito por: Leandro Cesquini Pereira

Como atualizar um valor específico em um array JSONB

Digamos que você decidiu armazenar dados em um banco de dados como json ou jsonb e descobriu que acaba de criar novos problemas para si mesmo que antes não existiam. Você não está sozinho.

O JSONB é uma ferramenta poderosa, mas tem um custo, pois você precisa adaptar a maneira como faz consultas (em inglês, queries) e manipula os dados.

Não é raro carregar todo o objeto JSONB na memória, transformá-lo usando sua linguagem de programação preferida e salvar o objeto novamente no banco de dados. Você, no entanto, acaba de criar um problema de gargalos de desempenho e desperdício de recursos.

Neste artigo, vamos ver como atualizar um valor específico de um objeto dentro de um array com uma consulta.

Versão resumida: a query final está no fim do artigo. Você pode conferir um exemplo no DB Fiddle para copiar, colar e testar por sua conta.

Suponha que você esteja implementando tela de clientes o armazenamento de contatos dinâmicos para cada cliente. Então, você tem a ideia de armazenar os contatos em uma coluna em JSONB, pois eles são dinâmicos. Assim, usar uma estrutura de dados não relacional faz sentido.

Em seguida, você cria uma tabela de clientes com uma coluna de contatos em JSONB e insere alguns dados nela:

Bem fácil, não é? Como, no entanto, podemos atualizar um contato específico para um cliente específico? Como mudar o e-mail de Jimi ou o telefone de Janis, por exemplo?

Felizmente, o PostgreSQL é seu amigo e fornece a função jsonb_set:

jsonb_set(target jsonb, path text[], new_value jsonb[, create_missing boolean])

Dada uma coluna de jsonb, você pode definir um novo valor no caminho especificado:

Os selects (seleções) acima retornarão:

[{"type": "phone", "value": "+1–202–555–0105"}, {"type": "email", "value": "jimi.hendrix@gmail.com"}]

[{"type": "email", "value": "janis.joplin@gmail.com"}]

Para alterar o e-mail de Jimi na lista de contatos, informe o caminho "1, value", que significa o segundo objeto do array (começando em 0) e a chave value (valor). Esse é o path (caminho). O mesmo se aplica para alterar o e-mail de Janis, mas seu objeto de e-mail está no índice 0.

Você deve estar pensando: eu só preciso usar jsonb_set em um statement (instrução) de atualização e pronto? Essa é a ideia, mas ainda não é o suficiente.

O problema com dados não relacionais é que eles são dinâmicos. Bem, esse é um dos motivos para se usar JSONB, mas gera um problema: veja que o objeto de e-mail de Jimi está no índice 1 e o objeto de e-mail de Janis está no índice 0 do array. Outro cliente poderia ter um array muito diferente com índices diferentes. Então, como descobrir o índice de cada tipo de contato?

A resposta é ordenar os elementos do array e obter seu índice:

A query retorna 1, que é o índice do objeto email (de tipo email) dentro do array de contatos do cliente Jimi.

Agora, temos todas as peças do quebra-cabeça: sabemos como atualizar um valor em jsonb e como descobrir o índice de um objeto a ser atualizado.

O único passo que resta é a própria atualização. Juntando tudo, temos:

A parte mais importante dessa query é o bloco with. É um recurso poderoso, mas, para este exemplo, você pode pensar nele como um "modo de armazenar uma variável", que é o path(caminho) do contato que é necessário atualizar, o qual será dinâmico, dependendo do registro.

Deixe-me explicar um pouco sobre esta parte:

(‘{‘||index-1||’,value}’)::text[] as path

Essa parte apenas constrói path como '{1, value}', mas precisamos converter para text[], pois esse é o tipo esperado em uma função jsonb_path.

Resumindo

O JSONB é uma ferramenta excelente e valiosa para resolver muitos problemas. Tenha em mente, porém, que você também precisa consultar e atualizar esse tipo de dado. Isso traz um custo que você deve considerar ao decidir quais ferramentas escolher para usar.

Observação: essa solução surgiu de uma sessão de programação com Lucas Cegatti.

Está procurando por uma empresa criativa para implementar sua próxima ideia? Confira a LNA Systems.

O que é uma promise ?

Uma promise em Javascript é um objeto que representa a conclusão ou o fracasso de uma tarefa assíncrona e seu valor resultante.¹

Fim.

Estou brincando, é claro. Então, o que essa definição significa?

Primeiramente, muitas coisas em Javascript são objetos. É possível criar um objeto de maneiras diferentes. A maneira mais comum é com a sintaxe literal de objeto:

const myCar = {
   color: 'blue',
   type: 'sedan',
   doors: '4',
};

Você pode também criar uma class (classe) e instanciá-la com a palavra chave new (nova).

class Car {
   constructor(color, type, doors) {
      this.color = color;
      this.type = type;
      this.doors = doors
   }
}

const myCar = new Car('blue', 'sedan', '4');

console.log(myCar);

Uma promise é, simplesmente, um objeto que criamos, como no exemplo posterior. Nós a instanciamos com a palavra chave new. Em vez dos três parâmetros que passamos para fazer nosso carro (color - cor, type - tipo, doors - portas), nós passamos uma função que recebe dois argumentos: resolve (resolver) e reject (rejeitar).

No fim, promises nos dizem algo sobre a conclusão da função assíncrona da qual a retornamos – se deu certo ou não. Dizemos que a função foi bem-sucedida se a promise resolved (foi resolvida) e que não foi bem-sucedida se a promise rejected (foi rejeitada).

const myPromise = new Promise(function(resolve, reject) {});

console.log(myPromise);

const myPromise = new Promise(function(resolve, reject) {
   resolve(10);
});

Veja, nada muito assustador – apenas um objeto que criamos. Se nós o expandirmos um pouco:

Além disso, podemos passar qualquer coisa que queiramos para resolver e rejeitar. Por exemplo, poderíamos passar um objeto em vez de uma string:

return new Promise((resolve, reject) => {
   if(somethingSuccesfulHappened) {
      const successObject = {
         msg: 'Success',
         data,//...alguns dados que recebemos
      }
      resolve(successObject); 
   } else {
      const errorObject = {
         msg: 'An error occured',
         error, //...algum erro recebido
      }
      reject(errorObject);
   }
});

Ou, como vimos anteriormente, não precisamos passar nada:

return new Promise((resolve, reject) => {
   if(somethingSuccesfulHappend) {
      resolve()
   } else {
      reject();
   }
});

E quanto à parte “assíncrona” da definição?

JavaScript opera a partir de uma única thread. Isso significa que consegue executar apenas uma coisa de cada vez. Imagine uma estrada. Você pode pensar em JavaScript como uma rodovia de pista única. Certos códigos (código assíncrono) podem ceder lugar permitindo que outra parte do código o passe (seja executado primeiro). Quando esse código assíncrono termina sua tarefa, ele retorna à estrada.

Como observação, podemos retornar uma promise a partir de qualquer função. Não há necessidade de ser assíncrona. Dito isso, promises geralmente são retornadas nos casos em que a função da qual retornam é assíncrona. Por exemplo, uma API que possui métodos para salvar dados em um servidor seria uma ótima candidata para retornar uma promise!

Concluindo:

Promises nos dão uma maneira de aguardar que o nosso código assíncrono seja concluído, capturemos valores a partir disso e passemos esses valores a outras partes do nosso programa.

Eu tenho um artigo aqui que se aprofunda nesses conceitos: Thrown For a Loop: Understanding Loops and Timeouts in JavaScript (texto em inglês).

Como usamos uma promise?

Usar uma promise também é chamado de consumir uma promise. No nosso exemplo acima, nossa função retornou um objeto promise. Isso nos permite usar o encadeamento de métodos com nossa função.

Aqui está um exemplo de encadeamento de métodos que eu aposto que você já viu:

const a = 'Some awesome string';
const b = a.toUpperCase().replace('ST', '').toLowerCase();

console.log(b); // some awesome ring

Agora, chamamos nossa promise (fictícia):

const somethingWasSuccesful = true;

function someAsynFunction() {
   return new Promise((resolve, reject){
      if (somethingWasSuccesful) {
         resolve();     
      } else {
         reject()
      }
   });
}

Consumindo nossa promise usando encadeamento de métodos, temos:

someAsyncFunction
   .then(runAFunctionIfItResolved(withTheResolvedValue))
   .catch(orARunAfunctionIfItRejected(withTheRejectedValue));

Um exemplo (mais) real

Imagine que você tem uma função que obtém usuários de um banco de dados. Escrevi uma função de exemplo no CodePen, que simula uma API que você pode usar. Ela fornece duas opções para acessar os resultados. Primeiro, você pode prover uma função de callback onde você pode acessar o usuário ou qualquer erro. Em segundo, a função retorna uma promise como forma de acessar o usuário ou o erro.

Tradicionalmente, acessamos os resultados do código assíncrono através do uso de callbacks.

rr someDatabaseThing(maybeAnID, function(err, result)) {
   //...Depois que obtemos o que vamos buscar no banco de dados...
   if(err) {
      doSomethingWithTheError(error)
   }   else {
      doSomethingWithResults(results);
   }
}

O uso de callbacks é aceitável até que eles se tornem excessivamente aninhados. Em outras palavras, você precisa executar mais código assíncrono a cada novo resultado. Esse padrão de callbacks dentro de callbacks pode levar a algo conhecido como "callback hell" (inferno das callbacks).

Promises nos oferecem uma maneira mais elegante e legível de ver o fluxo do nosso programa.

doSomething()
   .then(doSomethingElse) // e se você não se importar
   .catch(anyErrorsPlease);

Escrevendo nossa promise: Cachinhos Dourados, os três ursos e um supercomputador

Imagine que você encontrou uma tigela de sopa. Você gostaria de saber a temperatura da sopa antes de comê-la. Porém, você está sem termômetros. Felizmente, você possui acesso a um supercomputador capaz de dizer a temperatura da tigela de sopa. Infelizmente, esse supercomputador pode levar até 10 segundos para obter os resultados.

Algumas coisas para observarmos.

1. Iniciamos a variável global chamada result.
2. Simulamos a duração do delay (atraso) da rede com  Math.random() e setTimeout().
3. Simulamos a temperatura com Math.random().
4. Mantemos os valores de delay e de temperatura confinados dentro de um range (intervalo) adicionando "matemática" extra. O range para temp é de 1 a 300; o range para o delay é 1000ms a 10000ms (1 a 10 segundos).
5. Registramos o delay e a temperatura para ter uma ideia de quanto tempo essa função levará e os resultados que esperamos ver quando estiver concluída.

Execute a função e registre os resultados.

getTemperature(); 
console.log(results); // undefined

A temperatura é undefined (indefinida). O que aconteceu?

A função levará um certo tempo para ser executada . A variável não é definida até que o delay acabe. Então, enquanto executamos a função, setTimeout é assíncrona. A parte do código em setTimeout sai do thread principal para uma área de espera.

Tenho um artigo aqui que se aprofunda nesse processo: Thrown For a Loop: Understanding Loops and Timeouts in JavaScript (texto em inglês).

Como a parte da nossa função que define a variável result se move para uma área de espera até que seja concluída, nosso analisador está livre para passar para a próxima linha. No nosso caso, é nosso console.log(). Nele, result ainda é undefined pois, nosso setTimeout não acabou.

Então, o que mais poderíamos tentar ? Poderíamos executar getTemperature() e aguardar 11 segundos (já que o nosso delay máximo e de 10 segundos) e then (então) fazer o console.log dos resultados.

getTemperature();
   setTimeout(() => {
      console.log(result); 
   }, 11000);
   
// Muito quente | Delay: 3323 | Temperatura: 209 graus

Isso funciona, mas o problema com essa técnica é que, embora em nosso exemplo saibamos o delay máximo da rede, em um exemplo da vida real, pode levar ocasionalmente mais de 10 segundos. Mesmo que pudéssemos garantir um delay máximo de 10 segundos, se o resultado ficar pronto antes, haverá um desperdício de tempo.

As promises salvam o dia

Vamos refatorar nossa função getTemperature() para retornar uma promise. Em vez de definir o resultado, rejeitaremos a promise a menos que o resultado seja "na medida", caso em que resolveremos a promise. Em ambos os casos, passaremos alguns valores para resolver e rejeitar.

Agora, podemos usar os resultados da nossa promise que estamos retornando (também chamado de consumir a promise).

getTemperature()
   .then(result => console.log(result))
   .catch(error => console.log(error));
   
// Rejeitar: muito fria | Delay: 7880 | Temperatura: 43 graus

.then será chamado quando nossa promise for resolvida e retornará qualquer informação que passamos para o resolve.

.catch será chamado quando nossa promise for rejeitada e retornará qualquer informação que passamos para o reject.

Muito provavelmente, você consumirá mais promises do que as criará. Em ambos os casos, elas ajudam a tornar o código mais elegante, legível e eficiente.

Resumo

1. Promises são objetos que contém informações sobre a conclusão de algum código assíncrono e quaisquer valores resultantes que queremos passar.
2. Para retornar uma promise usamos return new Promise((resolve, reject)=> {})
3. Para consumir uma promise usamos .then, para obter as informações de uma promise que foi resolvida, e .catch, para obter as informações de uma promise que foi rejeitada.
4. Você provavelmente usará (consumirá) promises mais do que as escreverá.

Referências

1. https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Promise