DEV Community: Alexandre

Programar é uma arte

Alexandre — Tue, 23 Sep 2025 11:59:06 +0000

Assim como desenhar, programar é traduzir o mundo em outra linguagem.

Bons programadores, como bons artistas, não enxergam melhor, mas sabem organizar, escolher e representar melhor.

Índice

1. Introdução
2. Fundamentos
3. Fundamentos da arte
4. Fundamentos da programação
- 4.1. Lógica computacional
- 4.2. Estruturas de dados e algoritmos
- 4.3. Ferramental (Tooling)
- 4.4. Debugging e engenharia reversa
- 4.5. Abstração
6. Conclusão

1. Introdução

No início dos meus estudos em programação, sempre caminhei em paralelo com o estudo de desenho. Durante essa jornada, não pude deixar de traçar paralelos entre as duas áreas. O estudo do desenho sempre me pareceu ter um caminho claro: focar nos chamados fundamentos e praticar. Já na programação, sempre busquei identificar esses fundamentos, mas a definição nunca foi tão evidente.

Neste texto, pretendo explorar o que considero serem os fundamentos da programação.

2. Fundamentos

O que me encanta na ideia de fundamentos é que eles são tópicos inesgotáveis. Você pode estudá-los por toda a vida, e ainda assim haverá sempre mais a aprender. É como anatomia no desenho: você pode aprofundar infinitamente, desde o estudo dos ossos até a simplificação de formas para criar estilos exagerados ou minimalistas. Mas, para que o resultado seja intencional e convincente, precisa estar bem fundamentado.

Da mesma forma, um bom desenho ou um bom programa depende da aplicação equilibrada de vários fundamentos ao mesmo tempo. Dominar apenas um não garante um bom resultado final. Os fundamentos não são uma lista que se esgota, mas pontos de prática constante — como um boxeador que treina o mesmo soco todos os dias até que se torne instintivo.

3. Fundamentos da arte

Como este é um artigo focado em programação, muitos podem não ter tido contato com os fundamentos da arte. Então farei uma breve explicação para seguirmos:

Linhas: o elemento mais básico para definir contorno, forma e dar sensação de movimento.
Formas: blocos de construção de qualquer objeto, representados por figuras geométricas básicas como círculos, quadrados e triângulos. Simplificar a realidade em formas ajuda a construir o desenho de maneira mais precisa.
Perspectiva: permite criar a ilusão de profundidade e tridimensionalidade em uma superfície plana.
Anatomia: essencial para desenhar pessoas e animais de maneira realista e proporcional. É o estudo da estrutura corporal, músculos e ossos.
Composição: refere-se à organização visual dos elementos dentro do espaço. Envolve a disposição, o equilíbrio e a distribuição de objetos, cores e linhas para criar uma obra harmoniosa.

4. Fundamentos da programação

4.1. Lógica computacional

Capacidade de entender uma necessidade e transformá-la em um programa. Observe como um desenhista enxerga formas simples (círculos, quadrados) em uma figura complexa.

LINK

O programador deve ter a habilidade de enxergar processos complexos e representa-los de forma simplificada.

Exemplo: imagine um programador conversando com um cliente sobre um novo projeto. O cliente descreve um fluxo de contratação totalmente manual, que envolve diversos setores, diferentes níveis de permissão, etapas de aprovação, envio de e-mails e muitos outros detalhes.

O papel do programador é extrair, simplificar e organizar esses fluxos, transformando a descrição em um modelo compreensível. Só assim será possível apresentar ao cliente quais funcionalidades serão desenvolvidas e como elas vão funcionar.

4.2. Estruturas de dados e algoritmos

São formas de organizar e processar informações. Assim como um artista usa a composição para distribuir elementos em uma cena, o programador utiliza estruturas para dar ordem e eficiência aos dados.

Observe essas 2 artes

Na primeira arte, não há técnicas de composição evidentes; já na segunda, o olhar do observador é conduzido intencionalmente pelos elementos, seguindo o caminho que o artista planejou.

Da mesma forma, um programador deve saber escolher as estruturas de dados e algoritmos adequados para guiar o fluxo das informações. Usar um array para armazenar uma lista telefônica pode até funcionar, mas não será a decisão mais eficiente — nesse caso, uma estrutura de mapa permitiria buscas muito mais rápidas e organizadas.

// Lista telefônica usando Vec
let lista_telefonica = vec![
    ("Peter", "1111-1111"),
    ("Carlos", "2222-2222"),
    ("Jordan", "3333-3333"),
];

// Procurar telefone do Jordan em um Vec (O(n))
let mut telefone = None;
for (nome, numero) in &lista_telefonica {
    if *nome == "Jordan" {
        telefone = Some(*numero);
        break;
    }
}

println!("Telefone do Jordan (Vec): {:?}", telefone.unwrap());

