DEV Community: Isaias Velasquez

How to versionar o banco de dados com Flyway sem medo

Isaias Velasquez — Sat, 11 Jul 2026 22:08:04 +0000

Flyway versiona o schema do banco de dados da mesma forma que o Git versiona o codigo fonte. Cada migracao e um arquivo SQL que o Flyway executa na ordem certa.

Adicione a dependencia no build.gradle.kts:

implementation("org.flywaydb:flyway-core")
runtimeOnly("org.flywaydb:flyway-database-postgresql")

Com Spring Boot, a configuracao e simples:

# application.properties
spring.flyway.enabled=true
spring.flyway.locations=classpath:db/migration

Crie o primeiro arquivo de migracao em src/main/resources/db/migration/V1__criar_tabela_usuarios.sql:

CREATE TABLE usuarios (
    id BIGSERIAL PRIMARY KEY,
    nome VARCHAR(100) NOT NULL,
    email VARCHAR(150) UNIQUE NOT NULL,
    criado_em TIMESTAMP DEFAULT NOW()
);

A segunda migracao V2__adicionar_coluna_telefone.sql:

ALTER TABLE usuarios ADD COLUMN telefone VARCHAR(20);

O padrao de nome e V{numero}__{descricao}.sql. O Flyway executa em ordem numerica e nunca repete o mesmo arquivo.

Para rodar as migracoes manualmente:

./gradlew flywayMigrate

Para ver o status:

./gradlew flywayInfo

Isso mostra quais migracoes ja foram aplicadas e quais estao pendentes.

Flyway cria uma tabela chamada flyway_schema_history no banco. Ela registra cada migracao executada:

SELECT version, description, installed_on, success
FROM flyway_schema_history;

Se uma migracao falha, o Flyway marca como falha e nao continua. Voce precisa corrigir o erro e rodar flywayRepair antes de tentar de novo.

Para migracoes irreversiveis, adicione o script de rollback separadamente:

# V3__adicionar_tabela_pedidos.sql
CREATE TABLE pedidos (
    id BIGSERIAL PRIMARY KEY,
    usuario_id BIGINT REFERENCES usuarios(id),
    total DECIMAL(10,2) NOT NULL,
    criado_em TIMESTAMP DEFAULT NOW()
);

# V3.1__rollback_V3.sql
DROP TABLE IF EXISTS pedidos;

O Flyway nao executa rollbacks automaticamente. Mas ter o script pronto ajuda em emergencias.

Para ambientes com dados reais, nunca altere migracoes ja executadas. Crie uma nova migracao:

-- ERRADO: alterar V2__adicionar_coluna_telefone.sql depois de rodar
-- CERTO: criar V4__alterar_coluna_telefone.sql

ALTER TABLE usuarios ALTER COLUMN telefone TYPE VARCHAR(30);

Voce pode usar Flyway com SQL puro ou com Java para logicas complexas. Mas SQL puro e mais simples e funciona em qualquer banco.

That's all for now.
Thanks for reading!

How to criar indices no SQL que realmente fazem diferenca

Isaias Velasquez — Sat, 11 Jul 2026 22:07:40 +0000

Ter um indice certo pode fazer uma query ir de 10 segundos para milissegundos. Mas indices demais ou errados atrapalham mais que ajudam.

O comando basico para criar um indice:

CREATE INDEX idx_clientes_email ON clientes(email);

Isso acelera buscas por email. Sem o indice, o banco faz uma varredura completa na tabela.

Para indices compostos (mais de uma coluna):

CREATE INDEX idx_pedidos_cliente_data ON pedidos(cliente_id, data_criacao);

A ordem das colunas importa. Esse indice ajuda queries que filtram por cliente_id ou por cliente_id + data_criacao. Mas nao ajuda queries que filtram so por data_criacao.

Para ver se uma query esta usando indice, use EXPLAIN:

EXPLAIN ANALYZE SELECT * FROM clientes WHERE email = 'joao@email.com';

O resultado mostra se o banco fez um Index Scan (bom) ou Seq Scan (ruim).

Indices parciais sao otimos para filtrar um subconjunto especifico:

CREATE INDEX idx_pedidos_pendentes ON pedidos(status)
WHERE status = 'pendente';

Se voce sempre busca pedidos pendentes, esse indice e muito menor que um indice completo.

Indices unicos garantem que nao ha valores duplicados:

CREATE UNIQUE INDEX idx_cpf_unico ON clientes(cpf);

Isso e equivalente a uma constraint UNIQUE, mas explicito como indice.

Para buscas de texto parcial (LIKE), use indices com varchar_pattern_ops:

CREATE INDEX idx_clientes_nome ON clientes(nome varchar_pattern_ops);

Isso acelera consultas como WHERE nome LIKE 'Silva%'.

Indices em tabelas grandes tem custo: eles desaceleram INSERT, UPDATE e DELETE. Cada vez que voce insere uma linha, o banco atualiza todos os indices.

Para monitorar indices nao usados:

SELECT 
    schemaname,
    tablename,
    indexname,
    idx_scan,
    idx_tup_read,
    idx_tup_fetch
FROM pg_stat_user_indexes
ORDER BY idx_scan ASC
LIMIT 10;

Indices com idx_scan baixo sao candidatos a remocao.

Uma dica pratica: indices em colunas com baixa cardinalidade (como status com 3 valores possiveis) raramente ajudam. O banco prefere ler a tabela toda em vez de usar o indice.

Para colunas booleanas ou de poucos valores, indices parciais sao a melhor opcao.

That's all for now.
Thanks for reading!

How to usar CTEs para consultas SQL mais legiveis

Isaias Velasquez — Sat, 11 Jul 2026 22:07:11 +0000

CTEs (Common Table Expressions) tornam consultas SQL mais legiveis ao dividir logicas complexas em blocos nomeados. E como criar variaveis temporarias dentro da query.

A sintaxe basica:

WITH vendas_recentes AS (
    SELECT * FROM vendas WHERE data >= '2025-01-01'
)
SELECT cliente_id, SUM(valor) as total
FROM vendas_recentes
GROUP BY cliente_id
ORDER BY total DESC;

O WITH define um bloco temporario chamado vendas_recentes. A query principal usa esse bloco como se fosse uma tabela.

CTEs sao uteis para reutilizar a mesma subconsulta em varios lugares:

WITH gastos_por_cliente AS (
    SELECT cliente_id, SUM(valor) as total_gasto
    FROM vendas
    GROUP BY cliente_id
)
SELECT 
    c.nome,
    g.total_gasto,
    CASE 
        WHEN g.total_gasto > 1000 THEN 'VIP'
        ELSE 'normal'
    END as categoria
FROM clientes c
JOIN gastos_por_cliente g ON c.id = g.cliente_id
ORDER BY g.total_gasto DESC;

Sem CTE, voce teria que repetir o SUM(valor) ou criar uma view.

CTEs recursivas permitem trabalhar com dados hierarquicos como arvores de categorias:

WITH RECURSIVE subcategorias AS (
    SELECT id, nome, parent_id, 1 as nivel
    FROM categorias
    WHERE parent_id IS NULL

    UNION ALL

    SELECT c.id, c.nome, c.parent_id, s.nivel + 1
    FROM categorias c
    JOIN subcategorias s ON c.parent_id = s.id
)
SELECT * FROM subcategorias ORDER BY nivel, nome;

A parte antes do UNION ALL e o caso base (categorias raiz). A parte depois e a recursao que busca os filhos. O nivel controla a profundidade.

Para calcular o total de vendas com crescimento mes a mes:

WITH vendas_por_mes AS (
    SELECT 
        DATE_TRUNC('month', data) as mes,
        SUM(valor) as total_mes
    FROM vendas
    GROUP BY DATE_TRUNC('month', data)
),
com_diferenca AS (
    SELECT 
        mes,
        total_mes,
        LAG(total_mes) OVER (ORDER BY mes) as mes_anterior,
        total_mes - LAG(total_mes) OVER (ORDER BY mes) as crescimento
    FROM vendas_por_mes
)
SELECT 
    mes,
    total_mes,
    COALESCE(crescimento, 0) as crescimento
FROM com_diferenca
ORDER BY mes;

Multiplas CTEs sao separadas por virgula. Cada uma pode referenciar as anteriores.

Para encontrar o caminho entre dois usuarios em uma rede social:

WITH RECURSIVE conexoes AS (
    SELECT usuario1, usuario2, array[usuario1, usuario2] as caminho
    FROM amizades
    WHERE usuario1 = 1

    UNION ALL

    SELECT a.usuario1, a.usuario2, c.caminho || a.usuario2
    FROM amizades a
    JOIN conexoes c ON a.usuario1 = c.usuario2
    WHERE NOT a.usuario2 = ANY(c.caminho)
)
SELECT * FROM conexoes WHERE usuario2 = 10;

