DEV Community: Kauan Amorim da Silva

Entendo a ordem de execução de uma query SQL

Kauan Amorim da Silva — Wed, 13 Nov 2024 14:56:22 +0000

Geralmente, no ambiente de trabalho, costumo dar dicas e explicar alguns conceitos para os desenvolvedores juniores, para que eles possam, aos poucos, absorver noções sobre performance, boas práticas e aspectos de segurança. Um dos pontos que gosto de destacar é a importância da ordem de execução de uma query SQL. Normalmente, abordo esse assunto quando percebo que eles já superaram as dificuldades iniciais com SQL e começam a tentar criar consultas mais robustas e complexas.

Ordem de Execução

FROM: Define a tabela principal da consulta de dados.
JOIN: Estabelece a junção e o relacionamento entre as tabelas.
ON: Define a condição para a junção das tabelas, destacando as chaves de relacionamento entre elas.
WHERE: Filtra os dados consultados.
GROUP BY: Agrupa dados que compartilham um valor específico.
HAVING: Filtra os dados após o agrupamento feito pelo GROUP BY.
SELECT: Seleciona as colunas de uma tabela.
DISTINCT: Remove linhas com dados duplicados.
ORDER BY: Ordena o conjunto de dados consultados.
LIMIT: Restringe o número de linhas retornadas no resultado final.

Há vários motivos para ressaltar a importância da ordem de execução, e abaixo destaco alguns deles:

Otimização de Consultas: Um exemplo interessante é o uso de filtros. Sabendo que as cláusulas JOIN e ON são processadas antes do WHERE, é possível utilizá-las para restringir dados já na etapa de junção, reduzindo a necessidade de filtros adicionais na cláusula WHERE.
Previsibilidade dos Resultados: Compreender a ordem de execução permite prever com precisão o resultado da consulta, o que ajuda a garantir que os dados recuperados sejam exatamente os desejados, sem surpresas ou inconsistências.
Estruturação de Consultas Complexas: Em consultas mais complexas, entender a ordem de execução auxilia na organização da estrutura da consulta, assegurando que cada etapa seja processada no momento apropriado.

Qual a diferença de Encadeamento de Promises e Aync/await

Kauan Amorim da Silva — Tue, 12 Nov 2024 19:51:04 +0000

Hoje me deparei com a minha própria ignorância sobre a diferença entre essas duas formas de lidar com operações assíncronas, então decidi ler e pesquisar para escrever esse post — como um lembrete para mim e, quem sabe, ajudar outros desenvolvedores a entender melhor essa diferença.

Na época, eu sabia mais ou menos explicar que ambas fazem a mesma coisa, com o then() trazendo os dados resolvidos, enquanto resolve e reject eram usados para finalizar com sucesso ou erro. Já o async/await tinha o await para esperar o resultado antes de seguir para o próximo passo. Não estava completamente errado, mas dava para explicar de uma forma bem melhor.

Promise

A Promise, como o nome sugere, é uma "promessa" de retorno de dados que passa por três estados principais:

Pending: Estado inicial, quando a promessa ainda não foi resolvida ou rejeitada.
Fulfilled: A operação foi concluída com sucesso.
Rejected: A operação falhou e o erro foi capturado.

const minhaPromise = new Promise((resolve, reject) => {
  let sucesso = true; // Apenas um exemplo condicional

  if (sucesso) {
    resolve("Operação concluída com sucesso!");
  } else {
    reject("Ocorreu um erro na operação.");
  }
});

Encadeamento de Promises

Essa era a forma mais comum de lidar com Promises antes do async/await. Usamos os métodos then(), catch() e finally().

then(): Usado para receber e manipular o dado resolvido com sucesso.
catch(): Usado para lidar com o erro quando a promessa é rejeitada.
finally(): Usado para executar um código independente do resultado.

minhaPromise
  .then((mensagem) => {
    console.log(mensagem); // "Operação concluída com sucesso!"
  })
  .catch((erro) => {
    console.error(erro); // Se der erro, isso será executado.
  })
  .finally(() => {
    console.log("Finalizando a execução da Promise"); // Sempre será executado.
  });

Async/Await