// Lista telefônica usando HashMap
let mut lista_telefonica_map = HashMap::new();
lista_telefonica_map.insert("Peter", "1111-1111");
lista_telefonica_map.insert("Carlos", "2222-2222");
lista_telefonica_map.insert("Jordan", "3333-3333");

// Procurar telefone do Jordan em HashMap (O(1))
if let Some(numero) = lista_telefonica_map.get("Jordan") {
    println!("Telefone do Jordan (HashMap): {}", numero);
}

Dominar essas estruturas — e os algoritmos que as acompanham — é essencial para compor sistemas complexos. Cada estrutura tem pontos fortes e fracos, e saber quando aplicar cada uma delas é o que diferencia soluções simples de ótimas composições.

4.3. Ferramental (Tooling)

Assim como um artista que utiliza uma mesa digitalizadora consegue desenhar mais rápido, com maior precisão e explorar possibilidades criativas que seriam muito mais trabalhosas no papel, o programador também pode acelerar e ampliar sua capacidade ao dominar suas ferramentas.

O uso de LLMs para gerar código ou documentação, scripts de automação para eliminar tarefas repetitivas, Docker para garantir ambientes consistentes e até sistemas como o Nix para reproduzir setups complexos traz não apenas mais velocidade, mas também conforto e segurança no dia a dia de desenvolvimento.

Aprender e dominar essas ferramentas é tão importante quanto aprender uma linguagem de programação: são elas que permitem transformar esforço bruto em eficiência, garantindo que o desenvolvedor trabalhe com mais fluidez e tenha liberdade para explorar soluções mais sofisticadas.

4.4. Debugging e engenharia reversa

Um bom desenvolvedor deve ser capaz de “executar mentalmente” o código, acompanhando cada fluxo de decisão (if, switch) e cada loop (for, while) como se estivesse rodando o programa na cabeça.

fn calcular_frete(valor: f64, destino: &str) -> f64 {
    if valor <= 0.0 {
        return 0.0;
    }

    // Frete grátis para pedidos acima de 500
    if valor > 500.0 {
        return 0.0;
    }

    // Destino prioritário tem taxa fixa
    if destino == "capital" {
        return 20.0;
    }

    // Valor padrão
    50.0
}

Você não deve precisar perder tempo executando esse código com todas as suas possibilidades para debugar, enquanto escreve já deve ser capaz de executar as possibilidades de entrada e saída para a função.

O verdadeiro desafio surge quando algo dá errado: muitas vezes o erro aparece apenas como uma mensagem no console ou um comportamento inesperado na tela do cliente, enquanto a causa real está escondida em camadas mais profundas.

Depurar significa seguir esse rastro, passo a passo, de cima para baixo, até chegar à raiz do problema. É como um artista que olha para um desenho “estranho” e percebe que a falha não está na pintura final, mas em uma proporção incorreta do esboço inicial. Ter essa habilidade de engenharia reversa, de reconstruir o caminho do erro até sua origem, é o que transforma um desenvolvedor comum em um solucionador de problemas eficiente.

4.5. Abstração

Abstração é o ato de simplificar: olhar para um problema complexo e destacar apenas os pontos essenciais.

Um pintor não precisa desenhar cada fio de cabelo, apenas sugerir volume e textura.

Observe essa pintura

Note que o artista não precisou pintar cada detalhe da cena, alguns elementos da pintura são somente pinceladas; ele concentrou-se no ponto de interesse e deixou de lado elementos desnecessários. Ainda assim conseguimos identificar claramente uma criatura em um pasto de animais com montanhas ao fundo.

Em programação, as abstrações existem para organizar o caos. Ao criar uma função como sendEmail, o que realmente importa é a intenção: “enviar um e-mail”. Se será por API, SMTP ou outro provedor é apenas um detalhe de implementação, que deve ser abstraído para poder mudar sem impactar o restante do sistema. Esse isolamento torna o código mais limpo, reutilizável e fácil de manter.

Conclusão

Estudar fundamentos não significa que você dominará tudo, mas sim que terá a base sólida para evoluir. Conhecer os fundamentos permite aplicá-los de forma consciente, adaptá-los e até quebrar regras quando necessário, da mesma forma que um artista usa formas circulares para transmitir suavidade, mas pode inverter a lógica para transmitir algo inesperado.

O essencial é entender que fundamentos não se esgotam: quanto mais você pratica, mais naturais se tornam, e mais liberdade você ganha para criar, inovar e resolver problemas de maneira original.

Rust Threads safety: Uma comparação com C.

Alexandre — Mon, 18 Nov 2024 22:54:10 +0000

Nesta POC (Proof of Concept), exploraremos como a linguagem Rust trata as race conditions, comparando-a com C, uma linguagem amplamente usada, mas com menos garantias de segurança para concorrência.

Rust Threads safety: Uma Comparação com C

Threads Safety: Data Races de C ao Rust

Índice