CTEs nao sao sempre a opcao mais rapida. O banco pode otimizar subconsultas simples melhor que CTEs. Mas para legibilidade, CTEs ganham sempre.

That's all for now.
Thanks for reading!

How to usar window functions para resolver em uma query

Isaias Velasquez — Sat, 11 Jul 2026 22:06:24 +0000

Window functions resolvem em uma unica query problemas que antes exigiam subconsultas ou joins complicados. Elas calculam valores baseados em um conjunto de linhas relacionadas sem agrupar o resultado.

A sintaxe basica com ROW_NUMBER:

SELECT 
    nome,
    departamento,
    salario,
    ROW_NUMBER() OVER (PARTITION BY departamento ORDER BY salario DESC) as posicao
FROM funcionarios;

Isso numero cada funcionario dentro do seu departamento, ordenado por salario. O PARTITION BY divide as linhas em grupos. O ORDER BY define a ordem dentro de cada grupo.

Para pegar os 3 maiores salarios de cada departamento:

WITH ranked AS (
    SELECT 
        nome,
        departamento,
        salario,
        ROW_NUMBER() OVER (PARTITION BY departamento ORDER BY salario DESC) as pos
    FROM funcionarios
)
SELECT * FROM ranked WHERE pos <= 3;

RANK e DENSE_RANK sao variantes que lidam com empates:

SELECT 
    nome,
    departamento,
    salario,
    RANK() OVER (ORDER BY salario DESC) as rank,
    DENSE_RANK() OVER (ORDER BY salario DESC) as dense_rank
FROM funcionarios;

RANK pula numeros em caso de empate (1, 1, 3). DENSE_RANK nao pula (1, 1, 2).

Para calcular totais acumulados:

SELECT 
    data,
    valor,
    SUM(valor) OVER (ORDER BY data) as acumulado
FROM vendas
ORDER BY data;

A SUM com OVER sem PARTITION BY calcula o total acumulado desde o inicio.

Para comparar um valor com a linha anterior:

SELECT 
    data,
    valor,
    LAG(valor, 1) OVER (ORDER BY data) as valor_anterior,
    valor - LAG(valor, 1) OVER (ORDER BY data) as diferenca
FROM vendas
ORDER BY data;

LAG olha para tras. LEAD olha para frente. O segundo parametro e quantas linhas pular.

Para media movel de 7 dias:

SELECT 
    data,
    valor,
    AVG(valor) OVER (ORDER BY data ROWS BETWEEN 6 PRECEDING AND CURRENT ROW) as media_movel_7d
FROM vendas;

O ROWS BETWEEN define a janela. 6 PRECEDING pega as 6 linhas anteriores. CURRENT ROW e a linha atual.

Para percentual de cada venda dentro do total:

SELECT 
    produto,
    valor,
    valor / SUM(valor) OVER () * 100 as percentual
FROM vendas;

Sem PARTITION BY, a SUM considera todas as linhas.

Window functions sao mais performaticas que subconsultas equivalentes. O banco processa tudo em um unico scan dos dados.

That's all for now.
Thanks for reading!

How to fazer deploy do Spring Boot com Docker sem dor de cabeca

Isaias Velasquez — Sat, 11 Jul 2026 22:04:27 +0000

Spring Boot e Docker juntos fazem o deploy ser uma tarefa simples. Com um Dockerfile bem feito, voce empacota a aplicacao e roda em qualquer ambiente sem surpresas.

O Dockerfile basico para uma aplicacao Spring Boot com Java 21:

FROM eclipse-temurin:21-jdk-alpine AS builder
WORKDIR /app
COPY gradlew gradlew.bat build.gradle.kts settings.gradle.kts ./
COPY gradle gradle
RUN ./gradlew dependencies
COPY src src
RUN ./gradlew bootJar -x test

FROM eclipse-temurin:21-jre-alpine
WORKDIR /app
COPY --from=builder /app/build/libs/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

O primeiro stage compila o projeto. O segundo stage copia so o JAR. A imagem final e pequena porque nao tem Gradle nem JDK.

Para construir:

docker build -t minha-api .
docker run -p 8080:8080 minha-api

Para passar properties externas no docker run:

docker run -p 8080:8080 \
    -e SPRING_PROFILES_ACTIVE=prod \
    -e APP_DB_URL=jdbc:postgresql://host.docker.internal:5432/db \
    minha-api

Variaveis de ambiente sobrescrevem as properties do application.properties.

Para usar Docker Compose com banco de dados:

version: '3.8'
services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      SPRING_PROFILES_ACTIVE: prod
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/meubanco
      SPRING_DATASOURCE_USERNAME: app
      SPRING_DATASOURCE_PASSWORD: ${DB_PASSWORD}
    depends_on:
      db:
        condition: service_healthy

  db:
    image: postgres:16
    environment:
      POSTGRES_DB: meubanco
      POSTGRES_USER: app
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app -d meubanco"]
      interval: 5s
      timeout: 3s
      retries: 5
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

O depends_on com condition: service_healthy garante que o banco esteja pronto antes da aplicacao iniciar.

Para imagens ainda menores, use JRE slim ou distroless:

FROM eclipse-temurin:21-jre-alpine
RUN addgroup -S app && adduser -S app -G app
USER app
COPY --from=builder /app/build/libs/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

Executar a aplicacao como usuario nao root e uma boa pratica de seguranca.

Para multiplos profiles de Docker Compose:

# docker-compose.override.yml (ambiente local)
services:
  app:
    environment:
      SPRING_PROFILES_ACTIVE: dev

# docker-compose.prod.yml (producao)
services:
  app:
    environment:
      SPRING_PROFILES_ACTIVE: prod
    restart: always

Uso: docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d.

That's all for now.
Thanks for reading!

How to fazer exception handling limpo com ControllerAdvice

Isaias Velasquez — Sat, 11 Jul 2026 22:02:06 +0000

@ControllerAdvice e a forma mais limpa de centralizar o tratamento de erros em uma aplicacao Spring Boot. Em vez de espalhar try/catch por todos os controllers, voce trata tudo em um lugar so.

Crie uma classe com @ControllerAdvice:

@ControllerAdvice
class GlobalExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException::class)
    fun handleNotFound(ex: ResourceNotFoundException, request: WebRequest):
            ResponseEntity<Map<String, Any>> {
        val body = mapOf(
            "error" to "Not Found",
            "message" to ex.message,
            "status" to 404
        )
        return ResponseEntity(body, HttpStatus.NOT_FOUND)
    }

    @ExceptionHandler(MethodArgumentNotValidException::class)
    fun handleValidation(ex: MethodArgumentNotValidException):
            ResponseEntity<Map<String, Any>> {
        val erros = ex.bindingResult.fieldErrors.map {
            "${it.field}: ${it.defaultMessage}"
        }
        val body = mapOf(
            "error" to "Validation Failed",
            "details" to erros,
            "status" to 400
        )
        return ResponseEntity(body, HttpStatus.BAD_REQUEST)
    }
}

Crie excecoes customizadas:

class ResourceNotFoundException(message: String) : RuntimeException(message)
class BusinessException(message: String) : RuntimeException(message)

Uso no controller:

@RestController
class UsuarioController(private val service: UsuarioService) {

    @GetMapping("/usuarios/{id}")
    fun buscar(@PathVariable id: Long): ResponseEntity<Usuario> {
        val usuario = service.buscarPorId(id)
            ?: throw ResourceNotFoundException("Usuario $id nao encontrado")
        return ResponseEntity.ok(usuario)
    }
}

Quando o usuario nao existe, o ResourceNotFoundException e lancado. O GlobalExceptionHandler captura e retorna um JSON limpo.

Para validacao de entrada com @Valid:

data class CriarUsuarioRequest(
    @field:NotBlank val nome: String,
    @field:Email val email: String,
    @field:Min(18) val idade: Int
)

@PostMapping("/usuarios")
fun criar(@Valid @RequestBody request: CriarUsuarioRequest): ResponseEntity<Usuario> {
    val usuario = service.criar(request)
    return ResponseEntity(usuario, HttpStatus.CREATED)
}

Se a validacao falha, o MethodArgumentNotValidException e lancado e o handler devolve os erros campo a campo.

Para excecoes genericas nao mapeadas:

@ExceptionHandler(Exception::class)
fun handleGeneric(ex: Exception): ResponseEntity<Map<String, Any>> {
    val body = mapOf(
        "error" to "Internal Server Error",
        "message" to (ex.message ?: "Erro inesperado"),
        "status" to 500
    )
    return ResponseEntity(body, HttpStatus.INTERNAL_SERVER_ERROR)
}