Uma função marcada como async retorna automaticamente uma Promise, e o await é usado para "pausar" a execução até que a Promise seja resolvida.

async function buscarDados() {
  try {
    const response = await fetch("https://jsonplaceholder.typicode.com/todos/1");
    const data = await response.json();
    console.log("Dados recebidos:", data);
  } catch (error) {
    console.error("Erro ao buscar dados:", error);
  }
}

buscarDados();

A Diferença

O encadeamento de Promises pode fazer com que o código fique muito aninhado, especialmente quando usamos vários then() seguidos, tornando a leitura mais difícil.

Já o async/await permite escrever código assíncrono de uma maneira mais parecida com o código síncrono, facilitando a leitura e a compreensão da lógica. O código fica mais limpo, especialmente quando precisamos lidar com várias operações assíncronas.

Além disso, a forma de tratar erros usando try/catch com async/await é mais intuitiva do que usar apenas o catch nas Promises.

Pesquisando conteúdo de arquivos - Série Linux

Kauan Amorim da Silva — Mon, 21 Aug 2023 20:35:31 +0000

Muitas vezes quando estamos procurando um arquivo e queremos algo em seu conteudo usamos o comando cat. Porém esse mesmo comando nos da todo o conteúdo do arquivo e passamos muito tempo dando scroll no terminal para achar o que estamos procurando.

Para conseguirmos filtrar o conteúdo do arquivo, pesquisando o que estamos procurando, podemos utilizar o grep. Esse comando nos ajudar a pesquisar tanto em arquivos, diretórios e subdiretórios o conteúdo procurado.

Exemplo de comando CAT.

# cat [option] <filename>

cd ~                  # entramos na pasta home
mkdir cat-test        # criamos uma pasta teste
cd cat-test           # entramos na pasta teste
cp /etc/services .    # copiamos o arquivo services da nossa máquina
cat services          # usamos o cat para pegar o conteúdo do arquivo services

Exemplo de comando GREP.

# grep [option] <search-value> <where-to-look>

cd ~                 # entramos na pasta home
mkdir grep-test      # criamos uma pasta teste
cd grep-test         # entramos na pasta teste
cp /etc/services .   # copiamos o arquivo services da nossa máquina.
cp /etc/passwd .     # copiamos o arquivo passwd da nossa máquina.
grep http *          # pesquisamos http em qualquer arquivo do diretório corrente.
                                         # será listado o conteúdo dos arquivos que tem a palavra http.

Options

Logo após escrevermos o nome do comando, podemos colocar uma de suas opções de execução e aqui serão descritas algumas dessas opções (-i -l -L -r).

-i | --ignore-case

Essa opção faz com que a pesquisa do grep ignore o case sensitive (case insensitive).

# grep [option] <search-value> <where-to-look>

cd ~                # entramos na pasta home
mkdir grep-test     # criamos uma pasta teste
cd grep-test        # entramos na pasta teste
cp /etc/services .  # copiamos o arquivo services da nossa máquina.
cp /etc/passwd .    # copiamos o arquivo passwd da nossa máquina.
grep -i http *      # pesquisamos http em qualquer arquivo do diretório corrente.
                                        # será listado o conteúdo dos arquivos que tem a palavra http sem case sensitive.

-l | --file-with-matches

Essa opção faz com que sejam listados os arquivos que contém o conteúdo procurado.

# grep [option] <search-value> <where-to-look>

cd ~                # entramos na pasta home
mkdir grep-test     # criamos uma pasta teste
cd grep-test        # entramos na pasta teste
cp /etc/services .  # copiamos o arquivo services da nossa máquina.
cp /etc/passwd .    # copiamos o arquivo passwd da nossa máquina.
grep -l http *      # pesquisamos http em qualquer arquivo do diretório corrente.
                                        # será listado os arquivos que tem o valor pesquisado.

-L --files-without-match

Essa opção faz com que sejam listados os arquivos que não contém o conteúdo procurado.

# grep [option] <search-value> <where-to-look>