1. Introdução
2. Threads
3. Implementação em C
- 3.1. Código sem Proteção Contra Race Conditions
- 3.2. Corrigindo com Mutex
4. Implementação em Rust
- 4.1. Problema com Race Conditions
- 4.2. Resolução com Mutex e Arc
- 4.3. Mutex vs. RwLock
5. Conclusão
6. Referências

1. Introdução

Em computação, threads são usadas para dividir tarefas de software em subtarefas que podem ser executadas concorrentemente. Ao usar threads, ganhamos tempo de processamento e aproveitamos melhor os recursos da máquina, mas essa concorrência traz desafios, como race conditions que podem gerar inconsistências graves nos dados.

2. Threads

Threads são unidades de execução que permitem processar tarefas simultaneamente. Podemos pensar em threads como fluxos independentes de execução dentro de um programa, ilustrados na imagem abaixo:

Embora as threads tragam vantagens de desempenho, elas introduzem riscos, especialmente ao acessar recursos compartilhados.

Além disso, threads podem ser usadas para implementar paralelismo, onde múltiplas tarefas são executadas simultaneamente em diferentes núcleos de CPU. Isso permite que o programa aproveite melhor o hardware disponível, acelerando a execução de tarefas independentes.

3. Implementação em C

Vamos criar um sistema simples em C:

Um saldo inicial de 1000.
Um conjunto de transações que podem ser créditos ou débitos.
Processamento paralelo dessas transações usando threads.

3.1. Código sem Proteção Contra Race Conditions

int saldo = 1000; 

void creditar(int valor) {
    int tmp_saldo = saldo;

    sleep(1); // Delay simulado

    saldo += tmp_saldo + valor;
}

void debitar(int valor) {
    int temp = saldo;

    sleep(1); // Delay simulado

    if (temp >= valor) {
        saldo = temp - valor;
    }
}

void* processar_transacao(void* arg) {
    int valor = *(int*)arg;

    if (valor > 0) {
        creditar(valor);
    } else {
        debitar(abs(valor));
    }

    return NULL;
}

int main() {
    int transactions[] = {100, -50, 200, -150, 300, -200, 150, -100, 50, -50};
    int num_transactions = sizeof(transactions) / sizeof(transactions[0]);

    pthread_t threads[num_transactions];

    for (int i = 0; i < num_transactions; i++) {
        pthread_create(&threads[i], NULL, processar_transacao, &transactions[i]); // Cria uma thread para cada transação
    }

    for (int i = 0; i < num_transactions; i++) {
        pthread_join(threads[i], NULL); // Aguarda todas as threads terminarem
    }

    printf("Saldo final da conta: %d\n", saldo);
    return 0;
}

Ao optarmos por um ambiente com processamento multithreading pode acontecer o que chamamos de race conditions, no momento em que 2 threads acessam e modificam um mesmo valor temos uma condição de corrida. Esse problema acontece pois não é garantido uma sincronização do valor acessado em cada thread devido à concorrência entre as chamadas.

Ao executar várias vezes esse código, o saldo final varia, pois threads acessam e alteram saldo simultaneamente.

3.2. Corrigindo com Mutex

int saldo = 1000; 
pthread_mutex_t saldo_mutex; // Mutex para proteger o saldo

void creditar(int valor) { 
    pthread_mutex_lock(&saldo_mutex); // Bloqueia o mutex
    int tmp_saldo = saldo;

    sleep(1); // Delay simulado

    saldo = tmp_saldo + valor;

    pthread_mutex_unlock(&saldo_mutex); // Libera o mutex
}

void debitar(int valor) {
    pthread_mutex_lock(&saldo_mutex); // Bloqueia o mutex
    int tmp_saldo = saldo;

    sleep(1); // Delay simulado

    if (tmp_saldo >= valor) {
        saldo = tmp_saldo - valor;
    }

    pthread_mutex_unlock(&saldo_mutex);  // Libera o mutex
}

Mutex é um primitivo de sincronização que garante que apenas um thread tenha acesso a um recurso compartilhado por vez. O acrônimo mutex vem do termo em inglês mutual exclusion, que significa "exclusão mútua".

Quando uma thread adquire um mutex, qualquer outra thread que tente adquirir o mesmo mutex é suspenso até que a primeira thread libere o mutex. Isso evita que dois ou mais processos(threads) tenham acesso simultâneo ao recurso compartilhado.

4. Implementação em Rust

Rust’s rich type system and ownership model guarantee memory-safety and thread-safety — enabling you to eliminate many classes of bugs at compile-time.

Pensar em Rust como uma linguagem ausente de data race não é produtivo, mas podemos entender como as structs e seu compilador contribuem trazendo recursos ótimos para segurança de memória e thread.

Rust trata race conditions com garantias em tempo de compilação, utilizando recursos como ownership, borrowing e estruturas seguras para concorrência:

Arc: Compartilhamento seguro de dados imutáveis.
Mutex e RwLock: Controle de acesso para dados mutáveis.

4.1. Problema com Race Conditions

Sem o uso das structs Arc e Mutex

fn main() {
    let mut saldo = 1000; // saldo mutável, mas sem proteção

    let handle1 = thread::spawn(move || {
        saldo += 100;  // erro: `saldo` é movido para esta thread sem proteção
    });

    let handle2 = thread::spawn(move || {
        saldo -= 50;  // erro: `saldo` é movido para esta thread sem proteção
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
}

Rust não permite o acesso direto a um dado mutável (saldo) a partir de várias threads sem proteção.
O compilador vai gerar um erro porque saldo está sendo movido para várias threads (handle1 e handle2) sem um mecanismo seguro.
Mensagem de erro que será exibida é:

error[E0382]: use of moved value: `saldo`

4.2. Resolução com Mutex e Arc

Usando Mutex e Arc conseguimos compilar e executar nosso código, com os problemas de race condition tratados.

struct ContaBancaria {
    saldo: i32,
}

impl ContaBancaria {
    fn creditar(&mut self, valor: i32) {
        let tmp_saldo = self.saldo;
        thread::sleep(time::Duration::from_secs(1));
        self.saldo = tmp_saldo + valor;
    }

    fn debitar(&mut self, valor: i32) {
        let tmp_saldo = self.saldo;

        thread::sleep(time::Duration::from_secs(1));

        if tmp_saldo >= valor {
            self.saldo = tmp_saldo - valor;
        }
    }

    fn consultar_saldo(&self) -> i32 {
        self.saldo
    }
}

fn main() {
    let conta = Arc::new(Mutex::new(ContaBancaria { saldo: 1000 }));  // Cria a conta com Arc

    let mut handles = vec![];
    let transactions = [100, -50, 200, -150, 300, -200, 150, -100, 50, -50];

    for transaction in transactions {
        let conta = Arc::clone(&conta);

        let handle = thread::spawn(move || {
            let random_sleep_time = rand::thread_rng().gen_range(0..10);
            thread::sleep(time::Duration::from_secs(random_sleep_time));

            if transaction > 0 {
                conta.lock().unwrap().creditar(transaction);
            } else {
                conta.lock().unwrap().debitar(transaction.abs());
            }
        });

        handles.push(handle);
    }


    for handle in handles {
        handle.join().unwrap(); // Espera todas as threads terminarem
    }

    let saldo_final = conta.lock().unwrap().consultar_saldo();
    println!("Saldo final da conta: {}", saldo_final);
}

4.3. Mutex vs. RwLock

Mutex e RwLock são usados para tratar race conditions, cada um com vantagens específicas:

Mutex: Garante acesso exclusivo de um recurso para uma thread, bloqueando o acesso das outras até seja liberado. É simples e eficaz, mas mesmo leituras bloqueiam o recurso, tornando-o menos eficiente em cenários com muitas leituras.

RwLock: Permite múltiplas leituras simultâneas com .read() e restringe a escrita exclusiva com .write(). É Ideal para cenários com predominância de leituras, pois melhora o desempenho ao permitir paralelismo nas operações de leitura.

5. Conclusão

A comparação entre C e Rust destaca abordagens diferentes para resolver race conditions. Enquanto C exige atenção para evitar erros de condições de corrida, Rust reduz esses riscos em tempo de compilação, por meio de ferramentas como Mutex, RwLock e Arc além do modelo de ownership. Isso não apenas torna o código mais seguro, mas também reduz a carga mental do programador evitando bugs silenciosos.

Em resumo, Rust se posiciona como uma excelente escolha para o desenvolvimento de sistemas concorrentes, oferecendo segurança e confiabilidade.

6. Referências

Schemas em SQL: Indexes e B+ trees

Alexandre — Thu, 19 Oct 2023 18:21:27 +0000

Indexes e B+ trees qual será a relação dessa engraçada estrutura de dados com nossos queridos indexes do banco?

Conteúdo

1 Prólogo
2 O que são indexes
3 B Tree e B+ Tree
4 Vamos observar na prática
5 Conclusão
6 Referências

1 Prólogo

O que são indexes e como eles são usados para optimizar buscas? quantas vezes já não adicionamos indexes em colunas de tabelas com milhares de registros e magicamente as queries caíram de alguns segundos para milissegundos, nunca foi magica e sim Computer Science.

2. O que são indexes

Index são uma estrutura separada da estrutura dos registros tabela, sendo feita uma cópia de uma parte dos seus dados, que servem como um ponteiro para acessar um registro específico.

Quando pensamos em criar index existe um conceito que podemos seguir "As many as you need, As few as you can get away with", em outras palavras, você deve criar índices suficientes para acelerar as consultas e melhorar o desempenho, mas não deve criar muitos índices desnecessários, pois isso pode aumentar o espaço de armazenamento e a sobrecarga inserções no banco de dados, já que sempre que um registro for inserido vão ser criados também os indexes existentes.

Então como sei quais index criar? Para criar seus indexes é preciso olhar para queries que pretende executar, para montar um bom schema olhamos para os dados que vamos armazenar, já para bons indexes olhamos para as queries estamos executando ou pretendemos executar.

3. B Tree e B+ Tree

Como foi dito os indexes são partes dos seus dados armazenados em uma estrutura diferente, essa estrutura é a B+Tree, antes de entendermos ela precisamos compreender a B Tree.

B Tree é uma estrutura não lineares diferentes de um Array, que somente podemos ir para frente e para trás com as árvores podemos navegar para níveis e subníveis dentro dela.

A B Tree diferente a Binary Tree permite que armazenemos mais de um valor por nó, como na imagem de exemplo onde o primeiro nó tem 2 valores 20 e o 40 permitindo que tenhamos um bloco de valores em cada nó que recebem o nome de página.

B+tree é a estrutura de dados que está por trás das buscas optimizadas que o banco faz, é uma estrutura derivada das BTrees, mas com uma forma diferente de armazenar suas chaves de uma maneira que o processamento sequencial e aleatório de chaves fossem eficientes, sendo bastante usadas em bancos de dados como MYSQL e sistemas de arquivo como FTP.

A principal diferença de estrutura das duas é que a B+ os dados são armazenados apenas nas folhas(Nós finais, que não tem filhos), e seus nós internos armazenam ponteiros para os filhos e suas folhas são uma linked list facilitando assim uma busca sequencial de valores se adequando bem melhor para o contexto de bancos de dados, já a B Tree é mais versátil permitindo um uso em uma variedade maior de contextos.

4. Prática

Vamos observar como uma query usa index para encontrar os dados e como seria essa mesma busca se não usássemos os index.

SELECT * FROM users;  
EXPLAIN SELECT * FROM users WHERE name='Virux';

Como o SQL fez para encontrar um user baseado no nosso where ?

Sem um índice, o MySQL vai ler toda a tabela do início ao fim encontrando os valores desejados, conseguimos comprovar isso observando valor all no campo type que o EXPLAIN nos retorna, ou seja, quanto maior a tabela mais lenta a busca, como Virux é o registro 9 ele precisou ler 8 registros até encontrar o desejado.

Executando isso o SQL vai criar um index para esse campo

CREATE INDEX idx_name ON users (name(255));

Agora se a coluna name tiver um index executando a mesma busca será feita de uma forma mais optimizada, buscando na estrutura da B+Tree que o mysql montou com os seus dados, conseguimos identificar isso com o valor ref no campo type que o EXAPLAIN nos retorna.

Podemos encontrar esse registro com somente 3 etapas.

5. Conclusão

Com isso podemos concluir que buscar usando index são bem mais optimizadas, pois são feitas em uma estrutura de dados separada da sua tabela chamada B+Tree, mas precisamos criar nossos index com cuidado pensando nas queries que pretendemos executar, pois eles afetam diretamente a desempenho das inserções além de aumentar o espaço de armazenamento.

6. Referências

B+Tree Wiki
B+Tree Vizualize
Doc do mysql sobre index

Garanta a Eficiência: Escolhendo entre tipos String no SQL

Alexandre — Tue, 29 Aug 2023 12:27:27 +0000

Garanta a eficiência, nova série fazendo mais sucesso que The Walking Dead, venha aprender como salvar seus strings no seu banco sql.

Conteúdo

1 Prólogo
2 CHAR
3 VARCHAR
4 CHARSET e COLLATE
5 Conclusão

1. Prólogo

Dando continuidade à nossa série, já abordamos os valores numéricos agora, chegou a hora de nos aprofundarmos nas strings. Neste artigo, exploraremos as diferenças entre os tipos VARCHAR e CHAR, além de fornecer uma compreensão detalhada sobre os conceitos de CHARSET e COLLATE, os quais você certamente já encontrou em seus bancos de dados, mas talvez ainda não tenha uma ideia clara de suas finalidades.

2. CHAR

O tipo de dado CHAR no MySQL é usado para armazenar strings de comprimento fixo.

Se o valor de uma string CHAR tiver um comprimento menor do que o comprimento especificado, os espaços em branco serão adicionados automaticamente ao final da string para preencher o espaço restante. Esses espaços em branco serão incluídos.

O tipo de dado CHAR é usado principalmente quando você precisa armazenar strings de comprimento fixo ou quando há um requisito específico para o tamanho da string. As comparações e pesquisas em colunas CHAR são mais rápidas do que em colunas VARCHAR porque não há necessidade de levar em consideração o tamanho variável.

3. VARCHAR

O tipo de dado VARCHAR armazena strings de comprimento variável, o que significa que o tamanho ocupado no armazenamento depende do comprimento real da string. Por exemplo, se você definir uma coluna VARCHAR(255) e inserir uma string de apenas 10 caracteres, ela ocupará apenas a quantidade de espaço necessária para armazenar esses 10 caracteres.

O tipo de dado VARCHAR pode ser mais eficiente em termos de armazenamento em comparação com o tipo de dado CHAR se a maioria das strings armazenadas tiver comprimentos variáveis. Isso ocorre porque o espaço alocado para armazenar a string é proporcional ao comprimento real da string e não ao comprimento máximo especificado.

O tipo de dado VARCHAR requer espaço adicional de armazenamento para registrar o comprimento real da string. Esse espaço extra varia de 1 a 2 bytes, dependendo do tamanho máximo especificado para a coluna VARCHAR.

4. CHARSET e COLLATE

CREATE TABLE strings (
    fixed100 CHAR(100), -- 100 bytes "Aaron     ..."
    var100 VARCHAR(100) -- 5 bytes + 1 Byte "Aaron"
);

SHOW CREATE TABLE strings;

CREATE TABLE `strings` (
  `fixed100` char(100) DEFAULT NULL,
  `var100` varchar(100) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

SELECT * FROM information_schema.CHARACTER_SETS ORDER BY CHARACTER_SET_NAME;

CHARSET (utf8mb4)

O CHARSET utf8mb4 é uma configuração no MySQL que define o conjunto de caracteres utilizado para armazenar dados em colunas de texto. Nesse caso, o utf8mb4 refere-se a um conjunto de caracteres multibyte que suporta a codificação UTF-8.

utf8: Refere-se ao conjunto de caracteres UTF-8, que é um padrão universalmente aceito para representação de caracteres em várias línguas e scripts. O UTF-8 é capaz de representar uma ampla gama de caracteres e é amplamente utilizado em sistemas modernos.
mb4: É uma abreviação de "multibyte 4", indicando que o conjunto de caracteres suporta até 4 bytes por caractere. Isso permite a representação de caracteres que requerem mais de 2 bytes, como emojis e caracteres especiais de diferentes idiomas.

COLLATE (utf8mb4_0900_ai_ci)

A cláusula COLLATE é usada para definir a ordem de classificação de caracteres em operações de comparação e classificação de texto. No caso específico do COLLATE utf8mb4_0900_ai_ci, é uma sequência de configuração que define a ordem de classificação. Essas definições são as seguintes:

utf8mb4: É um conjunto de caracteres que suporta a codificação UTF-8 de caracteres multibyte. O UTF-8 é um padrão universalmente aceito para representação de caracteres e suporta uma ampla gama de caracteres de diferentes idiomas.
0900: É um indicador da versão do algorítimo usado. Neste caso, 0900 refere-se à versão do Unicode Collation Algorithm (ou UCA). As versões mais recentes do MySQL podem introduzir atualizações e melhorias nos conjuntos de caracteres existentes.
ai: É uma abreviação de "Accent Insensitive" (insensível a acentos). Isso significa que as comparações de caracteres são realizadas sem levar em consideração os acentos. Por exemplo, as letras "á" e "a" seriam consideradas iguais.
ci: É uma abreviação de "Case Insensitive" (insensível a maiúsculas e minúsculas). Isso significa que as comparações de caracteres são realizadas sem levar em consideração a diferença entre letras maiúsculas e minúsculas. Por exemplo, as letras "A" e "a" seriam consideradas iguais.

5. Conclusão

Neste artigo, exploramos a diferença entre os tipos de string VARCHAR e CHAR no MySQL. Aprendemos que o CHAR é ideal para tamanhos fixos, enquanto o VARCHAR é mais adequado para tamanhos variáveis. Além disso, compreendemos o papel do CHARSET e COLLATE, permitindo personalizar a ordenação de texto.

Com esse conhecimento, podemos tomar decisões mais acertadas ao projetar nossas tabelas no MySQL, garantindo a eficiência e o desempenho ideais para nossas aplicações. A escolha inteligente dos tipos de string e configurações de charset/collate é crucial para um banco de dados otimizado e bem-sucedido.

Garanta a Eficiência: Escolhendo entre tipos decimais no SQL

Alexandre — Wed, 12 Jul 2023 00:30:56 +0000

Decimais, existem tantos e qual devo escolher ? Saiba que essa decisão é de total importância para não perder dinheiro em seu software.

Conteúdo

Prólogo
Tipos decimais SQL
O que é essa precisão ?
Então quando eu não ira querer precisão
Vamos observar na prática
Conclusão

1. Prólogo

Sempre tive dúvidas sobre a razão pela qual existem tantos tipos de dados decimais no SQL e quando é apropriado utilizá-los, especialmente ao lidar com valores monetários, onde a consistência dos cálculos e a precisão são fundamentais para evitar perdas financeiras. Muitos desses tipos de dados são desconhecidos ou subutilizados no cotidiano de um desenvolvedor web. No entanto, estar ciente dos seus casos de uso diferenças é uma vantagem significativa para quando precisar usar você conseguir identificar.

2. Tipos decimais SQL

Existem diversos tipos de dados decimais disponíveis no SQL, cada um com seu próprio propósito e comportamento. Vamos explorar alguns dos tipos mais comuns:

DECIMAL/NUMERIC

O tipo DECIMAL possui um alias (apelido) chamado NUMERIC, ou seja ambos têm o mesmo comportamento. Esse tipo é especialmente adequado para lidar com valores precisos, como dinheiro, onde é crucial manter a exatidão das informações.

FLOAT

O tipo FLOAT é recomendado para valores aproximados, como estatísticas, por serem eficientes em termos de espaço de armazenamento e desempenho, ocupando um total de 4 bytes de espaço de armazenamento.

DOUBLE

O campo DOUBLE também é apropriado para valores aproximados, mas oferece um range de valores maior em comparação ao FLOAT. Para acomodar essa flexibilidade, ele requer 8 bytes de espaço de armazenamento.

3. O que é essa precisão ?

Essa precisão é você saber que se um cliente comprar 2 produtos que custam R$ 20,30 ele vai pagar R$ 20,60 e não R$ 20,59999931231232321.

4. Então quando eu não ira querer precisão ?

Embora o float possa introduzir variações nos cálculos, há casos de uso em que eles são vantajosos na prática. Aqui estão dois exemplos:

Cálculos científicos e simulações: Em muitas áreas da ciência e da engenharia, os cálculos envolvem números que não exigem uma precisão extrema. Nesses casos, o uso de float pode ser adequado, pois oferece uma representação aproximada dos valores com eficiência de espaço e desempenho. Por exemplo, em simulações físicas, como modelos de sistemas climáticos ou mecânicos, a precisão aproximada fornecida pelos números de ponto flutuante é suficiente e pode acelerar significativamente os cálculos.
Processamento gráfico: Em aplicações de computação gráfica, como jogos ou renderização de imagens, o uso de float é comum para representar coordenadas 3D, cores e transformações. A natureza aproximada dos números de ponto flutuante não é perceptível para a maioria dos usuários, e a velocidade de processamento é fundamental nesses casos.

5. Vamos observar na prática

Criaremos uma tabela para testes chamada decimals

CREATE TABLE decimals (
  n INT,
  d1 DECIMAL(10, 2),
  d2 FLOAT, -- 4 bytes
  d3 DOUBLE -- 8 bytes
);

INSERT INTO decimals
VALUES
(1, 100.40, 100.40, 100.40),
(1, -80.00, -80.00, -80.00);

SELECT sum(d1), sum(d2), sum(d3) FROM decimals GROUP BY n;

Ao executar o SELECT vamos ter o seguinte resultado

sum(d1)	sum(d2)	sum(d3)
20.40	20.400001525878906	20.400000000000006

Nesse exemplo, criamos uma tabela chamada "decimals" com três colunas: "d1" do tipo DECIMAL(10, 2), "d2" do tipo FLOAT e "d3" do tipo DOUBLE. Em seguida, inserimos duas linhas de dados nessa tabela.

Ao realizar a soma dos valores de cada coluna usando a cláusula GROUP BY, podemos observar as diferenças resultantes. A coluna "d1", que utiliza o tipo DECIMAL com precisão fixa de duas casas decimais, apresenta um resultado preciso de 20.40.

No entanto, as colunas "d2" (FLOAT) e "d3" (DOUBLE) demonstram as variações típicas dos números de ponto flutuante. Embora os valores somados sejam teoricamente iguais a 20.40, devido à representação aproximada desses tipos, ocorrem pequenas variações nos resultados. Essas variações podem ocorrer devido a erros de arredondamento ou limitações na precisão dos bits usados para representar os números.

Essas diferenças podem parecer insignificantes, mas em casos que exigem precisão exata, como manipulação de valores monetários, elas podem levar a perdas ou erros nos cálculos financeiros.

6. Conclusão

Exploramos os diferentes tipos de dados decimais no SQL e destacamos a importância de escolher o tipo correto com base nas necessidades específicas. Ao lidar com valores monetários e cálculos que exigem precisão absoluta, é recomendado utilizar tipos decimais de precisão fixa, como DECIMAL ou NUMERIC. Esses tipos garantem resultados consistentes e evitam perdas de valor.

Embora os números de ponto flutuante (float) possam ser vantajosos em determinados cenários, e*les podem introduzir variações nos cálculos* devido à natureza aproximada da representação. É essencial avaliar o contexto e a precisão necessária para evitar problemas de arredondamento.

Garanta a Eficiência: Escolhendo Sabiamente o Tipo de Dado Integer no MySQL

Alexandre — Tue, 04 Jul 2023 18:16:05 +0000

Já pensou no motivo de um banco de dados ter tantos tipos de valores inteiros? SMALLINT? BIGINT? É de comer?

Conteúdo

Prólogo
Escolhendo tipos em modelos de dados
Tomando uma decisão consciente
O que posso fazer um Byte ?
Agora vamos colocar em prática
Considerações finais

1. Prólogo

Nessa vida de desenvolvedor de software, aprendi a valorizar os fundamentos das tecnologias com as quais trabalho. Neste artigo, vamos explorar todos os tipos INTEGER existentes, quais suas características e como podemos usar isso para tomar decisões mais assertivas ao modelar um esquema com MySQL.

2. Escolhendo tipos em modelos de dados

Um princípio fundamental para modelar dados é avaliar se os tipos escolhidos são os melhores para os valores que serão recebidos. Nesse artigo vamos tentar entender quais tipos de inteiros existem e quais suas diferenças para podermos tomar essa melhor decisão no momento de criar nossas tabelas.

3. Tomando uma decisão consciente

Para conseguirmos tomar a decisão mais consciente precisamos saber quais o tipos de inteiro existentes e qual o espaço ocupado em Bytes por cada tipo, pois independente de você inserir o número inteiro 1 em um registro ele ocupa um espaço diferente de acordo com o tipo de dado do schema.

Por exemplo, o tipo TINYINT ocupa 1 byte, enquanto o tipo BIGINT ocupa 8 bytes. Portanto, mesmo que você insira o número inteiro 1 em um registro, ele ocupará um espaço diferente dependendo do tipo de dado especificado no esquema (schema).

Podemos considerar que cada tipo de inteiros nos permitem armazenar um certo range de valores e cada range reserva uma quantidade de Bytes.

Vamos observar todos os tipos e seus custos de Bytes:

Type	Storage (Bytes)
TINYINT	1
SMALLINT	2
MEDIUMINT	3
INT	4

4. O que posso fazer um Byte ?

Com 1 Byte podemos usar 8 Bits, ou seja com o TINYINT podemos armazenar números no seguinte range:

00000000 = 0
11111111 = 255

E caso precisarmos ter um sinal ? Nesse caso vamos precisas separar um bit para isso reduzindo nosso range assim:

0 1111111 = -128 (negative bit)
1 1111111 = 127 (positive bit)

Com isso temos a seguinte tabela:

Type	Storage (Bytes)	Min Signed	Max Signed	Max Unsigned
TINYINT	1	-128	127	255
SMALLINT	2	-32768	32767	65535
MEDIUMINT	3	-8388608	8388607	16777215
INT	4	-2147483648	2147483647	4294967295
BIGINT	8	-2^63	2^63-1	2^64-1

5. Agora vamos colocar em prática

CREATE TABLE `books` (
    `id` bigint NOT NULL AUTO_INCREMENT,
    `title` varchar(100) NOT NULL,
    `num_pages` SMALLINT UNSIGNED, 
     PRIMARY KEY (id)
);

Nesse trecho de SQL, tomamos a decisão de escolher o tipo de inteiro mais adequado com base no contexto do nosso caso de uso. Ao analisar a coluna num_pages, que representa o total de páginas de um livro, optamos por utilizar o tipo SMALLINT. Essa escolha foi feita levando em consideração os seguintes fatores:

1. Valor máximo adequado: O tipo TINYINT possui um valor máximo de 255, o qual poderia ser facilmente ultrapassado por livros com um número significativo de páginas. No entanto, o tipo SMALLINT oferece um tamanho maior, permitindo um valor máximo de 65535. Essa faixa é mais adequada para a representação do número de páginas de um livro na vida real a não ser que você esteja lendo Game of Thrones, ai já seria preciso de um BIGINIT.

2. Modificador UNSIGNED: Utilizamos o modificador UNSIGNED para indicar que não há necessidade de armazenar valores negativos para o número de páginas de um livro. Isso nos permite aproveitar um limite positivo maior dentro do mesmo tipo de dado, já que não precisamos reservar espaço para o sinal.

Portanto, ao escolher o tipo SMALLINT UNSIGNED para a coluna num_pages, levamos em consideração o valor máximo adequado, a economia de espaço e a exclusão da possibilidade de valores negativos, garantindo uma representação eficiente e precisa do número de páginas dos livros em nosso sistema.

6. Considerações finais

Após compreendermos as diferenças entre os tipos de inteiro, percebi o quanto é importante escolher o tipo de dado adequado para cada situação. Refletindo sobre minha própria experiência, lembro-me das vezes em que utilizei o tipo INTEGER desnecessariamente. Após aprofundar-me nesse assunto e compartilhar essas informações, acredito que não vou mais cometer esse erro. Espero que este artigo tenha sido esclarecedor para vocês também, auxiliando na escolha consciente do tipo de inteiro mais adequado para cada contexto.

Venha fazer parte de um ambiente de aprendizado.