Monte a resposta padrao em uma data class:

data class ErrorResponse(
    val error: String,
    val message: String?,
    val status: Int,
    val timestamp: Long = System.currentTimeMillis()
)

@ExceptionHandler(BusinessException::class)
fun handleBusiness(ex: BusinessException): ResponseEntity<ErrorResponse> {
    val body = ErrorResponse(
        error = "Business Error",
        message = ex.message,
        status = 422
    )
    return ResponseEntity(body, HttpStatus.UNPROCESSABLE_ENTITY)
}

Para mais de um tipo de excecao no mesmo handler:

@ExceptionHandler(IOException::class, DataAccessException::class)
fun handleInfra(ex: Exception): ResponseEntity<ErrorResponse> {
    return ResponseEntity(
        ErrorResponse("Infra Error", ex.message, 503),
        HttpStatus.SERVICE_UNAVAILABLE
    )
}

Com @ControllerAdvice voce tem um unico ponto de tratamento de erros. O codigo dos controllers fica limpo e as respostas de erro seguem um padrao consistente.

That's all for now.
Thanks for reading!

How to usar Testcontainers para testes de integracao que prestam

Isaias Velasquez — Sat, 11 Jul 2026 21:59:59 +0000

Testcontainers e uma biblioteca que sobe containers Docker dentro dos seus testes de integracao. Em vez de mockar o banco de dados, voce usa um banco de verdade que nasce e morre com o teste.

Adicione a dependencia no build.gradle.kts:

testImplementation("org.testcontainers:testcontainers:1.20.0")
testImplementation("org.testcontainers:postgresql:1.20.0")
testImplementation("org.testcontainers:junit-jupiter:1.20.0")

O teste mais simples com PostgreSQL:

@Testcontainers
@SpringBootTest
class UsuarioRepositoryTest {

    companion object {
        @Container
        val postgres = PostgreSQLContainer<Nothing>("postgres:16").apply {
            withDatabaseName("testdb")
            withUsername("test")
            withPassword("test")
        }
    }

    @Autowired
    lateinit var repo: UsuarioRepository

    @Test
    fun deveSalvarUsuario() {
        val usuario = Usuario(nome = "Joao", email = "joao@email.com")
        val salvo = repo.save(usuario)
        assertThat(salvo.id).isNotNull()
    }
}

O Testcontainers sobe um container PostgreSQL antes dos testes e derruba depois. Nao precisa de banco instalado na maquina.

Para configurar o Spring Boot automaticamente:

@DynamicPropertySource
fun configurarProps(registry: DynamicPropertyRegistry) {
    registry.add("spring.datasource.url", postgres::getJdbcUrl)
    registry.add("spring.datasource.username", postgres::getUsername)
    registry.add("spring.datasource.password", postgres::getPassword)
}

Isso substitui as properties do application.properties pela URL do container que acabou de subir.

Para Redis:

@Container
val redis = GenericContainer<Nothing>("redis:7").apply {
    withExposedPorts(6379)
}

@DynamicPropertySource
fun redisProps(registry: DynamicPropertyRegistry) {
    registry.add("spring.redis.host", redis::getHost)
    registry.add("spring.redis.port") { redis.getMappedPort(6379).toString() }
}

Testcontainers tambem suporta Kafka:

@Container
val kafka = KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:7.6.0"))

@DynamicPropertySource
fun kafkaProps(registry: DynamicPropertyRegistry) {
    registry.add("spring.kafka.bootstrap-servers", kafka::getBootstrapServers)
}

Para reaproveitar o container entre varios testes:

@Testcontainers
abstract class AbstractIntegrationTest {
    companion object {
        @Container
        val postgres = PostgreSQLContainer<Nothing>("postgres:16").apply {
            withDatabaseName("testdb")
            withUsername("test")
            withPassword("test")
            start()
        }

        @DynamicPropertySource
        @JvmStatic
        fun props(registry: DynamicPropertyRegistry) {
            registry.add("spring.datasource.url", postgres::getJdbcUrl)
            registry.add("spring.datasource.username", postgres::getUsername)
            registry.add("spring.datasource.password", postgres::getPassword)
        }
    }
}

Agora toda classe que estender AbstractIntegrationTest ganha um banco PostgreSQL real.

