<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Hugo Brilhante on Medium]]></title>
        <description><![CDATA[Stories by Hugo Brilhante on Medium]]></description>
        <link>https://medium.com/@hugobrilhante?source=rss-c5f257b40127------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*YI2igDvn_Vn8OPPMxZMPzw.jpeg</url>
            <title>Stories by Hugo Brilhante on Medium</title>
            <link>https://medium.com/@hugobrilhante?source=rss-c5f257b40127------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 21:49:11 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@hugobrilhante/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Restaurantes, cardápios e APIs: uma analogia para entender de vez]]></title>
            <link>https://hugobrilhante.medium.com/restaurantes-card%C3%A1pios-e-apis-uma-analogia-para-entender-de-vez-c2731ef69337?source=rss-c5f257b40127------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2731ef69337</guid>
            <category><![CDATA[real-life-stories]]></category>
            <category><![CDATA[api-development]]></category>
            <dc:creator><![CDATA[Hugo Brilhante]]></dc:creator>
            <pubDate>Sun, 29 Jun 2025 18:08:47 GMT</pubDate>
            <atom:updated>2025-06-29T18:08:47.374Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3YiN_TMzvGCy5Md7Yvnvnw.png" /></figure><p>As APIs já são usadas há muitos anos. Mesmo com o avanço das inteligências artificiais, a base da comunicação com esses sistemas ainda passa por APIs — e vai continuar assim por muito tempo.</p><p>Mas afinal, o que é uma API?</p><p>Pode parecer um conceito técnico demais à primeira vista, mas a verdade é que usamos APIs o tempo todo — mesmo sem perceber. E para mostrar isso, quero te levar a uma cena cotidiana.</p><p>Imagine que você está com fome e decide ir a um restaurante. Você se senta, pega o cardápio, escolhe um prato, faz seu pedido ao garçom e depois de alguns minutos, recebe exatamente aquilo que pediu — ou pelo menos deveria. Simples, certo?</p><p>Agora pense comigo: esse processo tem muito mais a ver com o mundo da programação do que parece.</p><p>Neste artigo, vamos explorar como APIs funcionam usando uma analogia deliciosa (literalmente): um restaurante.</p><p>Você vai perceber que o garçom, o cardápio, a cozinha, os pedidos e até a fila de espera têm tudo a ver com o jeito que sistemas se comunicam entre si.</p><p>Então, prepare o apetite — por conhecimento — e vamos lá.</p><h3>O cardápio é a API</h3><p>Quando você chega a um restaurante, o garçom não espera que você diga qualquer coisa. Em vez disso, ele te entrega um <strong>cardápio</strong>. Ali está tudo o que você <em>pode</em> pedir — nem mais, nem menos.</p><p>No mundo da tecnologia, esse cardápio é a <strong>API</strong>.</p><p>A sigla API vem de <em>Application Programming Interface</em> — ou seja, uma interface que permite que diferentes sistemas conversem entre si. Mas pode pensar nela como o cardápio que mostra exatamente o que está disponível e como pedir.</p><p>Por exemplo:</p><ul><li>Se você quer <strong>ver algo</strong>, faz um pedido do tipo GET (como pedir “uma lasanha”).</li><li>Se você quer <strong>enviar algo novo</strong>, usa um POST (como pedir “um prato personalizado”).</li><li>Se quiser <strong>atualizar algo</strong>, é um PUT ou PATCH.</li><li>E se quiser <strong>remover</strong>, é um DELETE.</li></ul><p>Esses são os <strong>métodos HTTP</strong> — os “tipos de pedidos” que você pode fazer.</p><p>Além disso, o cardápio não mostra só o nome do prato. Ele vem com <strong>descrição, ingredientes e, às vezes, até foto</strong>. Isso é o equivalente à <strong>documentação da API</strong>: explica direitinho o que pode ser pedido, quais são os campos obrigatórios (como “sem glúten?”), os valores aceitos e o que esperar como resposta.</p><p>E assim como em um restaurante, se você pedir algo que não está no cardápio… o garçom provavelmente vai levantar a sobrancelha e dizer: “Desculpe, não servimos isso aqui.”</p><p>Esse é o papel de uma boa API: deixar <strong>claro, previsível e seguro</strong> o que pode ou não ser feito.</p><h3>O pedido: serialização e desserialização</h3><p>Depois de olhar o cardápio, você faz seu pedido ao garçom: “Quero uma lasanha, sem queijo, por favor.”</p><p>Nesse momento, algo importante acontece. O garçom <strong>entende o que você disse</strong> e transforma esse pedido em algo que a cozinha possa preparar. Talvez ele escreva num bloquinho, ou digite no sistema. Isso é o que chamamos, no mundo das APIs, de <strong>desserialização</strong> — transformar uma informação (como um JSON) em algo que o sistema entenda internamente.</p><p>Na cozinha, o pedido é interpretado, os ingredientes são separados, o prato é montado e preparado com cuidado. Quando fica pronto, ele <strong>volta até você</strong>, agora como um prato bonito, bem montado e pronto para consumo.</p><p>Isso é a <strong>serialização</strong> — pegar a informação do sistema (por exemplo, um objeto Python, Java, etc.) e transformá-la em um formato que o cliente entenda, geralmente um JSON.</p><p>Resumindo:</p><ul><li><strong>Você → garçom</strong>: pedido = <strong>JSON enviado</strong></li><li><strong>Garçom → cozinha</strong>: desserialização = sistema interpreta os dados</li><li><strong>Cozinha → garçom → você</strong>: prato na mesa = <strong>resposta serializada</strong></li></ul><p>Se algo der errado — por exemplo, você pedir um ingrediente que não existe — o garçom te avisa antes mesmo do prato chegar. É como uma API bem construída: ela valida seu pedido antes de processar e retorna um erro claro se houver problema.</p><p>No fim, tudo se resume a <strong>comunicação clara entre cliente e servidor</strong>, assim como entre cliente, garçom e cozinha.</p><h3>Autenticação: “Você tem reserva?”</h3><p>Antes mesmo de fazer o pedido, o garçom pode perguntar: <strong>“Você tem reserva?”</strong></p><p>Ou talvez:<br> — Qual o nome?<br> — Pode me mostrar um documento?</p><p>Essa é a <strong>etapa de autenticação</strong>. O restaurante precisa saber <strong>quem você é</strong>, se <strong>tem direito de estar ali</strong>, e talvez até <strong>qual é a sua mesa</strong>.</p><p>Nas APIs acontece o mesmo. Antes de processar qualquer requisição, o sistema precisa ter certeza de quem está do outro lado. Isso pode ser feito de várias formas:</p><ul><li><strong>Login e senha</strong>: como dar seu nome e CPF na entrada.</li><li><strong>Token de acesso</strong>: como apresentar um <strong>QR Code da reserva</strong> ou um <strong>cartão fidelidade</strong>.</li><li><strong>Biometria ou reconhecimento facial</strong>: como um restaurante super tecnológico que te reconhece ao entrar.</li></ul><p>Sem isso, nada acontece. A cozinha nem começa a preparar. Afinal, segurança vem antes de tudo.</p><p>E vale lembrar: autenticação <strong>não é sobre o que você pode fazer</strong>, mas <strong>sobre provar quem você é</strong>. As permissões vêm logo em seguida — e é sobre isso que falamos no próximo tópico.</p><h3>Permissões: “Desculpe, este prato é só para clientes VIP”</h3><p>Depois de se identificar, você faz o pedido. Mas o garçom responde:<br> <strong>“Esse prato é exclusivo para clientes VIP.”</strong></p><p>Mesmo autenticado, você <strong>não tem permissão</strong> para tudo.</p><p>É assim também nas APIs. Autenticação prova <em>quem você é</em>, mas <strong>permissão define o que você pode fazer</strong>.</p><p>Alguns exemplos:</p><ul><li>Um cliente comum pode ver apenas os <strong>próprios pedidos</strong>.</li><li>Um gerente pode visualizar <strong>todos os pedidos do restaurante</strong>.</li><li>Um administrador pode <strong>editar o cardápio</strong> ou <strong>criar novos pratos</strong>.</li></ul><p>As permissões funcionam como as <strong>regras internas da casa</strong>. Elas ajudam a proteger dados sensíveis, evitar confusão e garantir que cada um veja (e faça) apenas o que lhe cabe.</p><p>É como ter uma área VIP no restaurante: todos os clientes são importantes, mas <strong>alguns têm acesso a privilégios diferentes</strong>.</p><h3>Throttling: “Calma! Um pedido por vez”</h3><p>Imagine que uma mesa começa a pedir <strong>20 pratos de uma vez só</strong>, enquanto o restante do restaurante espera para ser atendido. A cozinha entra em pânico. O garçom fica sobrecarregado. O serviço desanda.</p><p>Para evitar esse caos, alguns restaurantes colocam limites:<br> <strong>“Máximo de 2 pratos por pessoa”</strong><br> ou<br> <strong>“Esse prato tem número limitado por dia.”</strong></p><p>Nas APIs, isso se chama <strong>throttling</strong> — um mecanismo que limita o número de requisições que um cliente pode fazer dentro de um certo tempo.</p><p>Por exemplo:</p><ul><li>Um app pode ter direito a <strong>100 requisições por minuto</strong>.</li><li>Um usuário gratuito pode acessar <strong>menos endpoints</strong> do que um usuário premium.</li><li>Em momentos de pico, a API pode impor uma <strong>fila</strong> para organizar o fluxo.</li></ul><p>Isso protege o servidor (a cozinha) e garante que <strong>todos sejam atendidos de forma justa e estável</strong>.</p><p>No fim das contas, é uma questão de bom senso e equilíbrio: <strong>dar conta da demanda sem perder a qualidade no serviço</strong>.</p><h3>Paginação: “Menu degustação em etapas”</h3><p>Alguns restaurantes servem um <strong>menu degustação</strong>: em vez de trazer tudo de uma vez, os pratos vêm em etapas. Entrada, prato principal, sobremesa… um de cada vez, no tempo certo.</p><p>Imagine agora um cardápio com <strong>milhares de pratos</strong>. Seria impraticável entregar tudo de uma vez. O cliente ficaria perdido, e o garçom carregando uma enciclopédia.</p><p>Nas APIs, isso se resolve com <strong>paginação</strong>: quando há <strong>muitos dados para retornar</strong>, a resposta é dividida em <strong>blocos menores</strong>. Você recebe uma página de resultados por vez — e pode navegar para a próxima, se quiser.</p><p>Por exemplo:</p><ul><li>GET /pedidos?page=1&amp;limit=10 traz os primeiros 10 pedidos.</li><li>A resposta inclui um link para page=2, e assim por diante.</li></ul><p>Os benefícios são claros:</p><ul><li><strong>Melhor performance</strong> para o servidor.</li><li><strong>Menos dados trafegando</strong> pela rede.</li><li><strong>Experiência mais suave</strong> para quem está consumindo a API.</li></ul><p>É como ser bem servido, no seu tempo, sem pressa e sem exagero.</p><h3>Desempenho: Cozinha eficiente vs. cozinha lenta</h3><p>Todo mundo quer ser bem atendido num restaurante. Mas além de comida boa, <strong>tempo importa</strong>. Esperar 5 minutos por uma massa é aceitável. Agora, 40 minutos para uma salada? Injustificável.</p><p>Com APIs, é a mesma coisa. O <strong>tempo de resposta</strong> faz toda a diferença. Uma API rápida melhora a experiência do usuário, reduz custos e torna tudo mais fluido.</p><p>E o que ajuda a manter a cozinha (ou melhor, o servidor) ágil?</p><ul><li><strong>Cache</strong>: é como deixar pratos semi-prontos na cozinha. Se muita gente pede o mesmo item, ele sai mais rápido. Na API, é guardar uma resposta para servir de novo sem recalcular tudo.</li><li><strong>Evitar N+1 queries</strong>: imagine um garçom que precisa trazer 10 ingredientes, mas em vez de ir uma vez só à despensa, ele vai <strong>10 vezes, um por um</strong>. Ineficiente, não? Isso acontece quando a API (ou o backend) consulta o banco de dados de forma desnecessariamente repetitiva.</li><li><strong>Pré-processamento</strong>: como preparar molhos antes do horário de pico. Em APIs, pode ser um processo em background que deixa dados prontos para servir mais rápido.</li></ul><p>Desempenho não é só sobre “rodar código rápido”. É sobre <strong>planejar bem, antecipar necessidades e reduzir o desperdício</strong> — como toda boa cozinha faz.</p><h3>Versionamento: “Esse prato mudou no novo cardápio”</h3><p>Você vai ao seu restaurante favorito e pede aquele prato que adora. Mas o garçom responde:<br> <strong>“Ah, ele saiu do cardápio.”</strong><br> Ou pior:<br> <strong>“Agora esse prato vem com molho diferente e sem acompanhamento.”</strong></p><p>Frustrante, né?</p><p>No mundo das APIs, isso também acontece. À medida que um sistema evolui, <strong>novos recursos são criados, regras mudam e alguns dados deixam de existir</strong>. Para não quebrar tudo de quem já usava a versão antiga, entra em cena o <strong>versionamento</strong>.</p><p>É como manter <strong>vários cardápios coexistindo</strong>:</p><ul><li>/api/v1/pedidos: traz o prato como ele sempre foi.</li><li>/api/v2/pedidos: já vem com novos ingredientes, apresentação diferente, talvez até um novo nome.</li></ul><p>Isso permite:</p><ul><li>Atualizar funcionalidades <strong>sem afetar usuários antigos</strong>.</li><li>Testar mudanças com segurança.</li><li>Dar tempo para quem usa a API se adaptar.</li></ul><p>O versionamento é uma forma de respeitar o cliente — e evitar que alguém receba um prato inesperado só porque o restaurante resolveu mudar a receita.</p><h3>Erros: “Esse prato está em falta”</h3><p>Você fez seu pedido, mas o garçom volta e diz:<br> <strong>“Desculpe, esse prato está em falta hoje.”</strong><br> Ou então:<br> <strong>“Estamos com problemas na cozinha, não podemos preparar seu pedido agora.”</strong><br> Ou ainda:<br> <strong>“Desculpe, mas você não pode pedir esse prato.”</strong></p><p>Essas são formas de avisar que algo deu errado — e, no mundo das APIs, os <strong>códigos de erro HTTP</strong> fazem o mesmo papel.</p><p>Os mais comuns são:</p><ul><li><strong>404 (Not Found)</strong>: o prato não existe no cardápio, ou o pedido foi feito para uma mesa que não está no sistema.</li><li><strong>500 (Internal Server Error)</strong>: a cozinha teve um problema inesperado e não conseguiu preparar o prato.</li><li><strong>403 (Forbidden)</strong>: você está tentando pedir algo que não tem permissão, como um prato exclusivo para clientes VIP.</li></ul><p>Uma boa API, assim como um bom garçom, <strong>dá um feedback claro e rápido</strong>, para que o cliente saiba exatamente o que aconteceu — sem deixar no escuro ou frustrado.</p><p>Isso facilita corrigir o pedido, ajustar expectativas e continuar a experiência de forma agradável.</p><h3>Conclusão: APIs bem servidas agradam qualquer paladar</h3><p>Criar uma API é como ser o garçom de um bom restaurante.</p><p>Não basta só preparar o prato (o dado ou serviço). É preciso servir com clareza, rapidez e atenção — entregando exatamente o que o cliente pediu, no momento certo, e da forma mais fácil de entender.</p><p>Uma API bem feita é eficiente, segura e previsível. Ela evita confusões, frustrações e faz com que a experiência de quem a consome seja sempre agradável.</p><p>Por isso, sempre que estiver desenvolvendo ou mantendo uma API, pergunte-se:<br> <strong>“Que tipo de garçom eu estou sendo?”</strong></p><p>Você está servindo seus usuários com cuidado, respeito e excelência?</p><p>No fim das contas, <strong>API de qualidade é sobre servir bem — e agradar a qualquer paladar.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2731ef69337" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python Is All of That at Once (And That Is Fine)]]></title>
            <link>https://hugobrilhante.medium.com/python-is-all-of-that-at-once-and-that-is-fine-a985156209ea?source=rss-c5f257b40127------2</link>
            <guid isPermaLink="false">https://medium.com/p/a985156209ea</guid>
            <category><![CDATA[multithreading]]></category>
            <category><![CDATA[compilation]]></category>
            <category><![CDATA[curiosity]]></category>
            <category><![CDATA[python-programming]]></category>
            <dc:creator><![CDATA[Hugo Brilhante]]></dc:creator>
            <pubDate>Tue, 24 Jun 2025 18:02:47 GMT</pubDate>
            <atom:updated>2025-06-24T18:02:47.225Z</atom:updated>
            <content:encoded><![CDATA[<p>If you have ever felt that Python is a bit contradictory, like it is interpreted but also compiled, or single-threaded yet somehow multithreaded, you are not alone. The language often described as simple can still confuse even experienced developers. This article clarifies some of these mixed signals with short, practical examples.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ts3Q95Li3T5_Bajy" /><figcaption>Photo by <a href="https://unsplash.com/@rubaitulazad?utm_source=medium&amp;utm_medium=referral">Rubaitul Azad</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Is Python Interpreted or Compiled?</h3><p>Python is interpreted, but it also compiles code internally.</p><h3>What actually happens</h3><p>When you run a .py file, the interpreter, usually CPython, compiles it into bytecode files (.pyc). This bytecode is then executed by the Python Virtual Machine (PVM).</p><pre># hello.py<br>print(&quot;Hello, world!&quot;)</pre><p>When you run:</p><pre>python hello.py</pre><p>Python compiles the code to bytecode before running it. So it is not compiled like C++, but it is also not purely interpreted line by line at runtime.</p><h3>Is Python Weakly or Strongly Typed?</h3><p>Python is strongly typed, even though it may look flexible.</p><pre>print(&quot;1&quot; + 1)  # TypeError: can only concatenate str (not &quot;int&quot;) to str</pre><p>In weakly typed languages such as JavaScript, this would result in “11”.</p><h3>But Python is dynamically typed</h3><p>You do not have to declare types before using variables.</p><pre>x = 42<br>x = &quot;now I am a string&quot;</pre><h3>You can add static typing if you want</h3><p>Using tools like mypy, you can apply optional static typing.</p><pre>def add(a: int, b: int) -&gt; int:<br>    return a + b<br><br><br>add(&quot;1&quot;, 2)  # Python runs it, but mypy will flag this</pre><h3>Is Python Single-threaded or Multithreaded?</h3><p>Python is single-threaded by default because of the Global Interpreter Lock (GIL). This means only one thread runs Python bytecode at a time, even on multi-core systems.</p><h3>Threads work but have limitations due to GIL</h3><pre>import threading<br><br>def task():<br>    print(&quot;Running...&quot;)<br>t = threading.Thread(target=task)<br>t.start()</pre><p>Threads can run, but for CPU-bound tasks they do not run in parallel.</p><h3>Real parallelism is possible with multiple processes</h3><pre>from multiprocessing import Process<br><br>def task():<br>    print(&quot;Separate process!&quot;)<br>p = Process(target=task)<br>p.start()</pre><p>Each process has its own memory space and interpreter, so it bypasses the GIL.</p><h3>A GIL-free Python is coming soon</h3><p>Python 3.13 introduces an optional no-GIL build. This means real multithreading for CPU-bound code may finally be possible. See <a href="https://peps.python.org/pep-0703/">PEP 703</a> for details.</p><h3>Summary</h3><p>Python is a flexible and pragmatic language. That flexibility often raises the question: what kind of language is it really? Here is a quick summary of how Python behaves:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2F6EpCX%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2F6EpCX%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2F6EpCX%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="894" height="341" frameborder="0" scrolling="no"><a href="https://medium.com/media/3a7abc003476e5e928ffafe42a6f81dd/href">https://medium.com/media/3a7abc003476e5e928ffafe42a6f81dd/href</a></iframe><p>At first glance, Python looks simple, but under the surface it offers complex and powerful features. Understanding these features will make you a more effective Python developer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a985156209ea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Boas Perguntas Levam a Boas Respostas: Como ORMs e SQL Imitam a Comunicação Humana]]></title>
            <link>https://hugobrilhante.medium.com/boas-perguntas-levam-a-boas-respostas-uma-vis%C3%A3o-humana-sobre-sql-e-orms-7b0c3b0ddeea?source=rss-c5f257b40127------2</link>
            <guid isPermaLink="false">https://medium.com/p/7b0c3b0ddeea</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[orm]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[banco-de-dados]]></category>
            <dc:creator><![CDATA[Hugo Brilhante]]></dc:creator>
            <pubDate>Mon, 16 Jun 2025 23:23:41 GMT</pubDate>
            <atom:updated>2025-06-17T13:46:06.622Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dm6cVtEgYyN09k61DJAxsA.png" /></figure><p>A engenharia de software pode parecer complexa até para quem já tem experiência — imagine para quem está começando. Por isso, tenho buscado aprender e ensinar a partir de analogias com o mundo real. <a href="https://medium.com/%40hugobrilhante/python-em-tr%C3%A2nsito-entendendo-concorr%C3%AAncia-com-o-caos-de-s%C3%A3o-paulo-96edbd9b13be">Se antes comparei o trânsito de São Paulo com programação concorrente em Python</a>, agora quero mostrar como SQL e ORMs se assemelham a fazer boas perguntas às pessoas certas.</p><p>Fazer uma consulta ao banco é como perguntar algo a quem entende do assunto: se a pergunta for clara e direcionada à “pessoa” (ou tabela) certa, a resposta vem precisa. Caso contrário, pode ser confusa, incompleta ou nem chegar.</p><p>Neste artigo, exploro essa analogia para ajudar você a escrever queries melhores, usar ORMs com mais consciência e melhorar o diálogo com seu banco de dados.</p><h3>Usando a imaginação</h3><p>Imagine uma redação onde pessoas escrevem, revisam e comentam artigos o tempo todo. É um ambiente cheio de perguntas: quem está escrevendo sobre IA? Qual artigo tem mais comentários? Essas trocas lembram muito o que acontece num banco de dados — autores são registros, artigos são dados interligados, comentários são interações.</p><p>Mas assim como numa redação, não adianta perguntar tudo para todos ao mesmo tempo. É preciso saber o que perguntar e a quem. Essa é a essência de uma consulta eficiente. ORMs como Django e SQLAlchemy oferecem ferramentas como select_related(), prefetch_related() e filtros que ajudam a fazer perguntas melhores — e receber respostas rápidas, completas e precisas.</p><h3>Imagina as seguintes perguntas sendo feitas por pessoas da redação…</h3><ul><li><strong>“Quem escreveu esse artigo?”</strong><br> (Alguém curioso sobre o autor de um texto)<br> → select_related(&#39;author&#39;)</li><li>“<strong>Preciso carregar detalhes dos perfis dos autores junto com os artigos.</strong>”<br>(Um editor montando a página de autor com informações do artigo e perfil)<br>→ select_related(&#39;author__profile&#39;)</li><li><strong>“Quais artigos o João já escreveu?”</strong><br> (Um editor conferindo a produção de um autor)<br> → prefetch_related(&#39;articles&#39;)</li><li><strong>“Esse artigo tem comentários, mas só me mostra os que não são spam.”</strong><br> (Leitor cansado de ver bobagens)<br> → Prefetch(&#39;comments&#39;, queryset=Comment.objects.filter(is_spam=False))</li><li><strong>“Já carreguei a lista de autores. Agora pega os artigos de cada um.”</strong><br> (A pessoa já tem parte dos dados e quer completar)<br> → prefetch_related_objects(autores, &#39;articles&#39;)</li><li><strong>“Quero todos os artigos que falem de Python ou tenham ‘programação’ no título.”</strong><br> (Buscando assuntos relacionados de forma flexível)<br> → Q(title__icontains=&#39;programação&#39;) | Q(tags__name=&#39;Python&#39;)</li><li><strong>“Me mostra só os artigos com comentários que foram marcados como úteis.”</strong><br> (Foco em conteúdo relevante)<br> → FilteredRelation(&#39;comments&#39;,condition=Q(comments__is_useful=True))</li><li><strong>“Quais são os artigos mais comentados da semana?”</strong><br> (Análise editorial de engajamento)<br> → annotate(comment_count=Count(&#39;comments&#39;))</li><li>“<strong>Só preciso dos títulos e IDs, o conteúdo pode ficar pra depois.</strong>”<br>(Evitando carregar dados desnecessários)<br>→ .values(&#39;id&#39;, &#39;title&#39;) ou .only(&#39;title&#39;) / .defer(&#39;content&#39;)</li></ul><h3>Esse seria o nosso banco de dados da redação:</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FHtEmw%2F3%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FHtEmw%2F3%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FHtEmw%2Fplain-s.png%3Fv%3D3&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="419" frameborder="0" scrolling="no"><a href="https://medium.com/media/6f58050a4f7158bcdf35a04e5391246e/href">https://medium.com/media/6f58050a4f7158bcdf35a04e5391246e/href</a></iframe><h3>E aqui estão os conceitos do ORM aplicados nesse domínio:</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FPHAnB%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FPHAnB%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FPHAnB%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="432" frameborder="0" scrolling="no"><a href="https://medium.com/media/d9711112ab5c75a5ab0d9c6b1098910a/href">https://medium.com/media/d9711112ab5c75a5ab0d9c6b1098910a/href</a></iframe><p>Agora vamos ver como essas perguntas se traduzem em consultas reais — e por que a forma como perguntamos faz toda a diferença.</p><h3>Como essas perguntas seriam feitas por um ORM como o do Django?</h3><p><em>A seguir, transformamos cada uma daquelas perguntas em exemplos reais com o ORM do Django, comparando com SQL puro e comentando sobre performance e boas práticas. Os links levam direto para cada resposta detalhada.</em></p><p><a href="https://hugobrilhante.medium.com/quem-escreveu-esse-artigo-573c46118b4b">Quem escreveu esse artigo</a>?</p><p><a href="https://medium.com/@hugobrilhante/preciso-carregar-detalhes-dos-perfis-dos-autores-junto-com-os-artigos-66a7060b5a8a">Preciso carregar detalhes dos perfis dos autores junto com os artigos</a>.</p><p><a href="https://hugobrilhante.medium.com/quais-artigos-o-jo%C3%A3o-j%C3%A1-escreveu-e1e7a8eef34b">Quais artigos o João já escreveu</a>?</p><p><a href="https://hugobrilhante.medium.com/esse-artigo-tem-coment%C3%A1rios-mas-s%C3%B3-me-mostra-os-que-n%C3%A3o-s%C3%A3o-spam-5cc32c85c9a4">Esse artigo tem comentários, mas só me mostra os que não são spam</a>.</p><p><a href="https://hugobrilhante.medium.com/j%C3%A1-carreguei-a-lista-de-autores-agora-pega-os-artigos-de-cada-um-376b03006c4e">Já carreguei a lista de autores. Agora pega os artigos de cada um</a>.</p><p><a href="https://hugobrilhante.medium.com/quero-todos-os-artigos-que-falem-de-python-ou-tenham-programa%C3%A7%C3%A3o-no-t%C3%ADtulo-caf002174d58">Quero todos os artigos que falem de Python ou tenham programação no título</a>.</p><p><a href="https://hugobrilhante.medium.com/me-mostra-s%C3%B3-os-artigos-com-coment%C3%A1rios-que-foram-marcados-como-%C3%BAteis-f223fd0f4f00">Me mostra só os artigos com comentários que foram marcados como úteis</a>.</p><p><a href="https://hugobrilhante.medium.com/quais-s%C3%A3o-os-artigos-mais-comentados-da-semana-3c280f11f72a">Quais são os artigos mais comentados da semana</a>?</p><p><a href="https://hugobrilhante.medium.com/s%C3%B3-preciso-dos-t%C3%ADtulos-e-ids-o-conte%C3%BAdo-pode-ficar-pra-depois-b0e60b77069c">Só preciso dos títulos e IDs, o conteúdo pode ficar pra depois</a>.</p><h3>Mas nem só de perguntas vive a performance: boas práticas com banco de dados</h3><p>Depois de observar como perguntas bem formuladas resultam em consultas eficientes com ORM, vale olhar mais fundo: <strong>por trás de um ORM rápido, há quase sempre um banco de dados bem cuidado</strong>.</p><p>Apesar dos ORMs abstraírem muita coisa, entender como bancos relacionais funcionam é essencial para evitar gargalos e criar soluções escaláveis.</p><h3>Assim como perguntar à pessoa certa economiza tempo, perguntar ao banco com o índice certo faz toda a diferença.</h3><p>Imagine procurar um artigo em uma pilha de papéis embaralhados. Agora imagine que há uma lista em ordem alfabética com os títulos e páginas — isso é um <strong>índice</strong>.</p><p>Um índice em banco de dados funciona do mesmo jeito: ajuda a encontrar dados muito mais rápido.</p><h4>Quando e onde usar índices:</h4><ul><li>Em colunas frequentemente usadas em filtros (WHERE), ordenações (ORDER BY) ou joins.</li><li>Em campos únicos (email, username).</li><li>Em chaves estrangeiras (relacionamentos ForeignKey).</li></ul><p>O Django, por padrão, <strong>cria índices em chaves primárias e estrangeiras</strong>. Para os demais casos, você pode usar:</p><pre>class Article(models.Model):<br>    title = models.CharField(max_length=200, db_index=True)</pre><p>Mas atenção: <strong>índices custam memória e impactam </strong><strong>INSERT/</strong><strong>UPDATE</strong>. Use-os com estratégia.</p><h3>Traga só o que você precisa</h3><p>Buscar dados demais é um dos erros mais comuns — especialmente com ORMs, onde um simples .all() pode trazer dezenas de campos que você nem usa.</p><p>Use:</p><ul><li>only(&#39;title&#39;) ou defer(&#39;content&#39;) para carregar menos campos.</li><li>values(&#39;id&#39;, &#39;title&#39;) para retornar dicionários ao invés de objetos completos.</li><li>Paginação e seleção consciente quando exibir listas.</li></ul><p>Quanto menos dados o banco precisa ler, transferir e processar, <strong>mais leve será sua aplicação como um todo</strong> — tanto no backend quanto no frontend.</p><h3>SQL puro é mais rápido, mas nem sempre mais inteligente</h3><p>ORMs nunca serão tão rápidos quanto escrever SQL manual otimizado. Isso porque eles:</p><ul><li>Precisam traduzir objetos da linguagem para instruções SQL.</li><li>Carregam dados do banco e os transformam em objetos da aplicação.</li><li>Criam joins e filtros baseados em regras genéricas.</li></ul><p>Mas o ganho está na <strong>produtividade, clareza e segurança</strong>:</p><ul><li>Você escreve menos, e mais legível.</li><li>O risco de SQL injection cai praticamente a zero.</li><li>Alterações no schema se propagam com migrations.</li></ul><p>Se você precisa extrair um relatório complexo com várias agregações e subqueries? Use SQL bruto (.raw() ou text() no SQLAlchemy). Mas para a maioria dos casos — cadastro, listagem, busca simples — o ORM é mais que suficiente <strong>e perfeitamente performático, quando usado com consciência</strong>.</p><h3>Medir é melhor do que adivinhar</h3><p>Ferramentas como o <a href="https://django-debug-toolbar.readthedocs.io/en/latest/">Django Debug Toolbar</a> ou o comando EXPLAIN ANALYZE do PostgreSQL são seus aliados para entender:</p><ul><li>Quantas queries foram feitas?</li><li>Qual foi o tempo de execução?</li><li>Algum JOIN trouxe milhares de linhas desnecessárias?</li></ul><p>A performance não está no número de queries apenas, mas <strong>na qualidade e custo de cada uma</strong>.</p><h3>Conclusão</h3><p>Fizemos só algumas perguntas, mas já é possível perceber o quão a vida real e a programação são semelhantes. Usei o ORM do Django como guia, mas há outros tão poderosos quanto — como o SQLAlchemy — com ferramentas equivalentes e a mesma intenção: <strong>fazer a ponte entre nossas perguntas humanas e a linguagem dos bancos de dados</strong>.</p><p>No fim das contas, ORMs não são vilões da performance. Eles podem ser incrivelmente eficientes quando usamos os recursos certos, como select_related(), prefetch_related(), annotate(), only() e Q(). A chave está em conhecer o que está acontecendo nos bastidores e perguntar com clareza e propósito.</p><p>Mas também é essencial lembrar que bons índices, consultas enxutas e modelagens bem pensadas são o que dão base para qualquer abstração funcionar bem. Afinal, até a pergunta mais bem formulada pode ser mal respondida se o ouvinte — nesse caso, o banco de dados — não estiver preparado para escutar.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7b0c3b0ddeea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Preciso carregar detalhes dos perfis dos autores junto com os artigos.”]]></title>
            <link>https://hugobrilhante.medium.com/preciso-carregar-detalhes-dos-perfis-dos-autores-junto-com-os-artigos-66a7060b5a8a?source=rss-c5f257b40127------2</link>
            <guid isPermaLink="false">https://medium.com/p/66a7060b5a8a</guid>
            <category><![CDATA[orm]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[sql]]></category>
            <dc:creator><![CDATA[Hugo Brilhante]]></dc:creator>
            <pubDate>Mon, 16 Jun 2025 23:21:57 GMT</pubDate>
            <atom:updated>2025-06-16T23:21:57.341Z</atom:updated>
            <content:encoded><![CDATA[<p><em>(Um editor montando a página de autor com informações do artigo e perfil)</em><br> → select_related(&#39;author__profile&#39;)</p><h3>❌ Sem select_related(), com acesso ingênuo aos relacionamentos</h3><pre>articles = Article.objects.all()<br>for article in articles:<br>    print(article.author.profile.bio)</pre><p>Esse tipo de código parece inofensivo, mas está escondendo um <strong>problema sério de performance</strong>:</p><ul><li>1 query para buscar os artigos</li><li>1 query para cada author</li><li>1 query para cada profile</li></ul><p>Se houver 50 artigos, teremos até <strong>1 + 50 + 50 = 101 queries</strong>. Isso mata qualquer aplicação sob carga moderada.</p><h4>SQL gerado (simplificado):</h4><pre>-- Artigos<br>SELECT * FROM article;<br>-- Para cada artigo:<br>SELECT * FROM author WHERE id = {article.author_id};<br>SELECT * FROM profile WHERE author_id = {author.id};</pre><h3>✅ Com select_related(&#39;author__profile&#39;)</h3><pre>articles = Article.objects.select_related(&#39;author__profile&#39;)<br>for article in articles:<br>    print(article.author.profile.bio)</pre><p>Agora o Django junta tudo com JOINs internos, resolvendo a consulta <strong>com apenas uma query</strong>. E melhor: já retorna todos os dados estruturados como objetos Python.</p><h4>SQL equivalente:</h4><pre>SELECT<br>    article.*,<br>    author.*,<br>    profile.*<br>FROM article<br>JOIN author ON article.author_id = author.id<br>JOIN profile ON profile.author_id = author.id;</pre><h3>📈 Por que é melhor?</h3><ul><li><strong>Uma única consulta</strong> com múltiplos JOINs bem otimizados</li><li><strong>Economia drástica de round-trips</strong></li><li>Ideal para carregar objetos conectados por relações diretas (ForeignKey, OneToOne)</li><li>Aumenta a coesão do carregamento: você <strong>sabe o que virá na memória</strong></li></ul><h3>⚠️ Uma observação importante sobre select_related(&#39;author__profile&#39;)</h3><p>No primeiro exemplo que usamos select_related(&#39;author&#39;), estávamos lidando com <strong>uma única relação direta</strong>: o artigo possui um author via ForeignKey.<br> Já agora, com select_related(&#39;author__profile&#39;), navegamos <strong>por duas relações encadeadas</strong>:</p><ol><li>Article → Author (ForeignKey)</li><li>Author → Profile (OneToOne)</li></ol><p>Ou seja, o Django consegue montar um JOIN <strong>em cadeia</strong>, atravessando múltiplas tabelas que têm relações diretas. Isso é possível porque tanto ForeignKey quanto OneToOneField são suportados por select_related().</p><p>Esse é um ótimo exemplo de como o ORM pode simplificar o que seria uma SQL complexa, contanto que as relações sejam bem definidas e seguras para serem resolvidas em JOINs.</p><p>Um bom sinal de que você deveria usar select_related() é quando acessa .algumacoisa.algo dentro de um loop. Se você vê isso, pare e pense: <strong>posso fazer isso em uma query só?</strong></p><blockquote><em>🔎 Este artigo faz parte da série </em><strong>&quot;Boas Perguntas Levam a Boas Respostas&quot;<em>.</em></strong><em> Para conferir todas as comparações entre perguntas do mundo real e consultas com ORMs e SQL, acesse o texto principal: </em><a href="https://medium.com/@hugobrilhante/boas-perguntas-levam-a-boas-respostas-uma-vis%C3%A3o-humana-sobre-sql-e-orms-7b0c3b0ddeea"><em>Boas Perguntas Levam a Boas Respostas</em></a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=66a7060b5a8a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Só preciso dos títulos e IDs, o conteúdo pode ficar pra depois.”]]></title>
            <link>https://hugobrilhante.medium.com/s%C3%B3-preciso-dos-t%C3%ADtulos-e-ids-o-conte%C3%BAdo-pode-ficar-pra-depois-b0e60b77069c?source=rss-c5f257b40127------2</link>
            <guid isPermaLink="false">https://medium.com/p/b0e60b77069c</guid>
            <category><![CDATA[django]]></category>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[orm]]></category>
            <dc:creator><![CDATA[Hugo Brilhante]]></dc:creator>
            <pubDate>Mon, 16 Jun 2025 01:39:54 GMT</pubDate>
            <atom:updated>2025-06-16T01:39:54.514Z</atom:updated>
            <content:encoded><![CDATA[<p><em>(Evitando carregar dados desnecessários)</em><br> → .values(&#39;id&#39;, &#39;title&#39;) ou .only(&#39;title&#39;) / .defer(&#39;content&#39;)</p><p>Imagine uma situação comum: você quer montar uma <strong>listagem de artigos</strong>, talvez num painel, num dropdown ou numa busca simples.</p><p>Se você fizer isso sem se preocupar com otimização:</p><pre>Article.objects.all()</pre><p>Você está trazendo <strong>todos os campos de todos os artigos</strong>, incluindo conteúdos longos, imagens, timestamps, etc. — mesmo que só vá usar o título.</p><h3>❌ Problemas dessa abordagem “preguiçosa”:</h3><ul><li><strong>Mais dados transferidos</strong> do banco → app → cliente.</li><li>Uso desnecessário de memória e largura de banda.</li><li>Se você tem milhares de artigos, a performance cai visivelmente.</li><li>A listagem, que deveria ser rápida, pode parecer lenta.</li></ul><h3>✅ Otimização 1: Use .values() para buscar apenas os dados desejados</h3><pre>Article.objects.values(&#39;id&#39;, &#39;title&#39;)</pre><h4>SQL equivalente:</h4><pre>SELECT id, title FROM article;</pre><ul><li>Retorna um <strong>dicionário por artigo</strong>, só com os campos pedidos.</li><li>Ideal para APIs, listagens simples e serialização.</li><li><strong>Não carrega objetos completos</strong>, portanto não tem acesso a métodos personalizados dos models.</li></ul><h3>✅ Otimização 2: Use .only() ou .defer() para carregar parcialmente o model</h3><pre>Article.objects.only(&#39;title&#39;)<br># ou<br>Article.objects.defer(&#39;content&#39;)</pre><h4>Comportamento:</h4><ul><li>O Django carrega <strong>apenas os campos pedidos</strong> no primeiro momento.</li><li>Se você acessar depois article.content, ele faz um SQL extra para buscá-lo — isso é o chamado <em>lazy loading</em>.</li></ul><h3>✅ Quando usar cada um?</h3><pre>| Caso de Uso                        | Recomendado                   |<br>| ---------------------------------- | ----------------------------- |<br>| Listagem rápida / API JSON         | `values()`                    |<br>| Precisa do model, mas só usa parte | `only()` ou `defer()`         |<br>| Campos muito grandes (ex: texto)   | `defer(&#39;campo_grande&#39;)`       |<br>| Precisa de joins e métodos model   | `only()` + `select_related()` |</pre><h3>🧠 Boas práticas:</h3><ul><li><strong>Evite </strong><strong>*.all() sem necessidade</strong>.</li><li>Use values() para buscas leves e rápidas.</li><li>Combine only() com select_related() para otimizar sem perder estrutura.</li><li>Sempre pense: <em>preciso realmente de todos esses dados agora?</em></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0e60b77069c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Quais são os artigos mais comentados da semana?”]]></title>
            <link>https://hugobrilhante.medium.com/quais-s%C3%A3o-os-artigos-mais-comentados-da-semana-3c280f11f72a?source=rss-c5f257b40127------2</link>
            <guid isPermaLink="false">https://medium.com/p/3c280f11f72a</guid>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[orm]]></category>
            <category><![CDATA[django]]></category>
            <dc:creator><![CDATA[Hugo Brilhante]]></dc:creator>
            <pubDate>Mon, 16 Jun 2025 01:30:40 GMT</pubDate>
            <atom:updated>2025-06-16T01:30:40.770Z</atom:updated>
            <content:encoded><![CDATA[<p><em>(Análise editorial de engajamento)</em><br> → .annotate(comment_count=Count(&#39;comments&#39;))</p><h3>❌ Sem annotate() – seria necessário processar em Python (caro e ineficiente)</h3><p>Uma tentativa ingênua seria buscar todos os artigos com seus comentários e contar manualmente:</p><pre>articles = Article.objects.prefetch_related(&#39;comments&#39;)<br><br># Depois, em Python:<br>for article in articles:<br>    count = len(article.comments.all())</pre><h4>Problemas:</h4><ul><li>A consulta vai carregar <strong>todos os comentários</strong> na memória.</li><li>Mesmo que use prefetch_related(), ainda são <strong>duas queries pesadas</strong>: uma para artigos, outra para comentários.</li><li>O loop em Python <strong>não escala bem</strong> com muitos dados.</li></ul><h3>✅ Com annotate() – conta direto no banco de forma eficiente</h3><pre>from django.db.models import Count<br>from django.utils import timezone<br>from datetime import timedelta<br><br>week_ago = timezone.now() - timedelta(days=7)<br><br>articles = Article.objects.filter(<br>    created_at__gte=week_ago<br>).annotate(<br>    comment_count=Count(&#39;comments&#39;)<br>).order_by(&#39;-comment_count&#39;)</pre><h4>SQL equivalente:</h4><pre>SELECT article.*, COUNT(comment.id) AS comment_count<br>FROM article<br>LEFT JOIN comment ON comment.article_id = article.id<br>WHERE article.created_at &gt;= NOW() - INTERVAL &#39;7 days&#39;<br>GROUP BY article.id<br>ORDER BY comment_count DESC;</pre><h3>✅ Benefícios dessa abordagem:</h3><ul><li>Tudo é processado <strong>no banco de dados</strong>, que é otimizado para esse tipo de agregação.</li><li>Traz apenas os campos e dados necessários.</li><li>Permite <strong>ordenar pelos mais comentados</strong>, algo custoso de fazer em Python.</li><li>A cláusula LEFT JOIN garante que artigos <strong>sem comentários também apareçam</strong>, com comment_count = 0.</li></ul><h3>🧠 Boas práticas:</h3><ul><li>Sempre use annotate() para agregações como Count, Sum, Avg, etc.</li><li>Use filter() antes do annotate() para restringir o conjunto de dados — no caso, limitamos à última semana.</li><li>Combine com order_by() para rankings e dashboards.</li><li>Verifique se o campo usado no filter (created_at, article_id) está indexado.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c280f11f72a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Me mostra só os artigos com comentários que foram marcados como úteis.”]]></title>
            <link>https://hugobrilhante.medium.com/me-mostra-s%C3%B3-os-artigos-com-coment%C3%A1rios-que-foram-marcados-como-%C3%BAteis-f223fd0f4f00?source=rss-c5f257b40127------2</link>
            <guid isPermaLink="false">https://medium.com/p/f223fd0f4f00</guid>
            <category><![CDATA[orm]]></category>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[django]]></category>
            <dc:creator><![CDATA[Hugo Brilhante]]></dc:creator>
            <pubDate>Mon, 16 Jun 2025 01:25:35 GMT</pubDate>
            <atom:updated>2025-06-16T01:25:35.353Z</atom:updated>
            <content:encoded><![CDATA[<p><em>(Foco em conteúdo relevante)</em><br> → FilteredRelation(&#39;comments&#39;, condition=Q(comments__is_useful=True))</p><h3>❌ Sem FilteredRelation – join desnecessariamente amplo e resultado incorreto</h3><pre>Article.objects.filter(comments__is_useful=True)</pre><p>Essa consulta até <strong>parece correta</strong>, mas tem um problema: o <strong>join inclui todos os comentários</strong>, e o filtro é aplicado <strong>após</strong> o join.</p><h4>SQL gerado (padrão):</h4><pre>SELECT article.*<br>FROM article<br>JOIN comment ON comment.article_id = article.id<br>WHERE comment.is_useful = TRUE;</pre><h4>Problemas:</h4><ul><li>Traz todos os comentários para o join, o que <strong>pode impactar a performance</strong>, especialmente se o volume for alto.</li><li>Se você quiser trazer os comentários depois com prefetch_related, vai trazer <strong>todos</strong>, não apenas os úteis (isso gera um <em>N+1 problem</em> disfarçado).</li><li>O join não é explícito quanto ao filtro, dificultando o entendimento e o planejamento da execução pela engine do banco.</li></ul><h3>✅ Com FilteredRelation – join controlado e objetivo claro</h3><pre>from django.db.models import Q, FilteredRelation<br><br>articles = Article.objects.annotate(<br>    useful_comments=FilteredRelation(&#39;comments&#39;, condition=Q(comments__is_useful=True))<br>).filter(<br>    useful_comments__isnull=False<br>)</pre><h4>SQL gerado (com filtro no JOIN):</h4><pre>SELECT article.*<br>FROM article<br>LEFT JOIN comment ON comment.article_id = article.id AND comment.is_useful = TRUE<br>WHERE comment.id IS NOT NULL;</pre><h3>✅ Benefícios dessa abordagem:</h3><ul><li>O filtro is_useful = TRUE é aplicado <strong>no momento do JOIN</strong>, economizando recursos do banco.</li><li>O resultado só inclui artigos com pelo menos <strong>um comentário útil</strong>.</li><li>Evita trazer todos os comentários e filtrar depois em Python.</li><li><strong>Mais previsível e performático</strong> para grandes volumes de dados.</li></ul><h3>🧠 Boas práticas:</h3><ul><li>Use FilteredRelation para <strong>filtrar antes de fazer o join</strong>, quando só alguns dados relacionados interessam.</li><li>Combine com prefetch_related() com Prefetch() customizado, se quiser carregar os dados úteis depois.</li><li>Garanta que o campo filtrado (is_useful) esteja <strong>indexado</strong> para acelerar o join.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f223fd0f4f00" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Quero todos os artigos que falem de Python ou tenham ‘programação’ no título.”]]></title>
            <link>https://hugobrilhante.medium.com/quero-todos-os-artigos-que-falem-de-python-ou-tenham-programa%C3%A7%C3%A3o-no-t%C3%ADtulo-caf002174d58?source=rss-c5f257b40127------2</link>
            <guid isPermaLink="false">https://medium.com/p/caf002174d58</guid>
            <category><![CDATA[orm]]></category>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[django]]></category>
            <dc:creator><![CDATA[Hugo Brilhante]]></dc:creator>
            <pubDate>Mon, 16 Jun 2025 01:12:39 GMT</pubDate>
            <atom:updated>2025-06-16T01:12:39.837Z</atom:updated>
            <content:encoded><![CDATA[<p><em>(Buscando assuntos relacionados de forma flexível)</em><br> → Q(title__icontains=&#39;programação&#39;) | Q(tags__name=&#39;Python&#39;)</p><h3>❌ Sem Q() – a lógica sai errada e a consulta é limitante</h3><p>Se tentarmos fazer a busca usando filtros diretos:</p><pre>Article.objects.filter(<br>    title__icontains=&#39;programação&#39;,<br>    tags__name=&#39;Python&#39;<br>)</pre><p>Esse código aplica um <strong>AND lógico</strong> entre os filtros. Isso significa que ele <strong>só retorna artigos que tenham &#39;programação&#39; no título E estejam marcados com a tag &#39;Python&#39;</strong>, o que não atende ao pedido original.</p><h4>SQL equivalente (limitado):</h4><pre>SELECT article.*<br>FROM article<br>JOIN article_tags ON article.id = article_tags.article_id<br>JOIN tag ON article_tags.tag_id = tag.id<br>WHERE article.title ILIKE &#39;%programação%&#39;<br>  AND tag.name = &#39;Python&#39;;</pre><h3>🚫 Problemas com essa abordagem:</h3><ul><li>É <strong>muito restritiva</strong>, não cobre casos em que só o título ou só a tag atende ao critério.</li><li>Pode gerar <strong>falsos negativos</strong>: muitos artigos relevantes não serão incluídos.</li><li><strong>Não traduz corretamente a intenção da pergunta feita pelo usuário.</strong></li></ul><h3>✅ Com Q() – lógica expressiva e flexível</h3><pre>from django.db.models import Q<br><br>articles = Article.objects.filter(<br>    Q(title__icontains=&#39;programação&#39;) | Q(tags__name=&#39;Python&#39;)<br>).distinct()</pre><h4>SQL equivalente (correto):</h4><pre>SELECT DISTINCT article.*<br>FROM article<br>LEFT JOIN article_tags ON article.id = article_tags.article_id<br>LEFT JOIN tag ON article_tags.tag_id = tag.id<br>WHERE article.title ILIKE &#39;%programação%&#39;<br>   OR tag.name = &#39;Python&#39;;</pre><h3>📌 Por que usar DISTINCT?</h3><p>Como a relação Article ↔ Tag é <strong>muitos-para-muitos</strong>, o JOIN pode trazer <strong>linhas duplicadas</strong> para o mesmo artigo (um para cada tag relevante).<br> O distinct() remove essas duplicatas, garantindo um resultado limpo.</p><h3>🧠 Boas práticas:</h3><ul><li>Use Q() sempre que precisar compor <strong>filtros com </strong><strong>OR, </strong><strong>AND, </strong><strong>NOT</strong>.</li><li>Combine com distinct() em joins N:M para evitar duplicidade nos resultados.</li><li>Garanta que os campos buscados (ex: tag.name) estejam <strong>indexados</strong> para performance.</li><li>Sempre que possível, limite os campos retornados com .only() ou .values() se não for usar todos.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=caf002174d58" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Já carreguei a lista de autores. Agora pega os artigos de cada um.”]]></title>
            <link>https://hugobrilhante.medium.com/j%C3%A1-carreguei-a-lista-de-autores-agora-pega-os-artigos-de-cada-um-376b03006c4e?source=rss-c5f257b40127------2</link>
            <guid isPermaLink="false">https://medium.com/p/376b03006c4e</guid>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[orm]]></category>
            <category><![CDATA[django]]></category>
            <dc:creator><![CDATA[Hugo Brilhante]]></dc:creator>
            <pubDate>Sun, 15 Jun 2025 23:30:58 GMT</pubDate>
            <atom:updated>2025-06-15T23:30:58.249Z</atom:updated>
            <content:encoded><![CDATA[<p><em>(A pessoa já tem parte dos dados e quer completar)</em><br> → prefetch_related_objects(autores, &#39;articles&#39;)</p><h3>❌ Sem otimização — faz uma query por autor (N+1)</h3><pre>for author in autores:<br>    articles = author.article_set.all()<br>    print(f&#39;{author.name} escreveu {articles.count()} artigos&#39;)</pre><p>Se você tiver 10 autores, isso gera <strong>1 query para cada autor</strong>. Com 100, são 100 queries.<br> Esse é o famoso <strong>problema N+1</strong>, um dos maiores vilões de performance em aplicações ORM.</p><h3>✅ Com prefetch_related_objects() – reaproveitando a lista já carregada</h3><pre>from django.db.models import prefetch_related_objects<br><br># autores já carregados com alguma lógica anterior<br>prefetch_related_objects(autores, &#39;articles&#39;)<br><br>for author in autores:<br>    for article in author.articles.all():<br>        print(article.title)</pre><p>Dessa forma, o Django faz <strong>só duas queries</strong>:</p><pre>-- Query 1: lista de autores (já feita)<br>SELECT * FROM author WHERE ...<br><br>-- Query 2: todos os artigos desses autores<br>SELECT * FROM article WHERE author_id IN (...);</pre><p>E o ORM relaciona tudo em memória.</p><h3>📈 Vantagens dessa abordagem:</h3><ul><li><strong>Evita consultas repetidas</strong> (N+1 resolvido)</li><li><strong>Não exige refazer a query original</strong></li><li>Ideal para <strong>quando os objetos já foram obtidos por outro meio</strong> (ex: cache, API externa, lógica separada)</li></ul><h3>🧠 Curiosidade:</h3><p>prefetch_related_objects() funciona <strong>fora de um </strong><strong>QuerySet</strong> — é isso que o diferencia dos demais. Ele é como um &quot;patch&quot; que <strong>completa dados já carregados</strong>, respeitando a lógica do ORM.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=376b03006c4e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Esse artigo tem comentários, mas só me mostra os que não são spam.”]]></title>
            <link>https://hugobrilhante.medium.com/esse-artigo-tem-coment%C3%A1rios-mas-s%C3%B3-me-mostra-os-que-n%C3%A3o-s%C3%A3o-spam-5cc32c85c9a4?source=rss-c5f257b40127------2</link>
            <guid isPermaLink="false">https://medium.com/p/5cc32c85c9a4</guid>
            <category><![CDATA[orm]]></category>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[django]]></category>
            <dc:creator><![CDATA[Hugo Brilhante]]></dc:creator>
            <pubDate>Sun, 15 Jun 2025 23:21:49 GMT</pubDate>
            <atom:updated>2025-06-16T15:55:24.133Z</atom:updated>
            <content:encoded><![CDATA[<p><em>(Leitor cansado de ver bobagens)</em><br> → Prefetch(&#39;comments&#39;, queryset=Comment.objects.filter(is_spam=False))</p><h3>❌ Acesso direto — todos os comentários vêm (inclusive spam)</h3><pre>article = Article.objects.get(id=42)<br>comments = article.comments.all()</pre><p>Esse código carrega <strong>todos os comentários</strong>, e se quiser exibir só os que não são spam, o filtro seria feito em Python:</p><pre>non_spam = [c for c in comments if not c.is_spam]</pre><h4>Problemas:</h4><ul><li><strong>Todos os dados trafegam</strong> da base, mesmo os irrelevantes</li><li><strong>Mais carga na aplicação</strong>, filtrando no Python</li><li><strong>Lento em grandes volumes</strong> (ex: artigos virais com milhares de comentários)</li></ul><h3>✅ Com Prefetch() – filtrando antes de chegar na aplicação</h3><pre>from django.db.models import Prefetch<br><br>article = Article.objects.prefetch_related(<br>    Prefetch(&#39;comments&#39;, queryset=Comment.objects.filter(is_spam=False))<br>).get(id=42)<br><br>for comment in article.comments.all():<br>    print(comment.text)</pre><p>Agora o Django monta duas queries:</p><pre>-- Query 1: Artigo<br>SELECT * FROM article WHERE id = 42;<br>-- Query 2: Comentários válidos<br>SELECT * FROM comment WHERE article_id = 42 AND is_spam = false;</pre><h3>🧠 Benefícios claros:</h3><ul><li><strong>Evita tráfego desnecessário</strong>: não traz o que será descartado</li><li><strong>Menos memória e CPU no backend</strong></li><li><strong>Intenção clara no código</strong>: a lógica do que é útil está no ORM, não espalhada na view</li></ul><h3>⚠️ Observação: essa pergunta parece similar àquela do autor revisando comentários, mas há uma sutil diferença</h3><p>Antes, o foco era <strong>o autor acessando vários artigos e seus comentários válidos</strong>. Agora, é <strong>um leitor acessando um artigo específico</strong>, e só interessado nos comentários limpos.</p><p>A lógica é a mesma (Prefetch() com filtro), mas o <strong>contexto de uso</strong> reforça o motivo do controle: trazer apenas o que importa <strong>para aquele papel no sistema</strong>.</p><blockquote><em>🔎 Este artigo faz parte da série </em>“Boas Perguntas Levam a Boas Respostas”<em>. Para conferir todas as comparações entre perguntas do mundo real e consultas com ORMs e SQL, acesse o texto principal: </em><a href="https://medium.com/@hugobrilhante/boas-perguntas-levam-a-boas-respostas-uma-vis%C3%A3o-humana-sobre-sql-e-orms-7b0c3b0ddeea"><em>Boas Perguntas Levam a Boas Respostas</em></a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5cc32c85c9a4" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>