cd ~                # entramos na pasta home
mkdir grep-test     # criamos uma pasta teste
cd grep-test        # entramos na pasta teste
cp /etc/services .  # copiamos o arquivo services da nossa máquina.
cp /etc/passwd .    # copiamos o arquivo passwd da nossa máquina.
grep -L http *      # pesquisamos http em qualquer arquivo do diretório corrente.
                                        # será listado os arquivos que não tem o valor pesquisado.

-r | --recursive

Essa opção faz com que o que for pesquisado, não se limite ao diretório corrente, mas que consiga pesquisar em subdiretórios.

# grep [option] <search-value> <where-to-look>

cd ~                             # entramos na pasta home
mkdir grep-test                  # criamos uma pasta teste
cd grep-test                     # entramos na pasta teste
cp /etc/services .               # copiamos o arquivo services da nossa máquina.
cp /etc/passwd .                 # copiamos o arquivo passwd da nossa máquina.
mkdir sub                        # criamos a pasta sub
cp /etc/services ./sub/          # copiamos novamente o arquivo services, mas agora para a pasta sub
grep -r http *                   # pesquisamos http em qualquer arquivo do diretório corrente e subdiretórios.
                                                     # será listado o conteúdo dos arquivos que tem o valor pesquisado, tanto arquivos do diretório atual quanto em subdiretórios.

Listando arquivos e diretórios de forma mais eficiente - Série Linux

Kauan Amorim da Silva — Thu, 27 Jul 2023 03:31:46 +0000

Na continuação dessa série iremos falar de um dos comandos mais populares do linux o ls esse comando é bem interessante por suas opções e como elas podem ser de grande ajuda quando você está só tem a linha de comando disponível.

Para quem não conhece o comando ls é o comando de listagem, ele lista todos os arquivos e diretórios do diretório corrente.

Para começar irei discorrer o que muitos já sabem até outros comandos que para alguns podem ser comum, mas para outros seja uma novidade.

ls

cd ~      # Entrando na pasta home.
ls        # Lista arquivos e diretórios no diretório corrente.

Detalhando a listagem

ls -a

Com essa opção são listados os arquivos ocultados, o diretório atual (simbolizado por .) e o diretório anterior (simbolizado por ..).

cd ~      # Entrando na pasta home.
ls -a     # Lista arquivos e diretórios ocultos.

ls -l

Essa opção irá listar as permissões, quem criou, quem alterou, tamanho e data de alteração do arquivo.

cd ~      # Entrando na pasta home.
ls -l     # Lista arquivos e diretórios com seus detalhes

ls -s

Essa opção irá mostrar ao lado do nome do arquivo/diretório o tamanha em KB do mesmo.

cd ~      # Entrando na pasta home.
ls -s     # Lista arquivos e diretórios mostrando seus KB

Ordenando a listagem

ls -S

Essa opção ordena os arquivos/diretórios pelo tamanho.

cd ~      # Entrando na pasta home.
ls -S     # Lista arquivos/diretórios ordenando por seus KB

ls -t

Essa opção ordena os arquivos/diretórios pela data e horá mais recente de alteração.

cd ~      # Entrando na pasta home.
ls -t     # Lista arquivos/diretórios ordenando pela data e hora mais recente de alteração mais recente.

Listando com coringas 🃏

?

O ponto de interrogação é bem simples, ele representa um caractere e pode ser qualquer caractere.

Digamos que temos os arquivos:

arq1 arq2 arq3 arq4 arq5 arq01 arq02 arq03 arq04 arq05 arq10 arq20 arq30 arq40 arq50

ls arq? #será lista todos os arquivos que tenham arq e um caractere amais.
# resultado: arq1  arq2  arq3  arq4  arq5

*

Esse coringa qualquer coisa, qualquer caractere e qualquer quantidade do mesmo.

Digamos que temos os arquivos:
arquivo arqdhdtrhdrdvo arq1 arq2 arq3

ls arq*vo # Esse comando indica que entre o **q** e o **v** pode ter qualquer caractere e qualquer quantidade de caractere.
# resultado: arquivo arqdhdtrhdrdvo

[1-5]

Esse coringa determina o range de possibilidades.

Digamos que temos os arquivos:
arq1 arq2 arq3 arq4 arq5 arq01 arq02 arq03 arq04 arq05 arq10 arq20 arq30 arq40 arq50