Dica: se os testes ficarem lentos, use withReuse(true) no container. Isso mantem o container vivo entre execucoes. So nao esqueca de configurar testcontainers.reuse.enable=true em ~/.testcontainers.properties.

That's all for now.
Thanks for reading!

How to externalizar properties no Spring Boot sem surpresas

Isaias Velasquez — Sat, 11 Jul 2026 21:59:32 +0000

Properties externalizadas sao uma das maiores vantagens do Spring Boot. Elas permitem mudar o comportamento da aplicacao sem recompilar nada.

O jeito mais comum e usar o application.properties:

# application.properties
app.nome=MeuServico
app.versao=1.0.0
server.port=8080

Para acessar no codigo:

@Service
class ConfigService {
    @Value("\${app.nome}")
    lateinit var nomeApp: String

    @Value("\${app.versao}")
    lateinit var versao: String

    fun mostrar() {
        println("$nomeApp - v$versao")
    }
}

Um problema comum: se a chave nao existe, o Spring lanca uma excecao na inicializacao. Para evitar isso, use valores default:

@Value("\${app.autor:desconhecido}")
lateinit var autor: String

Para ambientes diferentes, crie arquivos separados:

# application-dev.properties
server.port=8081
spring.datasource.url=jdbc:h2:mem:devdb

# application-prod.properties
server.port=80
spring.datasource.url=jdbc:postgresql://prod:5432/db

Ative o perfil com SPRING_PROFILES_ACTIVE ou --spring.profiles.active:

SPRING_PROFILES_ACTIVE=prod java -jar app.jar
java -jar app.jar --spring.profiles.active=dev

Properties tambem podem vir de variaveis de ambiente. O Spring Boot mapeia automaticamente:

# Variavel de ambiente
export APP_NOME=MeuApp

# No application.properties
app.nome=\${APP_NOME:default}

A configuracao externalizada segue uma ordem de precedencia. Variaveis de ambiente sobrescrevem application.properties, que sobrescrevem valores default.

Para grupos de properties, use @ConfigurationProperties:

# application.properties
app.mail.host=smtp.gmail.com
app.mail.port=587
app.mail.username=user@gmail.com

@ConfigurationProperties(prefix = "app.mail")
@Component
class MailProperties {
    var host: String = ""
    var port: Int = 587
    var username: String = ""
}

@Service
class MailService(private val props: MailProperties) {
    fun configurar() {
        println("SMTP: ${props.host}:${props.port}")
    }

}

O @ConfigurationProperties agrupa todas as properties com prefixo app.mail em um objeto tipado. Muito mais limpo que varios @Value.

Para usar arquivos YAML:

# application.yml
app:
  nome: MeuServico
  database:
    url: jdbc:postgresql://localhost:5432/db
    pool:
      max: 10
      min: 2

Properties de ultimo recurso: @PropertySource para carregar um arquivo especifico:

@Configuration
@PropertySource("classpath:config/custom.properties")
class CustomConfig

Nunca coloque senhas e chaves de API no application.properties. Use variaveis de ambiente ou um servico de secrets.

That's all for now.
Thanks for reading!

How to usar awk e sed no processamento de texto do dia a dia

Isaias Velasquez — Sat, 11 Jul 2026 21:59:08 +0000

awk e sed sao dois comandos classicos do Unix que continuam sendo uteis mesmo com ferramentas modernas. Eles processam texto linha por linha sem precisar de scripts grandes.

Sed e um editor de texto nao interativo. O uso mais comum e substituicao:

sed 's/antigo/novo/g' arquivo.txt

O s significa substituir, o g significa global (todas as ocorrencias na linha).

Para editar o arquivo direto:

sed -i 's/erro/ERRO/g' arquivo.txt

Substituir em multiplos arquivos:

sed -i 's/pagina2antiga/paginanova/g' *.html

Para deletar linhas que contem um padrao:

sed -i '/debug/d' arquivo.log

O d deleta a linha inteira.

Para mostrar apenas as linhas 10 a 20:

sed -n '10,20p' arquivo.txt

O -n suprime a saida padrao. O p imprime as linhas selecionadas.

Agora awk. Awk processa linhas como campos separados por espaco (ou outro delimitador):

awk '{print $1, $3}' arquivo.txt

Isso imprime o primeiro e terceiro campo de cada linha.

Para usar outro delimitador, como CSV:

awk -F',' '{print $1, $2}' dados.csv

Filtragem condicional:

awk '$3 > 100 {print $1, $3}' dados.txt
awk '/ERROR/ {print $1, $2, $NF}' sistema.log

O $NF e o ultimo campo da linha.

Um exemplo pratico com logs Docker:

docker logs meu-container | awk '/ERROR/ {print $1, $2, $NF}'

Para formatar saida de comandos:

ps aux | awk '{printf "%-10s %-6s %s\n", $1, $2, $11}'

Awk tambem faz contas:

awk '{soma += $3} END {print "Total:", soma}' valores.txt

O bloco END executa depois de processar todas as linhas.

Combinando awk e sed para limpar dados:

cat dados_sujos.csv | sed 's/"//g' | awk -F',' '{print $1, $2}'

Sed remove as aspas duplas. Awk extrai as duas primeiras colunas.

Awk e sed resolvem problemas de processamento de texto em uma linha onde linguagens como Python exigiriam um arquivo separado. Para tarefas rapidas no terminal, eles sao insubstituiveis.

That's all for now.
Thanks for reading!

How to criar aliases e funcoes no bash que viram costume

Isaias Velasquez — Sat, 11 Jul 2026 21:58:50 +0000

Aliases e funcoes no bash transformam comandos longos em atalhos de uma palavra. Depois que voce comeca a usar, nao volta mais.

Para criar um alias simples, adicione no ~/.bashrc ou ~/.bash_aliases:

alias ll='ls -la --color=auto'
alias gs='git status'
alias gc='git commit -m'
alias gp='git push'
alias dc='docker compose'
alias dps='docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Image}}"'

Recarregue com:

source ~/.bashrc

Aliases aceitam parametros no final. Para parametros no meio, use funcoes:

gmkdir() {
    mkdir -p "$1" && cd "$1"
}

Uso: gmkdir novo-projeto cria a pasta e ja entra nela.

Funcoes de busca frequente:

findtext() {
    grep -rn "$1" --include="*.py" --include="*.java" "$2" .
}

findfile() {
    find . -name "*$1*" 2>/dev/null
}

Uso: findtext "TODO" src/ ou findfile "Dockerfile".

Funcao para navegar rapido no Git:

gcob() {
    git checkout -b "$1" 2>/dev/null || git checkout "$1"
}

Uso: gcob main faz checkout para main. gcob feature/x cria e vai para o branch novo.

Para navegar entre projetos:

proj() {
    cd ~/projects/"$1" 2>/dev/null || echo "projeto nao encontrado"
}

compro() {
    compgen -W "$(ls ~/projects)" -- "$1"
}
complete -F compro proj

Agora proj meu-app ja leva para ~/projects/meu-app. O autocomplete via complete -F mostra a lista de projetos ao apertar Tab.

Funcao para backup rapido:

backup() {
    cp "$1"{,.bak}
}

Uso: backup config.yaml cria config.yaml.bak.

Mini calculadora no terminal:

calc() {
    echo "$*" | bc -l
}

Uso: calc "42 * 3.14 + 10".

Para extrair qualquer tipo de arquivo sem lembrar o comando:

extract() {
    case "$1" in
        *.tar.gz)  tar xzf "$1" ;;
        *.tar.bz2) tar xjf "$1" ;;
        *.zip)     unzip "$1" ;;
        *.rar)     unrar x "$1" ;;
        *.7z)      7z x "$1" ;;
        *)         echo "formato nao reconhecido" ;;
    esac
}

Coloque tudo em um arquivo separado como ~/.bash_aliases e mande source no ~/.bashrc:

if [ -f ~/.bash_aliases ]; then
    . ~/.bash_aliases
fi

Assim voce mantem os aliases organizados sem poluir o ~/.bashrc.

That's all for now.
Thanks for reading!

How to usar stash, bisect e worktree no Git

Isaias Velasquez — Sat, 11 Jul 2026 21:58:29 +0000

Git tem comandos que vao alem do commit e push. Tres deles salvam tempo em situacoes especificas: stash, bisect e worktree.

Stash guarda modificacoes nao commitadas para voce poder mudar de branch sem perder o trabalho:

echo "nova feature" > arquivo.txt
git stash push -m "WIP: comeco da feature"
git stash list
git stash pop

Para guardar apenas arquivos especificos:

git stash push -m "so mudancas no frontend" src/frontend/

Para ver o que tem dentro de um stash sem aplicar:

git stash show -p stash@{0}

Bisect faz busca binaria no historico para encontrar o commit que introduziu um bug:

git bisect start
git bisect bad       # versao atual esta quebrada
git bisect good v1.0 # versao v1.0 estava funcionando

O Git vai fazendo checkout nos commits do meio do caminho. Voce testa e marca:

git bisect good  # esse commit funciona
git bisect bad   # esse commit esta quebrado

Quando encontrar o commit culpado, o Git mostra a mensagem. Para sair:

git bisect reset

Da para automatizar com um script:

git bisect start HEAD v1.0
git bisect run python test_bug.py

O Git executa test_bug.py em cada commit. Se o script retorna 0, marca como good. Se retorna 1, marca como bad.

Worktree permite ter multiplos branches checked out ao mesmo tempo em pastas separadas:

git worktree add ../projeto-hotfix hotfix/urgente

Isso cria uma pasta projeto-hotfix ao lado do seu projeto com o branch hotfix/urgente ja checked out. Voce trabalha nos dois ao mesmo tempo sem precisar esconder nada com stash.

Para listar worktrees ativas:

git worktree list

Para remover uma worktree:

git worktree remove ../projeto-hotfix
git branch -d hotfix/urgente

Worktree e ideal para revisao de PR. Voce faz checkout do branch do PR em outra pasta, revisa, testa, e volta para seu branch sem perder contexto.

Stash resolve trocas rapidas de contexto. Bisect encontra bugs em minutos que levariam horas manualmente. Worktree elimina o atrito de alternar entre branches. Os tres juntos cobrem situacoes que o commit simples nao resolve.

That's all for now.
Thanks for reading!

How to turbinar o terminal com jq, fzf e ripgrep

Isaias Velasquez — Sat, 11 Jul 2026 21:58:14 +0000

jq, fzf e ripgrep sao tres ferramentas de terminal que mudaram a forma como trabalho com arquivos e dados. Cada uma resolve um problema especifico e juntas formam um trio poderoso.

Primeiro, ripgrep (rg). Ele substitui o grep tradicional com uma busca muito mais rapida e com sintaxe mais amigavel:

rg "funcao main" src/
rg "TODO|FIXME" --type py
rg "import" -l src/  # so nomes de arquivo
rg "case class" --ignore-case

Instale no Ubuntu ou WSL:

sudo apt install ripgrep

No macOS:

brew install ripgrep

O ripgrep respeita .gitignore por padrao. Nao precisa ficar excluindo node_modules ou target manualmente.

Agora fzf. E um fuzzy finder que deixa voce buscar e selecionar qualquer coisa no terminal de forma interativa:

history | fzf  # busca em comandos recentes
Ctrl+R no terminal ja usa fzf se configurado
Ctrl+T para buscar arquivos

Instale:

git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
~/.fzf/install

Depois de instalado, aperte Ctrl+R no terminal. Voce digita parte de um comando antigo e o fzf filtra e seleciona.

Combine fzf com ripgrep para buscar arquivos de forma inteligente:

rg --files | fzf

Para abrir um arquivo qualquer do projeto:

vim $(rg --files | fzf)

Ou com fd (outra ferramenta rapida para listar arquivos):

sudo apt install fd-find
vim $(fd . | fzf)

Agora jq. E um processador de JSON que roda no terminal. Perfeito para trabalhar com APIs:

curl https://api.github.com/repos/user/repo | jq '.stargazers_count'
curl https://api.github.com/repos/user/repo | jq '.name, .description'

Para extrair dados de uma lista:

curl https://api.github.com/users/octocat/repos | jq '.[] | .name'

Filtrar por condicao:

curl https://api.github.com/users/octocat/repos | jq '.[] | select(.language == "Python") | .name'

Formatar saida:

curl https://api.github.com/users/octocat/repos | jq '.[] | {nome: .name, estrelas: .stargazers_count}'

Instale:

sudo apt install jq
# ou
brew install jq

Juntando os tres. Aqui esta um exemplo pratico:

rg --files | fzf --preview 'bat --color=always {}'

Isso lista todos os arquivos do projeto com ripgrep, filtra interativamente com fzf e mostra uma pre-visualizacao com bat (outro substituto do cat com syntax highlight).

Para buscar dentro de logs JSON:

cat arquivo.log | jq 'select(.level == "ERROR") | .message' | fzf

Essas tres ferramentas sao instalacao obrigatoria em qualquer maquina que voce use para desenvolver.

That's all for now.
Thanks for reading!