ls arq[1-5] # irá listar todos os arquivos arq que tenha um caractere de 1 a 5.
# resultado: arq1  arq2  arq3  arq4  arq5

[a, A]

Esse coringa determina as possibilidades que podemos ter, ele é muito parecido com o de range de possibilidades.

Digamos que temos os arquivos:

arq1 arq2 arq3 arq4 arq5 Arq6 Arq7 Arq8 Arq9

ls arq? # só listara os arquivos arq e não os Arq
#resultado: arq1 arq2 arq3 arq4 arq5

ls [a,A]rq? #listara todos os arquivos arq e Arq
#resultado: arq1 arq2 arq3 arq4 arq5 Arq6 Arq7 Arq8 Arq9

Exibindo conteúdo na linha de comando - Série Linux

Kauan Amorim da Silva — Wed, 26 Jul 2023 00:33:08 +0000

Uma das coisas mais comuns quando se está usando um sistema operacional linux, acessando um container ou até mesmo acessando um servidor é exibir o conteúdo de um arquivo.

Nesse artigo irei te passar alguns comandos e algumas opções interessantes para serem usadas com eles.

Comandos:

cat
more
less
head
tail

cat

Esse comando não serve somente para exibir o conteúdo de um arquivo, mas ele é um dos mais comuns para se fazer isso, o cat veio de concatenar e você consegue concatenar o conteúdo de diversos arquivos diferentes em um único output.

# cat [option] <filename>

cd ~                  # entramos na pasta home
mkdir cat-test        # criamos uma pasta teste
cd cat-test           # entramos na pasta teste
cp /etc/services .    # copiamos o arquivo services da nossa máquina
cat services          # usamos o cat para pegar o conteúdo do arquivo services

O comando more pega todo o conteúdo de um arquivo, porém ele cria uma certa páginação do arquivo, exibindo em porcentagem o quando já foi exibido do arquivo.

Para se locomover no conteúdo exibido, basta usar as setas do teclado e para sair da exibição do conteúdo basta usar a tecla q de quit.

# more [option] <filename>

cd ~                  # entramos na pasta home
mkdir cat-test        # criamos uma pasta teste
cd cat-test           # entramos na pasta teste
cp /etc/services .    # copiamos o arquivo services da nossa máquina
more services         # usamos o more para pegar parte do conteúdo do arquivo services

less

O comando less é muito parecido com o comando more a única diferença entre os dois é que o less não mostra a porcentagem de conteúdo já exibído.

# less [option] <filename>

cd ~                  # entramos na pasta home
mkdir cat-test        # criamos uma pasta teste
cd cat-test           # entramos na pasta teste
cp /etc/services .    # copiamos o arquivo services da nossa máquina
less services         # usamos o cat para pegar parte do conteúdo do arquivo services

HEAD | TAIL

Os comandos são opostos um do outro, o comando head exibe as 10 primeiras linhas do conteúdo de um arquivo e o comando tail exibe as 10 últimas linhas de um arquivo.

HEAD

# head [option] <filename>

cd ~                  # entramos na pasta home
mkdir cat-test        # criamos uma pasta teste
cd cat-test           # entramos na pasta teste
cp /etc/services .    # copiamos o arquivo services da nossa máquina
head services         # usamos o head para pegar as 10 primeiras linhas do arquivo services

TAIL

# tail [option] <filename>

cd ~                  # entramos na pasta home
mkdir cat-test        # criamos uma pasta teste
cd cat-test           # entramos na pasta teste
cp /etc/services .    # copiamos o arquivo services da nossa máquina
tail services         # usamos o head para pegar as 10 últimas linhas do arquivo services

-n | --lines

Essa opção é usada para alterar o número de linhas exibida na execução do comando (funciona tanto para head e tail).

# head [option] <filename>
# tail [option] <filename>

cd ~                  # entramos na pasta home
mkdir cat-test        # criamos uma pasta teste
cd cat-test           # entramos na pasta teste
cp /etc/services .    # copiamos o arquivo services da nossa máquina
head -n 3 services    # usamos o head para pegar as 3 primeiras linhas do arquivo services
tail -n 3 services    # usamos o head para pegar as 3 últimas linhas do arquivo services