<?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 Paulo Schmitz on Medium]]></title>
        <description><![CDATA[Stories by Paulo Schmitz on Medium]]></description>
        <link>https://medium.com/@pschmitzjr?source=rss-7d7fe1d45e08------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*wvDvYV9wCj1EU2Y6J6_Osg.jpeg</url>
            <title>Stories by Paulo Schmitz on Medium</title>
            <link>https://medium.com/@pschmitzjr?source=rss-7d7fe1d45e08------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 07:19:34 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@pschmitzjr/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[CRISP-DM: organize-se nos seus projetos]]></title>
            <link>https://medium.com/@pschmitzjr/crisp-dm-organize-se-nos-seus-projetos-9b6159cdc6af?source=rss-7d7fe1d45e08------2</link>
            <guid isPermaLink="false">https://medium.com/p/9b6159cdc6af</guid>
            <category><![CDATA[data]]></category>
            <category><![CDATA[crisp-dm]]></category>
            <category><![CDATA[framework]]></category>
            <category><![CDATA[data-analysis]]></category>
            <category><![CDATA[organization]]></category>
            <dc:creator><![CDATA[Paulo Schmitz]]></dc:creator>
            <pubDate>Fri, 26 Apr 2024 14:58:00 GMT</pubDate>
            <atom:updated>2024-04-26T14:58:00.985Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/556/1*asV5hWorJ2m2OjBM6_O6PQ.png" /></figure><p>Você já se sentiu perdido durante a execução de um projeto de dados? Bateu aquela indecisão: “E agora? O que devo fazer? Para onde devo seguir a partir daqui?”</p><p>Uma ótima forma de se organizar em meio a tantas tarefas existentes na hora de realizar um projeto é adotando uma boa metodologia. E hoje, falaremos sobre uma delas.</p><p>Um spoiler: começa com CRISP e termina com DM!</p><p>O CRISP-DM, que vem da sigla em inglês <em>Cross Industry Standard Process for Data Mining</em>, é uma metodologia muito útil que pode ser sua maior aliada em seu próximo trabalho!</p><p>O CRISP-DM separa o projeto em 6 etapas:</p><ol><li><strong>Entendimento do Negócio</strong>;</li><li><strong>Entendimento dos Dados</strong>;</li><li><strong>Preparação dos Dados</strong>;</li><li><strong>Modelagem</strong>;</li><li><strong>Avaliação</strong>;</li><li><strong>Implementação</strong>.</li></ol><p>Vamos abordar cada um desses passos na sequência.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*23TGb2yiLYHsE6R2.png" /></figure><h3>Entendimento do Negócio</h3><p>Na primeira etapa, é definido o <strong>objetivo principal </strong>do projeto. Afinal, por qual motivo ele será iniciado? Qual problema ele pretende resolver? Quais os resultados esperados para considerá-lo satisfatório?</p><p>Essa etapa acaba sendo bastante negligenciada, principalmente em projetos para portfolio, seja por falta de conhecimento dos processos ou pelo desejo de já sair colocando a mão na massa.</p><p>Mas, sem dúvida, é a etapa mais importante de todas! Porque, sem ela, não temos um porquê da execução do projeto e, logo, ele nem deveria existir.</p><p>Então, antes de sair criando código, visuais ou fazendo análises, tente responder as perguntas mencionadas no início do tópico.</p><p>Conheça o contexto em que sua problemática está envolvida, pesquise um panorama geral mínimo para que você não siga por caminhos que não fazem sentido algum para a resolução do seu problema.</p><h4>Custo-benefício</h4><p>Tudo nesta vida tem um <strong>custo</strong>. Mesmo que não seja monetário, temos o gasto de tempo e o famoso custo de oportunidade que, se analisarmos a fundo, acabam todos retornando à questão monetária.</p><p>Por essa razão, devemos, antes de tudo, colocar na balança se o que estamos prestes a iniciar será realmente benéfico e metrificar o <strong>quanto</strong> irá beneficiar a empresa ou nosso cliente.</p><p>É interessante, para cada passo a ser seguido, levantar quais custos tangíveis e intangíveis serão necessários. Em seguida, analisar como esse passo impactaria no projeto e avaliar o quão benéfico seria.</p><p>Com isso, podemos definir se aquilo é realmente necessário em uma fase inicial, ou se pode ser deixado para versões ou projetos futuros.</p><h4>Premissas</h4><p>Quanto mais informação você tiver sobre a área a ser estudada, melhores serão suas premissas iniciais para iniciar a execução do seu projeto.</p><p>Estas não são nada mais do que considerações a serem feitas. Imagine que você está analisando a ocorrência de <em>churn</em> em uma empresa: uma premissa inicial pode ser considerar que, para um cliente ser considerado como <em>churn</em>, ele deverá apresentar, no mínimo, 180 dias sem utilizar o serviço da empresa.</p><p>Claro que, em casos reais, isso deve ser muito bem acordado entre as áreas responsáveis ou com as partes interessadas.</p><h4>Métricas de sucesso</h4><p>Ok, chegaremos a um resultado, mas como saberei se ele é adequado? Quais métricas irei levar em consideração para isso?</p><p>Imagine nosso cenário hipotético sobre o projeto de <em>churn </em>mencionado anteriormente. Uma métrica de sucesso poderia ser definida como a redução em 10% na taxa de clientes que param de usar os serviços da empresa.</p><p>Isso nos ajuda não só a ter um caminho mais centrado e a não ficar explorando diversos cenários que não levarão a lugar algum, mas também nos fornece um <strong>critério de parada</strong> para definirmos um ponto final no projeto e evitar trabalhar para sempre no mesmo projeto.</p><p>Lembre-se: nunca teremos o modelo perfeito, o projeto perfeito, ou a métrica perfeita. Não se apegue à perfeição!</p><h4>Documentação</h4><p>Escreva! Se o seu projeto será visto apenas por você, ele não deveria nem existir!</p><p>Portanto, documente cada passo, cada tarefa realizada, cada premissa definida da forma mais clara possível. Isso ajudará as partes responsáveis a entender tudo o que você fez e também (principalmente) a você mesmo, caso revisite o projeto depois de um tempo e não se recorde de algum ponto do mesmo</p><p>É claro que essa etapa continuará sendo aplicada durante todo o projeto, mas é no próprio entendimento dos dados que devemos iniciar a documentação do trabalho.</p><h3>Entendimento dos Dados</h3><p>Nossa segunda etapa é aquela em que os dados são <strong>obtidos</strong>, caso ainda não o tenham sido, e <strong>explorados</strong>.</p><p>Aqui, começamos a pôr a mão na massa! Definimos as ferramentas e técnicas a serem utilizadas para realizar a análise exploratória, como os tipos de gráficos para visualização, funções estatísticas para determinar o padrão e distribuição dos dados e a relação entre as variáveis do(s) conjunto(s) de dado(s).</p><h4>Análise univariada</h4><p>Podemos utilizar das análises univariadas para verificar o comportamento da variável isolada.</p><p>Para isso, o primeiro passo é conhecer nossa variável. Ela é categórica? Numérica? Que tipo de informação ela nos traz? Com essas informações, podemos selecionar as técnicas mais adequadas para analisá-la.</p><p>Se a variável é numérica, talvez possamos calcular a média, mediana, desvio padrão, entre outras métricas. Ao mesmo tempo, podemos plotá-la em um histograma ou box plot para conhecer sua distribuição e identificar outliers. Além disso, podemos levantar hipóteses e realizar testes estatísticos para extrair informações valiosas sobre ela.</p><p>Deixando claro que estes foram só alguns exemplos, pois não seria viável abordar tudo aqui, uma vez que o foco do artigo é outro.</p><h4>Análise bivariada</h4><p>Como o nome sugere, a análise bivariada nos permite compreender as relações que uma variável tem em comparação com outra.</p><p>Algumas técnicas básicas incluem a criação de tabelas de frequência, gráficos de dispersão e a aplicação de métodos estatísticos de correlação, como o coeficiente de correlação de Pearson.</p><p>Claro que aqui podemos testar todas as combinações possíveis de variáveis, mas o ideal é focar naquela que importa: a variável-alvo que desejamos otimizar. Vamos lembrar de evitar atirar para todos os lados e focar no real objetivo do trabalho.</p><h3>Preparação dos Dados</h3><p>Conhecendo bem os dados, podemos realizar a seleção, limpeza e tratamento deles.</p><p>Entender quais variáveis irão agregar ao nosso problema é crucial para conseguirmos efetuar uma boa modelagem.</p><p>“Essa variável que mostra a altura da pessoa irá nos ajudar a descobrir se ele vai comprar nosso produto?” Muito provavelmente não (a não ser que sejamos uma loja especializada em produtos de basquete, rs), então, não faz sentido mantê-la em nosso projeto.</p><p>É claro que uma <strong>seleção </strong>prévia já é feita na fase de entendimento dos dados, mas aqui podemos utilizar recursos mais avançados para determinar se aquela variável agregará valor ou não para nosso estudo estatístico ou modelo de aprendizado de máquina.</p><p>Um exemplo disso é a correlação existente entre variáveis. A multicolinearidade pode prejudicar a interpretação dos coeficientes dos preditores em modelos de regressão, levando a estimativas imprecisas e, consequentemente, a uma diminuição na confiabilidade do modelo.</p><p>Já a parte de <strong>limpar </strong>e <strong>tratar </strong>os dados envolve lidar com a <strong>qualidade</strong> dos dados. Remover instâncias duplicadas, valores ausentes ou <em>outliers</em>, se necessário para o problema, faz parte das etapas de limpeza.</p><p>O tratamento é feito para reformular variáveis, transformando seus tipos (como datas que estão formatadas como texto) e retirando informação desnecessária (como, por exemplo, retirar o horário em uma variável de data de nascimento).</p><p>É, talvez, a etapa menos complexa, mas que pode consumir um tempo considerável do projeto, dependendo da <strong>qualidade </strong>dos dados obtidos.</p><h3>Modelagem</h3><p>O momento mais esperado! É a etapa em que são definidas as técnicas estatísticas cabíveis ao problema e, posteriormente, seu <strong>desenvolvimento</strong>.</p><p>Muitos já pensam em aplicar imediatamente um algoritmo de <em>Machine Learning</em> muito robusto e muitas vezes estão usando um canhão contra uma simples formiga.</p><p>Pense. É realmente necessário um modelo avançado de aprendizado de máquina? Uma simples regressão ou até mesmo um teste estatístico não resolveria nosso problema? Comece com o simples e vá sofisticando caso <strong>necessário</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0Bbp6sIwRw6YOazAorngIg.png" /><figcaption>Técnicas estatísticas para cada tipo de variável. Fonte: HOWELL, D. C. <strong>Statistical methods for psychology</strong>. 7. ed. Belmont, Ca: Thomson Wadsworth, 2010. p. 10</figcaption></figure><p>Todas as etapas anteriores serviram como base para selecionarmos as ferramentas adequadas para resolver o problema que estamos enfrentando. Aqui, podemos entender melhor o porquê da importância de premissas bem definidas e de um ótimo entendimento do negócio.</p><p>Por isso, por vezes precisamos retornar às fases anteriores para aprimorá-las e adequar nosso conhecimento sobre o problema e, também, refinar ainda mais nosso conjunto de dados. Lembre-se do ditado: “<em>Garbage in, garbage out</em>”; sem dados de qualidade, não existe um modelo de qualidade!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*3qgnvJWKJG5u-cyKypIxOw.jpeg" /><figcaption>Framework dos principais algoritmos de Machine Learning<em>. </em>Fonte: Macruz, Fabíola &amp; Dias, Ana &amp; Andrade, Celi &amp; Nucci, Mariana &amp; Rimkus, Carolina &amp; Lucato, Leandro &amp; Rocha, Antônio &amp; Kitamura, Felipe. (2024). The new era of artificial intelligence in neuroradiology: current research and promising tools. Arquivos de Neuro-Psiquiatria. 82. 001–012. 10.1055/s-0044–1779486.</figcaption></figure><p>É de suma importância realizar testes continuamente para observar o desempenho de nosso modelo, utilizando isso como base para aprimorá-lo cada vez mais até alcançarmos o resultado almejado.</p><h3>Avaliação</h3><p>Nesta etapa, é realizada a verificação se tudo foi executado corretamente. Isso inclui verificar se as técnicas foram aplicadas adequadamente, se os resultados obtidos são precisos e se manterão consistentes mesmo diante de novos dados inéditos, e se as previsões são úteis e relevantes para a resolução do problema em questão.</p><p>Uma ideia interessante é utilizar alguém externo ao projeto para revisá-lo. Ao obtermos uma perspectiva de fora, podemos ter uma opinião não enviesada e até mesmo identificar erros que passaram despercebidos pela equipe ou por você.</p><h3>Implementação</h3><p>Após deixar o modelo nos trinques, podemos colocá-lo em prática na produção. Esta é uma etapa muito delicada, pois é onde nosso trabalho irá ser posto a prova e enfrentar dados em tempo real pela primeira vez e, caso as etapas anteriores não tenham sido bem executadas, pode gerar uma grande dor de cabeça pra você e uma dor no bolso para a empresa.</p><p>Por isso, é importante estabelecer um processo de <strong>monitoramento </strong>e <strong>feedback </strong>para permitir que o modelo se mantenha atualizado de acordo com as necessidades e mudanças no contexto do problema de negócio.</p><p>Além disso, é necessário definir regras e níveis de variação nas métricas para avaliar quando o modelo precisará de ajustes e como estes serão feitos.</p><p>Ufa! É bastante informação! Contudo, se pararmos para pensar, é um processo bem intuitivo e análogo aos métodos de gestão de projetos convencionais (fora da área de tecnologia).</p><p>O mais interessante disso tudo é que ele é um processo iterativo, então a elaboração do seu projeto não precisa ser algo engessado, onde você precise finalizar 100% de uma etapa para avançar para a próxima.</p><p>Você pode sempre ir e voltar entre os passos para aperfeiçoá-los e alcançar o objetivo desejado da forma mais otimizada possível.</p><p>Agora que você conheceu essa metodologia incrível, que tal aplicá-la no seu próximo projeto? Ou, quem sabe, adaptar algum projeto já existente, para torná-lo mais organizado?</p><p>Agradeço pela atenção e seguimos firme nos estudos.</p><h3>Referências</h3><p><strong>Preditiva Analytics — Escola de Análise de Dados — Módulo Método CRISP-DM</strong>. Disponível em: &lt;https://www.preditiva.ai/&gt;</p><p><a href="https://www.preditiva.ai/">Preditiva Analytics - Escola de Análise de Dados</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9b6159cdc6af" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Banco de dados e SQL: um guia prático para novatos e curiosos — Parte 3]]></title>
            <link>https://medium.com/@pschmitzjr/banco-de-dados-e-sql-um-guia-pr%C3%A1tico-para-novatos-e-curiosos-parte-3-3da120665dfd?source=rss-7d7fe1d45e08------2</link>
            <guid isPermaLink="false">https://medium.com/p/3da120665dfd</guid>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[data]]></category>
            <category><![CDATA[data-analytics]]></category>
            <category><![CDATA[data-analysis]]></category>
            <category><![CDATA[database]]></category>
            <dc:creator><![CDATA[Paulo Schmitz]]></dc:creator>
            <pubDate>Fri, 05 Apr 2024 01:22:28 GMT</pubDate>
            <atom:updated>2024-04-05T01:22:28.271Z</atom:updated>
            <content:encoded><![CDATA[<h3>Banco de dados e SQL: um guia prático para novatos e curiosos — Parte 3</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/0*zQnp-uo6xhMCRLmD.jpg" /></figure><p>Na segunda parte da nossa série, aprendemos a conectar nossa base de dados ao SGBD e conhecemos as principais funções básicas da linguagem SQL.</p><p>Agora, na terceira e última parte do nosso artigo, vamos nos aprofundar um pouco e conhecer mais técnicas e comandos para nos ajudar ainda mais em nossas análises</p><h3>Ordem de Precedência</h3><p>Ao contrário do que esperávamos ao olhar a ordem que os comandos são escritos, a ordem de execução deles segue uma estrutura totalmente diferente. Portanto, vamos entender melhor a ordem de precedência do SQL.</p><h4>FROM &gt; ON &gt; JOIN &gt; WHERE &gt; GROUP BY &gt; HAVING &gt; SELECT &gt; DISTINCT &gt; ORDER BY &gt; LIMIT</h4><p>Primeiro, o SQL identifica a <strong>origem dos dados</strong> pelo “<em>FROM</em>”, e, se houver alguma <strong>junção </strong>entre tabelas, o comando “<em>ON</em>” é executado antes mesmo do “<em>JOIN</em>”, para, da mesma maneira, identificar o <strong>ponto de relacionamento</strong> entre as duas tabelas.</p><p>A seguir, temos a <strong>filtragem </strong>do “<em>WHERE</em>”, que vai limitar os resultados possíveis, e só assim executar o “<em>GROUP BY</em>” e, <strong>pós</strong> <strong>agrupamento</strong>, mais uma <strong>filtragem </strong>com o “<em>HAVING</em>”.</p><p>Surpreendentemente, só depois de todos esses comandos é que o nosso “SELECT” entra em ação para aí sim <strong>selecionar </strong>aquilo que cumpriu todas as exigências da nossa <em>query</em>.</p><p>Por fim, temos a seleção dos <strong>valores únicos</strong>, com o “<em>DISTINCT</em>”, a <strong>ordenação </strong>desejada com o “<em>ORDER BY</em>” e o “<em>LIMIT</em>” para <strong>restringir </strong>o número de linhas exibidas.</p><p>Conhecer a ordem de execução que o SQL segue quando você “roda” a sua consulta é fundamental para poder estruturar melhor as queries e torná-las mais eficientes.</p><blockquote>Vale ressaltar que essa ordem pode sofrer pequenas alterações de acordo com cada SGBD utilizado.</blockquote><h4>Condicionais no SQL: CASE WHEN</h4><p>Muito presente em diversas linguagens de programação, o famoso “<em>if-else</em>” permite adicionar condições para definir qual caminho o código seguirá, baseado nos valores de suas variáveis.</p><p>No SQL não seria diferente. Com o “CASE WHEN” podemos criar novas variáveis baseadas nos campos de nossas tabelas.</p><pre>SELECT <br>    *,<br>    CASE<br>        WHEN (price &gt; 12.5 AND size = &#39;S&#39;) OR <br>             (price &gt; 16.5 AND size = &#39;M&#39;) OR <br>             (price &gt; 20.5 AND size = &#39;L&#39;) OR <br>             (size LIKE &#39;X%&#39;) THEN &#39;Premium&#39;   <br>        ELSE &#39;Regular&#39;<br>    END AS &#39;pizza_category&#39;<br>FROM <br>    pizzas;</pre><p>Como exemplificação da função, criamos um sistema de classificação dos sabores de pizza baseados no seu preço. Pizzas mais caras de cada tamanho receberão o título de <em>Premium</em>, enquanto as demais serão intituladas como <em>Regular</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/361/1*SGwY0N1LPCv9iDRQt1eu3w.png" /></figure><blockquote>Tamanhos XL e XXL foram todos classificados como <em>Premium </em>por só existirem uma de cada tamanho.</blockquote><h4>Datas e suas funções</h4><p>Vimos um pouco sobre os tipos de dados usados para datas na primeira parte, durante a criação de nossa base de dados. Mas agora que estamos avançando no nosso conhecimento em SQL, vamos conhecer as principais funções envolvendo manipulação de datas.</p><blockquote>Lembrando que diferentes SGBDs possuem diferentes nomenclaturas para as mesmas funções e a que estamos usando para a construção desse artigo é o MySQL.</blockquote><h4>date_format()</h4><p>Retorna o ano, mês ou dia da data em questão:</p><pre>SELECT<br>    o.order_id, o.date, o.time,<br>    od.pizza_id, od.quantity,<br>    date_format(o.date, &#39;%Y&#39;) AS &#39;order_year&#39;,<br>    date_format(o.date, &#39;%m&#39;) AS &#39;order_month&#39;,<br>    date_format(o.date, &#39;%d&#39;) AS &#39;order_day&#39;<br>FROM<br>    orders AS o<br>LEFT JOIN <br>    order_details AS od ON o.order_id = od.order_id;</pre><p>Como visto, podemos pegar dias, meses e anos ou também combinar os valores, como por exemplo o padrão ‘<em>%Y-%m-%d</em>’ que nos retornaria exatamente os mesmos valores do campo “<em>date</em>”.</p><h4>date() e time()</h4><p>Enquanto a primeiro retorna a data no formato ‘YYYY-MM-DD’, o segundo nos fornece o horário, no formato ‘HH:MM:SS’.</p><pre>SELECT<br>    DATE(NOW()) AS &#39;Data de hoje&#39;,<br>    TIME(NOW()) AS &#39;Horário atual&#39;;</pre><p>Aliados ao comando “<em>NOW()</em>”, obtemos a data e horário exatos do momento em que a <em>query </em>é executada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/321/1*PVBaOYWtYzTSWKwBXtWkoA.png" /></figure><h4>datediff()</h4><p>Retorna a diferença em dias entre duas datas.</p><pre>SELECT<br>    *,<br>    DATE(NOW()) AS &#39;today&#39;,<br>    DATEDIFF(NOW(), o.date) AS &#39;days_difference&#39;<br>FROM <br>    orders o;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*GaqO7M50IkRTeuRdwtkVWw.png" /></figure><h3>WINDOW FUNCTIONS</h3><p>As funções de janela, popularmente conhecidas como <em>Window Functions</em>, são funções de cálculo que operam em um conjunto de linhas relacionadas à linha atual, preservando a individualidade de cada linha.</p><p>Isso significa que essas funções realizam cálculos em um “conjunto de janelas” de dados, onde cada janela está relacionada à linha atual de alguma maneira, permitindo a execução de operações agregadas ou analíticas de forma mais flexível do que as funções que já conhecemos.</p><p>Cenários úteis para a utilização das <em>Window Functions </em>são aqueles em que precisamos realizar cálculos em grupos específicos de dados, como médias móveis, somas acumuladas, classificações entre grupos, e assim por diante.</p><h4>OVER</h4><p>É o comando que identifica uma função de janela. Ele é o responsável por nos retornar o resultado da função para cada linha, em vez de agregar os resultados em uma única linha.</p><p>Graças a ele, podemos resolver o problema que encontramos anteriormente, e calcular a média de pizzas por pedido corretamente.</p><pre>SELECT <br>    order_id,<br>    SUM(quantity) AS pizza_per_order,<br>    AVG(SUM(quantity)) OVER() AS avg_per_order<br>FROM <br>    order_details<br>GROUP BY <br>    order_id;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/245/1*v9CviZ3qA3U940qitlriMQ.png" /></figure><p>Não ficou a melhor das maneiras para se apresentar a métrica que queríamos. Daqui a pouco iremos conhecer uma técnica para aprimorar esse resultado.</p><h4>PARTITION BY</h4><p>É usado dentro do “<em>OVER</em>”, e define como os conjuntos serão definidos para a aplicação das funções. Acho que um exemplo prático será mais esclarecedor.</p><pre>SELECT <br>    o.date,<br>    o.time,<br>    o.order_id,       <br>    pt.name,       <br>    p.size,       <br>    od.quantity,        <br>    pt.category, p.price * od.quantity AS total_price,       <br>    SUM(p.price * od.quantity) OVER(PARTITION BY order_id) AS order_price<br>FROM <br>    order_details AS od<br>LEFT JOIN <br>    orders as o ON od.order_id = o.order_id<br>LEFT JOIN <br>    pizzas AS p ON od.pizza_id = p.pizza_id<br>CROSS JOIN <br>    pizza_types AS pt ON p.pizza_type_id = pt.pizza_type_id;</pre><p>Com essa <em>query</em>, utilizamos o “<em>PARTITION BY</em>” para criar o “<em>order_price</em>”, que nos mostra o preço total por pedido.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/1*l1RrlfDrgv_B2Yg6-ODFOA.png" /></figure><h4>ROW_NUMBER(), RANK() e DENSE_RANK()</h4><p>São funções semelhantes, mas que se diferenciam em alguns detalhes. Vamos conhecê-las.</p><p>“<em>ROW_NUMBER</em>” cria uma coluna numérica sequencial com base na ordem em que os resultados da consulta são retornados, gerando uma contagem incremental. Quase como um ranking.</p><p>O “<em>RANK</em>” e o “<em>DENSE_RANK</em>” são, de fato, formas de ranquear a coluna através de algum critério. Mas qual a diferença dos três, se eles fazem basicamente a mesma coisa? Você pode estar se perguntando.</p><p>Realmente, suas finalidades são muito semelhantes, mas o que os difere é o comportamento durante empates. Para exemplificar, pense que dois números empataram na posição 5. Logo, a consulta irá retornar duas linhas na mesma quinta posição.</p><p>O primeiro, “<em>RANK</em>”, retornará o próximo valor como a posição 7, <strong>ignorando a existência do empate</strong>.</p><p>Já o “<em>DENSE_RANK</em>” irá <strong>continuar de onde parou</strong> de acordo com o empate, retornando o próximo valor na posição 6. Vamos ver na prática!</p><pre>SELECT <br>    o.date,  <br>    o.time, <br>    o.order_id, <br>    pt.name, <br>    p.size, <br>    od.quantity,  <br>    ROW_NUMBER() OVER(ORDER BY o.order_id) AS &#39;row_number&#39;,<br>    RANK() OVER(ORDER BY o.order_id) AS &#39;rank&#39;,<br>    DENSE_RANK() OVER(ORDER BY o.order_id) AS &#39;dense_rank&#39;<br>FROM <br>    order_details AS od<br>LEFT JOIN <br>    orders as o ON od.order_id = o.order_id<br>LEFT JOIN <br>    pizzas AS p ON od.pizza_id = p.pizza_id<br>CROSS JOIN <br>    pizza_types AS pt ON p.pizza_type_id = pt.pizza_type_id;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/658/1*ZxdPVAxXrSOefzHitMv3aA.png" /></figure><p>Aqui, podemos perceber exatamente a diferença entre cada um. O “<em>DENSE_RANK</em>”, nesse caso, irá ter sempre o mesmo valor de “<em>order_id</em>”, porque é nesse campo que estamos nos baseando para ranquear as linhas.</p><h4>LEAD() e LAG()</h4><p>Essas simples funções tem a finalidade de acessar valores de linhas anteriores (“<em>LAG</em>”), ou superiores (“<em>LEAD</em>”).</p><p>São bastante úteis para realizar análises séries temporais, pois auxiliam a detecção de mudanças de padrões ou anomalias.</p><pre>SELECT <br>    o.date, <br>    COUNT(o.order_id) AS order_per_day,  <br>    SUM(od.quantity) AS pizzas_per_day,<br>    ROUND(SUM(p.price * od.quantity), 2) AS income_per_day,<br>    LEAD(ROUND(SUM(p.price * od.quantity), 2), 1) OVER() AS income_next_day,<br>    LAG(ROUND(SUM(p.price * od.quantity), 2), 1) OVER() AS income_previous_day<br>FROM <br>    order_details AS od<br>LEFT JOIN <br>    orders as o ON od.order_id = o.order_id<br>LEFT JOIN <br>    pizzas AS p ON od.pizza_id = p.pizza_id<br>GROUP BY <br>    o.date;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/579/1*-74k7NUkUI7g2SG2SZFYFg.png" /></figure><p>Perceba, pela sintaxe da função que, manipulando o segundo argumento — <em>LEAD(“valor”, “linhas abaixo”</em>) — , podemos retornar o intervalo que desejarmos em nossa consulta.</p><h4>FIRST_VALUE() e LAST_VALUE()</h4><p>Nossas duas últimas funções de janela, como você pode ter deduzido por seus nomes, nos permitem acessar o primeiro (“<em>FIRST_VALUE</em>”) ou último (“<em>LAST_VALUE</em>”) valor da coluna, simples assim. Vejamos:</p><pre>SELECT <br>    o.date, <br>    COUNT(o.order_id) AS order_per_day,  <br>    SUM(od.quantity) AS pizzas_per_day,<br>    ROUND(SUM(p.price * od.quantity), 2) AS income_per_day,<br>    LEAD(ROUND(SUM(p.price * od.quantity), 2), 1) OVER() AS income_next_day,<br>    LAG(ROUND(SUM(p.price * od.quantity), 2), 1) OVER() AS income_previous_day<br>FROM <br>    order_details AS od<br>LEFT JOIN <br>    orders as o ON od.order_id = o.order_id<br>LEFT JOIN <br>    pizzas AS p ON od.pizza_id = p.pizza_id<br>GROUP BY <br>    o.date;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/489/1*Lu_eXawcBYLKCVEwzG4umg.png" /></figure><p>Perceba que o último valor sempre atualiza de acordo com a última linha apresentada.</p><p>Isso acontece porque utilizamos o “<em>ORDER BY</em>”, caso não estivéssemos ordenando, seria apresentado sempre o último valor de todo o conjunto, como acontece em “<em>first_value</em>”.</p><p>Agora, vamos conhecer nosso <em>gran finale</em>: as <strong><em>subqueries</em></strong>.</p><h3>Subqueries</h3><p>De uma maneira bem simplista, uma <em>subquery </em>nada mais é do que uma consulta dentro de outra consulta, assim como o nome já diz.</p><p>Com ela, podemos criar novas métricas e reutilizá-las na <em>query</em> principal, abrindo um leque de novas possibilidades para nossas análises.</p><p><em>Subqueries</em> podem ser aplicadas em diversos pontos da nossa consulta, como “<em>SELECT</em>”, “<em>FROM</em>”, “<em>HAVING</em>” e até mesmo no “<em>JOIN</em>”.</p><h4>Subquery no FROM</h4><p>Retornando ao nosso problema lá atrás, aqui podemos finalmente exibir nossa média de pedidos de uma forma mais clara e objetiva.</p><pre>SELECT <br>    AVG(total_pizzas) AS avg_per_order<br>FROM (<br>    SELECT  <br>        order_id,<br>        SUM(quantity) AS total_pizzas<br>    FROM <br>        order_details<br>    GROUP BY<br>        order_id<br>) AS subquery;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/190/1*97BK5VQK5P4e5erTpkYwWg.png" /></figure><h4>Subquery no SELECT</h4><p>Utilizamos subconsultas no SELECT quando desejamos inserir uma métrica geralmente para fins de comparação. Veja:</p><pre>SELECT <br>    o.date, <br>    o.time,<br>    o.order_id, <br>    SUM(od.quantity) AS pizzas_per_order,<br>    SUM(p.price * od.quantity) AS total_order_price,<br>    ROUND(SUM(p.price)/SUM(od.quantity), 2) AS avg_pizza_price_per_order,<br>    (<br>        SELECT <br>            ROUND(AVG((p.price * od.quantity)/od.quantity), 2)<br>        FROM <br>            order_details AS od<br>        LEFT JOIN <br>            pizzas AS p ON od.pizza_id = p.pizza_id<br>    ) AS avg_pizza_price_total<br>FROM <br>    order_details AS od<br>    LEFT JOIN <br>        orders as o ON od.order_id = o.order_id<br>    LEFT JOIN <br>        pizzas AS p ON od.pizza_id = p.pizza_id<br>GROUP BY <br>    o.order_id;</pre><p>Com os valores de pizzas por pedido, e total do preço do pedido, calculamos a média do preço por pizza <strong>em cada pedido</strong> (“<em>avg_pizza_price_per_order</em>”)e, a seguir, comparamos com a média de preço por pizza considerando <strong>todos os pedidos (“</strong><em>avg_pizza_price_total</em><strong>”)</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/666/1*YzxcmuKGNLMiqHTTCx_zog.png" /></figure><h4>Subquery no JOIN</h4><p>Outra opção para a consulta anterior, seria inserir a subquery no próprio JOIN, criando uma tabela temporária para nossa métrica.</p><pre>SELECT <br>    o.date, <br>    o.time,<br>    o.order_id, <br>    SUM(od.quantity) AS pizzas_per_order,<br>    SUM(p.price * od.quantity) AS total_order_price,<br>    ROUND(SUM(p.price)/SUM(od.quantity), 2) AS avg_pizza_price_per_order,<br>    avg_prices.avg_order_price AS avg_order_price,<br>    CASE <br>        WHEN SUM(p.price)/SUM(od.quantity) &gt; avg_prices.avg_order_price THEN &#39;Expensive&#39;<br>        ELSE &#39;Cheap&#39;<br>    END AS price_category<br>FROM <br>    order_details AS od<br>    LEFT JOIN <br>        orders AS o ON od.order_id = o.order_id<br>    LEFT JOIN <br>         pizzas AS p ON od.pizza_id = p.pizza_id<br>    CROSS JOIN (<br>        SELECT <br>            ROUND(SUM(p.price)/SUM(od.quantity), 2) AS avg_order_price<br>        FROM <br>            order_details AS od<br>        LEFT JOIN <br>            pizzas AS p ON od.pizza_id = p.pizza_id<br>    ) AS avg_prices<br>GROUP BY <br>    o.order_id;</pre><p>Com isso, podemos criar um pequeno indicador de que a média do pedido está maior ou menor do que a geral.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/729/1*a5nAuqDDUzOqlpcrl5a7jA.png" /></figure><h4>Subquery no HAVING</h4><pre>SELECT <br>    o.date, <br>    o.time,<br>    o.order_id, <br>    SUM(od.quantity) AS pizzas_per_order,<br>    SUM(p.price * od.quantity) AS total_order_price,<br>    (<br>        SELECT <br>            ROUND(AVG(p.price * od.quantity), 2)<br>        FROM <br>            order_details AS od<br>        LEFT JOIN <br>            pizzas AS p ON od.pizza_id = p.pizza_id<br>    ) AS avg_order_price<br>FROM <br>    order_details AS od<br>    LEFT JOIN <br>        orders AS o ON od.order_id = o.order_id<br>    LEFT JOIN <br>        pizzas AS p ON od.pizza_id = p.pizza_id<br>GROUP BY <br>    od.order_id<br>HAVING <br>    o.order_id IN (<br>        SELECT <br>            od.order_id <br>        FROM <br>            order_details AS od<br>        LEFT JOIN <br>            pizzas AS p ON od.pizza_id = p.pizza_id <br>        GROUP BY <br>            od.order_id<br>        HAVING <br>            SUM(p.price * od.quantity) &gt; 50<br>    );</pre><p>Com essa query, estamos filtrando os pedidos com valor de pedido total maior do que $ 50,00.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/493/1*D_k--tgnyeYHaxeEpD4uZg.png" /></figure><h4>Subqueries correlacionadas</h4><p>Podemos, também, ter outras <em>subqueries </em>dentro de uma <em>subquery</em>. Vejamos:</p><pre>SELECT <br>    o.date, <br>    o.time,<br>    o.order_id, <br>    SUM(od.quantity) AS pizzas_per_order,<br>    SUM(p.price * od.quantity) AS total_order_price,<br>    ROUND(SUM(p.price) / SUM(od.quantity), 2) AS avg_pizza_price_per_order,<br>    (<br>        SELECT <br>            ROUND(AVG((p.price * od.quantity)/od.quantity), 2)<br>        FROM   <br>            order_details AS od<br>        LEFT JOIN <br>            pizzas AS p ON od.pizza_id = p.pizza_id<br>    ) AS avg_pizza_price_total<br>FROM <br>    order_details AS od<br>    LEFT JOIN <br>        orders AS o ON od.order_id = o.order_id<br>    LEFT JOIN <br>        pizzas AS p ON od.pizza_id = p.pizza_id<br>GROUP BY <br>    od.order_id<br>HAVING <br>    o.order_id IN (<br>        SELECT <br>            od.order_id <br>        FROM <br>            order_details AS od<br>        LEFT JOIN <br>            pizzas AS p ON od.pizza_id = p.pizza_id <br>        GROUP BY <br>            od.order_id<br>        HAVING <br>            SUM(p.price * od.quantity) &gt; (<br>                SELECT <br>                    ROUND(AVG((p.price * od.quantity)/od.quantity), 2)<br>                FROM <br>                    order_details AS od<br>                LEFT JOIN <br>                    pizzas AS p ON od.pizza_id = p.pizza_id<br>        )<br>    );</pre><p>Aqui, filtramos os pedidos que tinham uma média de preço por pizza <strong>maior</strong> do que a média geral.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/669/1*q0HKxFzb0l8A-3vF9tnKSA.png" /></figure><h4>Commom Table Expressions (CTE)</h4><p>Estamos caminhando para o final da nossa saga e, por último, gostaria de apresentar uma outra forma de realizar subconsultas, as<em> commom table expressions</em>.</p><p>Essa ferramenta nos permite criar <em>subqueries</em> em forma de tabelas temporárias, que podem ser aproveitadas na nossa <em>query</em> principal.</p><p>Sua principal vantagem é a organização que ela traz para a consulta, deixando-a mais legível e facilitando o entendimento de consultas muito complexas.</p><h4>WITH AS</h4><p>Sua estrutura se inicia com esses dois comandos entre o nome que dermos para a <em>subquery</em>. Sem encher linguiça, vamos ver um exemplo:</p><pre>WITH name_count AS (<br>    SELECT <br>        pt.name,<br>        COUNT(DISTINCT o.order_id) AS counting<br>    FROM <br>        order_details AS od<br>        LEFT JOIN <br>            orders AS o ON od.order_id = o.order_id<br>        LEFT JOIN <br>            pizzas AS p ON od.pizza_id = p.pizza_id<br>        LEFT JOIN <br>            pizza_types AS pt ON p.pizza_type_id = pt.pizza_type_id<br>    GROUP BY<br>        pt.name<br>)<br>SELECT <br>    nc.name,<br>    nc.counting,<br>    ROUND(nc.counting * 100.0 / total_count, 2) AS percent_total,<br>    RANK() OVER(ORDER BY (nc.counting * 100.0 / total_count) DESC) AS ranking<br>FROM <br>    name_count AS nc<br>CROSS JOIN (<br>    SELECT <br>        SUM(counting) AS total_count<br>    FROM <br>        name_count<br>) AS total<br>ORDER BY <br>    percent_total DESC;</pre><p>A query em questão agrupa os pedidos de acordo com o nome da pizza e conta quantas vezes cada pizza apareceu em pedidos <strong>distintos</strong>.</p><p>A seguir, reutilizamos a <em>subquery</em> para calcular o total de linhas e, com essas informações, criar o percentual em relação ao total de pedidos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/354/1*_EEU3dcoOKlQjZ_xmUJGoQ.png" /></figure><p>Com esse último comando, chegamos ao fim do nosso guia sobre a <em>Structured Query Language</em>, o amado e odiado SQL.</p><p>Você percebeu durante nossa trajetória que o SQL é uma linguagem bastante <strong>intuitiva</strong>? Sempre dá pra dificultar, mas no geral consegue-se entender pelo menos o contexto da consulta apenas por ler os comandos.</p><p>Agora que você aprendeu conceitos básicos (e até alguns intermediários), que tal praticar um pouco? Pegue uma base disponível por aí e faça sua própria análise, formule perguntas e tente as responder nas suas <em>queries</em>, seja curioso e criativo!</p><h4>Referências</h4><p><a href="https://mode.com/sql-tutorial/sql-window-functions">SQL Window Functions | Advanced SQL - Mode</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3da120665dfd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Banco de dados e SQL: um guia prático para novatos e curiosos — Parte 2]]></title>
            <link>https://medium.com/@pschmitzjr/banco-de-dados-e-sql-um-guia-pr%C3%A1tico-para-novatos-e-curiosos-parte-2-7c9ad4595ec3?source=rss-7d7fe1d45e08------2</link>
            <guid isPermaLink="false">https://medium.com/p/7c9ad4595ec3</guid>
            <category><![CDATA[data-analysis]]></category>
            <category><![CDATA[analytics]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[query]]></category>
            <category><![CDATA[sql]]></category>
            <dc:creator><![CDATA[Paulo Schmitz]]></dc:creator>
            <pubDate>Fri, 29 Mar 2024 15:27:45 GMT</pubDate>
            <atom:updated>2024-03-29T15:27:45.939Z</atom:updated>
            <content:encoded><![CDATA[<h3>Banco de dados e SQL: um guia prático para novatos e curiosos — Parte 2</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/678/1*2-qwKQclSyfLhNvn059X4A.png" /></figure><p>Na primeira parte da nossa série, conhecemos um pouco sobre a história dos bancos de dados e a sua linguagem, o SQL, e também aprendemos a como criar e manipular nosso próprio banco de dados.</p><p>No entanto, na prática, grande parte do trabalho dos analistas de dados se resume apenas a análises exploratórias em bancos de dados já existentes.</p><p>Por isso, nessa segunda parte, vamos pegar uma base pronta e conhecer os comandos mais importantes para as nossas consultas (ou <em>queries</em>, como são chamadas popularmente).</p><h3>Construindo uma base de dados completa</h3><p>Para isso, precisamos de uma fonte de dados, e aqui podemos utilizar dados em diversos tipos de arquivos, basta checar se o seu SGBD é compatível com a exportação deles:</p><ul><li>CSV (<em>Comma-Separated Values</em>): é o formato mais utilizado para importação</li><li>XML (<em>Extensible Markup Language</em>)</li><li>JSON (<em>JavaScript Object Notation</em>)</li><li>XLSX (Planilhas do Excel): pode ser utilizado para converter os dados para o formato CSV, mas alguns SGBDs possuem ferramentas para a importação direta desse tipo de arquivo.</li></ul><p>Os dados podem ser criados do zero pelo autor, através de <em>web scrapping</em> de alguma fonte ou mesmo através dos seus dados pessoais (registros de vendas da sua loja, por exemplo).</p><p>Outra opção seria utilizar dados de uma base previamente construída e disponibilizada em sites específicos para isso, como é o caso do popular <a href="http://kaggle.com/"><em>Kaggle</em></a>. Uma ferramenta interessante para pesquisa de <em>datasets </em>entre essas diferentes plataformas é o <a href="https://datasetsearch.research.google.com/"><em>Dataset Research</em></a>, do próprio Google.</p><p>Vamos mudar um pouco do tema que estávamos utilizando nas técnicas anteriores, optei por uma base de dados de <a href="https://www.kaggle.com/datasets/mysarahmadbhat/pizza-place-sales?select=pizza_types.csv">pedidos de uma pizzaria fictícia</a>, por apresentar uma estrutura simples, facilmente entendível e bem completa, além de que, convenhamos, possui uma temática muito chamativa, não é mesmo?</p><p>Para criar a base dentro do SGBD, vamos precisar de uma ajudinha de outra linguagem: o Python. Mas não se preocupe, são comandos muito simples e irei explicá-los detalhadamente conforme avançamos.</p><p>Caso você não tenha nenhuma afinidade com o Python, existem diversas outras formas para realizar a criação da base, inclusive com alguns SGBDs permitindo a importação direta do arquivo CSV durante a conexão.</p><p>Comecemos o passo a passo para criar a conexão do Python com o MySQL e inserir as tabelas dentro do nosso banco de dados. A primeira etapa: instalação dos pacotes utilizados:</p><pre># Caso não possua, será necessário a instalação das seguintes bibliotecas<br><br>pip install pandas<br>pip install pymysql<br>pip install sqlalchemy<br>pip install mysql-connector-python</pre><p>Com os pacotes devidamente instalados, podemos estabelecer uma conexão entre nosso código em Python com o SGBD que estamos usando (MySQL):</p><pre>from sqlalchemy import create_engine<br>import pandas as pd<br><br>sgbd = &quot;mysql&quot;<br>driver = &quot;pymysql&quot;<br>usuario = &quot;root&quot;<br>senha = &quot;1234&quot;<br>banco_de_dados = &quot;pizza_place&quot;<br>host = &quot;localhost&quot;<br>porta = 3306<br>    <br>conexao = create_engine(url=f&quot;{sgbd}+{driver}://{usuario}:{senha}@{host}:{porta}/{banco_de_dados}&quot;)</pre><p>O comando “<em>create_engine</em>” utiliza os seguintes argumentos para estabelecer a conexão com o <em>MySQL</em>:</p><ul><li>SGBD: o serviço utilizado para gerenciar o banco de dados (<em>MySQL</em>);</li><li>Driver: é o pacote que estamos utilizando para integrar o <em>Python</em> com o SQL (<em>pymysql</em>);</li><li>Usuário: nome do usuário que está gerenciando o banco de dados. Por padrão, em servidores locais, é definido como <em>root</em>;</li><li>Senha: definido pelo usuário;</li><li>Banco de dados: nome do <em>schema </em>que irá receber os dados;</li><li>Host: é o local de armazenamento do banco de dados. Nesse caso, se tratando de uma conexão local, usamos o <em>localhost</em>, mas no caso de uma rede de computadores ou até um serviço em nuvem, teríamos de especificar o caminho do banco de dados;</li><li>Porta: é a forma que os bancos se comunicam com o servidor. Para o MySQL, a porta padrão é a 3306.</li></ul><p>Paralelamente, vamos retornar ao MySQL para criar nossa base de dados e definir os parâmetros das nossas tabelas:</p><pre>CREATE DATABASE pizza_place;<br>USE pizza_place;<br> <br>DROP TABLE IF EXISTS `order_details`;<br>DROP TABLE IF EXISTS `orders`;<br>DROP TABLE IF EXISTS `pizza_types`;<br>DROP TABLE IF EXISTS `pizzas`; <br><br>CREATE TABLE `pizza_types` (<br> `pizza_type_id` VARCHAR(32) NOT NULL,<br> `name` VARCHAR(64) NOT NULL,<br> `category` ENUM(&#39;Supreme&#39;, &#39;Classic&#39;, &#39;Chicken&#39;, &#39;Veggie&#39;) NOT NULL,<br> `ingredients` VARCHAR(256),<br> CONSTRAINT typePK PRIMARY KEY (pizza_type_id)<br>);<br><br>CREATE TABLE `pizzas` (<br> `pizza_id` VARCHAR(32) NOT NULL,<br> `pizza_type_id` VARCHAR(32) NOT NULL,<br> `size` ENUM(&#39;S&#39;, &#39;M&#39;, &#39;L&#39;, &#39;XL&#39;, &#39;XXL&#39;) NOT NULL,<br> `price` FLOAT NOT NULL,<br> FOREIGN KEY (pizza_type_id) REFERENCES pizza_types(pizza_type_id),<br> CONSTRAINT pizzaPK PRIMARY KEY(pizza_id)<br>);<br><br>CREATE TABLE `orders` (<br> `order_id` INT NOT NULL,<br> `date` DATE NOT NULL,<br> `time` TIME NOT NULL,<br> CONSTRAINT orderPK PRIMARY KEY (order_id)<br>);<br><br>CREATE TABLE `order_details` (<br> `order_details_id` INT NOT NULL,<br> `order_id` INT NOT NULL,<br> `pizza_id` VARCHAR(32) NOT NULL,<br> `quantity` INT NOT NULL,<br> FOREIGN KEY (pizza_id) REFERENCES pizzas(pizza_id),<br> FOREIGN KEY (order_id) REFERENCES orders(order_id),<br> CONSTRAINT detailPK PRIMARY KEY (order_details_id)<br>);</pre><p>Sem muitas novidades do que já aprendemos anteriormente, criamos o “<em>database” e </em>acessamos ele com o comando “<em>USE</em>”. Mesmo sabendo que não existe nenhuma tabela existente, executamos o comando “<em>drop</em>”, apenas como uma boa prática mesmo.</p><p>Após isso, vamos definir os parâmetros das tabelas. Já vimos todos esses conceitos anteriormente, com exceção de dois termos:</p><ul><li><strong><em>CONSTRAINT</em></strong>: aqui impomos regras ou restrições para os campos. No caso da última tabela, por exemplo, estamos definindo a “<em>PRIMARY KEY</em>” da tabela “<em>order_details</em>” através da restrição “<em>detailPK</em>”;</li><li><strong><em>FOREIGN KEY</em></strong>: é utilizada para relacionar duas tabelas através de um campo, normalmente um ID, como é o caso da “<em>pizza_id</em>” que relaciona a tabela “<em>pizzas</em>” com a “<em>order_details</em>”.</li></ul><blockquote>Como o SQL não suporta caracteres com acentuação, evitar o uso de nomes em português é uma boa prática para não causar confusões no entendimento das palavras, visto que no nosso idioma o uso de acentos são comuns.</blockquote><p>A seguir, vamos importar os arquivos contendo os nossos dados:</p><pre>pizza_types = pd.read_csv(&quot;pizza_types.csv&quot;)<br>pizzas = pd.read_csv(&quot;pizzas.csv&quot;)<br>orders = pd.read_csv(&quot;orders.csv&quot;)<br>order_details = pd.read_csv(&quot;order_details.csv&quot;)</pre><p>Dessa forma, importamos os dados para dentro do código, criando tabelas, como essa, que apresenta a tabela “<em>pizzas</em>”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*QMp_V2qJlEu-t1MEEbQvsA.png" /></figure><blockquote>Caso os arquivos estejam em uma pasta separada do seu arquivo Python, é necessário passar todo o caminho do diretório em que elas estão localizadas para que seja possível detectá-los.</blockquote><p>Por fim, iremos exportar essas tabelas para o nosso já criado banco de dados no MySQL:</p><pre>pizza_types.to_sql(&#39;pizza_types&#39;, conexao, index=False, if_exists=&#39;append&#39;)<br>pizzas.to_sql(&#39;pizzas&#39;, conexao, index=False, if_exists=&#39;append&#39;)<br>orders.to_sql(&#39;orders&#39;, conexao, index=False, if_exists=&#39;append&#39;)<br>order_details.to_sql(&#39;order_details&#39;, conexao, index=False, if_exists=&#39;append&#39;)</pre><p>O comando “<em>to_sql</em>” possui diversos argumentos, mas os que vamos nos atentar aqui são os dois obrigatórios e outros dois opcionais:</p><ul><li><em>name</em>: nome da tabela no banco de dados;</li><li><em>con</em>: conexão entre Python e SQL, que fizemos com o “<em>create_engine</em>”;</li><li><em>index</em>: define se o índice da tabela entrará como uma coluna, e por padrão recebe “<em>True</em>”. Como criamos previamente as tabelas no SQL, vamos alterar para “<em>False</em>”;</li><li><em>if_exists</em>: esse padrão configura a resposta do Python caso encontre no banco de dados o nome da tabela que passamos, sendo a ação padrão apresentar uma mensagem de falha (<em>if_exists = ‘fail’</em>). Assim como descrito em “<em>index</em>”, como a tabela já existe, vamos alterar para ‘<em>append</em>’ que irá apenas adicionar os dados nela. Outra opção seria o ‘<em>replace</em>’, que iria substituir a tabela existente por uma nova.</li></ul><p>Após rodar esses códigos, se não houver nenhuma inconsistência, seu banco de dados agora deve estar devidamente preenchido. Mas, e agora? Como eu enxergo esses dados?</p><h3>Queries</h3><p>Simples, utilizamos as <em>queries</em>. Uma <em>query </em>é, como seu próprio nome em inglês diz, uma consulta, então vamos aprender a consultar os dados em nosso recém criado <em>database</em>.</p><h4>SELECT e FROM</h4><pre>SELECT * FROM order_details;</pre><p>O comando “<em>SELECT</em>” define os campos que serão vistos e, com o uso do argumento “<em>* </em>”, selecionamos todos os campos.</p><p>O “<em>FROM</em>” serve para informarmos qual tabela estamos consultando, nesse caso, a tabela “<em>order_details</em>” da base “<em>pizza_place</em>”. Com isso, podemos observar o resultado da nossa <em>query</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/1*cYAXRHwFdOA0RCorEXGW4w.png" /></figure><p>Ok, selecionamos todos os dados de uma tabela, mas e se esse não for o meu objetivo? Agora vamos aprofundar um pouco no comando “<em>SELECT” </em>e também conhecer formas de filtrar e ordenar as informações.</p><h4>ORDER BY</h4><pre>SELECT<br>    pizza_id, <br>    price <br>FROM <br>    pizza_place.pizzas<br>ORDER BY <br>    price DESC LIMIT 5;</pre><p>Nesta <em>query</em>, em vez de selecionar tudo da tabela, nosso objetivo foi selecionar o top 5 pizzas mais caras. Por isso, consultamos apenas as colunas que nos interessavam, no caso a identificação da pizza e seu preço.</p><p>Para realizar o top 5, <strong>ordenamos </strong>os valores de “<em>price</em>” com o “<em>ORDER BY</em>” de forma <strong>decrescente</strong>, com o “<em>DESC” </em>(caso nosso desejo fosse ordenar de forma crescente, utilizaríamos o “<em>ASC</em>”) e <strong>limitamos</strong> aos 5 primeiros resultados com o comando “<em>LIMIT</em>”. Vejamos o resultado final:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/163/1*QTV6CNTYgZrRWbDhfpYA_w.png" /></figure><h4>WHERE</h4><p>Para a <strong>filtragem</strong> dos dados, temos o “<em>WHERE</em>”, que é utilizado de uma forma muito simples , basta inserir o campo e o que você deseja buscar. É quase como se você estivesse conversando com o código, vamos ver:</p><pre>SELECT <br>    * <br>FROM <br>    pizzas<br>WHERE <br>    size = &#39;M&#39;<br>ORDER BY <br>    price DESC;</pre><p>Aqui, estamos selecionando as pizzas de tamanho médio, ordenando por preço, do maior para o menor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/264/1*RPmjb6M1vK_O373WOPDl-g.png" /></figure><p>Vejamos mais exemplos de uso do WHERE com o uso de operadores lógicos:</p><pre>-- AND<br>SELECT * FROM pizzas<br>WHERE size = &#39;M&#39; AND price &lt; 16;<br><br>-- OR<br>SELECT * FROM pizzas<br>WHERE size = &#39;M&#39; OR price &lt; 16;</pre><p>Podemos realizar filtros com mais de uma condição simultânea, acima, com o uso do “<em>AND</em>”, filtramos as pizzas médias <strong>E</strong> que possuem preço abaixo de $16,00. Da mesma forma, podemos utilizar o “<em>OR</em>” para selecionarmos pizzas médias <strong>OU </strong>que possuem preço menor que $16,00.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/268/1*TYyeFSAfbMxbKZfjS0W4Og.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/261/1*J4lkC0K688T41pNAWjv1xw.png" /><figcaption>Queries com filtros “AND ”e “OR”, respectivamente</figcaption></figure><p>Para criar filtros ainda mais precisos, podemos combiná-los quantas vezes for. Vamos filtrar pizzas médias OU grandes e que estejam na faixa de preço entre $14,00 e $16,00:</p><pre>SELECT * FROM pizzas<br>WHERE (size = &#39;M&#39; OR size = &#39;L&#39;) AND (price &lt;= 16 AND price &gt;= 14);</pre><p>Uma outra forma de escrever o código, talvez de forma mais limpa, seria utilizar os condicionais “<em>IN</em>” e “<em>BETWEEN</em>”:</p><pre>SELECT * FROM pizzas<br>WHERE (size IN (&#39;M&#39;, &#39;L&#39;)) AND (price BETWEEN 14 AND 16);</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/273/1*RiBiGuV75VzNA4dnTu5PpA.png" /></figure><p>E, para selecionarmos justamente o <strong>oposto </strong>disso, simplesmente adicionamos o operador “<em>NOT</em>”:</p><pre>SELECT * FROM pizzas<br>WHERE (size NOT IN (&#39;M&#39;, &#39;L&#39;)) AND (price NOT BETWEEN 14 AND 16);</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/253/1*Bdk9i9wTtovfCpdyYDIJ3A.png" /></figure><p>Dessa forma, filtramos todas as pizzas que não são médias nem grandes <strong>E</strong> que possuem preço fora da faixa de $14,00 e $16,00.</p><p>Um ponto interessante do comando “<em>BETWEEN</em>” é que ele também funciona com <em>strings </em>(ou seja, textos):</p><pre>SELECT <br>    * <br>FROM <br>    pizza_types<br>WHERE <br>    pizza_type_id BETWEEN &#39;calabrese&#39; AND &#39;five_cheese&#39;<br>ORDER BY <br>    pizza_type_id;</pre><p>No código acima, selecionamos códigos referentes aos sabores das pizzas, de forma que, alfabeticamente, todos os nomes entre “<em>calabrese</em>” e “<em>five_cheese</em>”, são mostrados no resultado da <em>query</em>, veja:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/574/1*4RHzoLTgwQcsbA2rwTAXjw.png" /></figure><p>Por fim, vamos conhecer mais dois recursos para trabalharmos principalmente com <em>strings</em>:</p><pre>SELECT DISTINCT category FROM pizza_types;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/126/1*mpEFypsjRJ-xg1U_bZ1aHg.png" /></figure><p>Supondo que estivéssemos consultando uma base nova e desconhecida, uma boa maneira de encontrar os <strong>valores únicos</strong> em um campo é com o uso do “<em>DISTINCT</em>”.</p><p>Este comando pode ser muito útil quando encontramos valores muito repetitivos em um determinado campo e precisamos analisar melhor quais são todos os valores possíveis.</p><p>Já o comando “<em>LIKE</em>” é uma mão na roda para encontrar valores que <strong>contenham </strong>determinada informação:</p><pre>SELECT * FROM pizza_types<br>WHERE ingredients LIKE &quot;%pepperoni%&quot;;</pre><p>O resultado da query acima seriam todas as pizzas que contenham “pepperoni” como ingrediente, independente da ordem em que ele se encontra.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/631/1*EdNt0vW97a3Ejjceyxvd1g.png" /></figure><p>Diferente de muitas situações que encontramos na programação, esse recurso não é sensível a maiúsculas e minúsculas, então mesmo que no campo o ingrediente esteja escrito como “Pepperoni”, “PEPPERONI” ou “PePpErOnI”, o resultado será o mesmo</p><p>O símbolo de porcentagem encontrado entre as aspas é um dos caracteres curingas (ou <strong><em>wildcards</em></strong>) do SQL, e representa que existem zero ou mais mais caracteres naquela posição. Por isso, ao inserir antes e depois da palavra, a <em>query </em>encontra todas as pizzas que contém o ingrediente, não importando em qual ordem ele está.</p><ul><li>“%a%”: qualquer campo que <strong>contenha </strong>a letra “a” será exibido;</li><li>“a%”: qualquer campo que <strong>comece </strong>com a letra “a” será exibido;</li><li>“%a”: qualquer campo que <strong>termine </strong>com a letra “a” será exibido;</li><li>“a%a”: qualquer campo que <strong>comece e termine</strong> com a letra “a” será exibido.</li></ul><p>Juntamente com a porcentagem (“%”), o <em>underline </em>(“_”) compõem os dois caracteres curingas do MySQL. Diferente da porcentagem que representa zero ou mais, o <em>underline </em>representa um único caractere. Vejamos alguns exemplos:</p><ul><li>“_a%”: qualquer campo em que o <strong>segundo caractere</strong> seja a letra “a” será exibido;</li><li>“_a%a_”: qualquer campo em que o <strong>segundo e o penúltimo caracteres</strong> sejam a letra “a” será exibido;</li><li>“a___%”: qualquer campo que <strong>comece </strong>com a letra “a” e possua pelo menos <strong>quatro caracteres</strong> será exibido.</li></ul><p>Ok, sabemos como visualizar uma tabela e aplicar os devidos filtros. Mas como aprendemos no início, o SQL usa, na maioria das vezes, o modelo relacional, logo, as chaves estrangeiras que referenciam outras tabelas podem acabar mais nos confundindo do que ajudando.</p><h4>JOIN</h4><p>Por sorte, também existe uma solução para contornar isso: os <strong>JOINs</strong>, que nada mais são do que os comandos utilizados para <strong>juntar uma ou mais tabelas</strong>. Vejamos a forma mais básica de se utilizá-lo na maneira correta:</p><pre>SELECT <br>    * <br>FROM <br>    pizzas AS p<br>JOIN <br>    pizza_types AS pt ON p.pizza_type_id = pt.pizza_type_id;</pre><p>Precisamos definir, no comando, a segunda tabela que desejamos juntar, e qual o campo será usado para relacionar ambas as tabelas. Caso contrário, a consulta nos retorna apenas as duas tabelas ligadas, sem associação nenhuma entre elas.</p><p>Para deixar o código mais conciso e facilitar a leitura, podemos abreviar as tabelas utilizando o comando “<em>AS</em>”, que renomeia o campo <strong>apenas na visualização</strong> da consulta.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/825/1*3z4ViiZAbnTAgukUftbp7w.png" /></figure><p>Existem diversos formas de se unir duas tabelas. Por padrão o “<em>JOIN</em>” combina apenas a <strong>intersecção </strong>das duas tabelas, também conhecido como o “<em>INNER JOIN</em>”.</p><p>Juntamente com o “<em>LEFT JOIN</em>”, que une apenas os resultados contidos na <strong>tabela da esquerda</strong>, esses são as formas mais comuns de se realizar a combinação de duas tabelas.</p><p>Mas existem algumas outras formas de se realizar esse processo, vide a imagem abaixo representando cada um deles:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e3KANVHE938QK3q8_cmBjw.png" /></figure><p>Para a nossa base de dados, que é totalmente relacional, ou seja, todas as chaves estrangeiras possuem um correspondente na tabela referencial, o “<em>JOIN” </em>que usaremos não importa muito, mas em tabelas onde isso não acontece seu uso pode gerar diversos valores nulos na <em>query</em>.</p><pre>SELECT <br>    o.order_id, <br>    o.date, <br>    o.time, <br>    od.quantity, <br>    p.size, <br>    p.price, <br>    pt.name, <br>    pt.category, <br>    pt.ingredients<br>FROM <br>    order_details AS od<br>INNER JOIN <br>    orders as o ON od.order_id = o.order_id<br>INNER JOIN <br>    pizzas AS p ON od.pizza_id = p.pizza_id<br>INNER JOIN <br>    pizza_types AS pt ON p.pizza_type_id = pt.pizza_type_id;</pre><p>Por fim, temos nossa tabela de pedidos totalmente relacionada, mostrando apenas os campos que nos interessam:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bvWIWpzHgmApz5y20qfT6A.png" /></figure><p>Utilizamos a data e hora do pedido, juntamente com o ID para checarmos se as pizzas fazem parte do mesmo pedido. A seguir, o nome, tamanho e quantidade de cada pizza, seguido do preço (o preço é da pizza individual, logo, se houver uma quantidade maior do que 1, devemos calcular para descobrir o preço final), categoria e os respectivos ingredientes.</p><h4>Funções de agregação</h4><p>Outra forma interessante de conhecer nossos dados é utilizando as chamadas funções de agregação. Com elas podemos realizar cálculos e criar alguns indicadores para nossos conjuntos de dados.</p><p>Uma delas é o “<em>COUNT()</em>”. Com ele, podemos quantificar os registros existentes baseado em nossa <em>query</em>:</p><pre>SELECT <br>    COUNT(*) AS &#39;Quantidade de pedidos&#39;<br>FROM <br>    order_details <br>WHERE <br>    pizza_id = &#39;calabrese_l&#39;;</pre><p>Graças a essa função, pudemos revelar que a pizza de calabresa de tamanho médio foi pedida 274 vezes.</p><p>Com a função “<em>SUM()</em>”, em vez de contar, podemos somar todos os valores numéricos que aparecem em uma coluna.</p><pre>SELECT <br>    COUNT(DISTINCT order_id) AS &#39;Total de pedidos&#39;, <br>    SUM(quantity) AS &#39;Total de pizzas&#39; <br>FROM <br>    order_details;</pre><p>Essa <em>query </em>nos retornou que, em 21.350 pedidos, foram pedidas 49.574 pizzas, uma média de 2,32 pizzas por pedido. Com isso, podemos avançar à nossa próxima função, a “<em>AVG()</em>”.</p><pre>SELECT <br>    COUNT(DISTINCT order_id) AS &#39;Total de pedidos&#39;, <br>    SUM(quantity) AS &#39;Total de pizzas&#39;,<br>    AVG(quantity) AS &#39;Média de pizzas&#39;<br>FROM <br>    order_details;</pre><p>No entanto, quando calculamos a média por essa função, temos um resultado final de 1,01. O que será que aconteceu?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/450/1*uKEraIf3P1wr3EyICHsGfA.png" /></figure><p>Bom, isso acontece porque o campo “<em>quantity</em>” apresenta o número de pizzas pedidas <strong>para um determinado tipo</strong>, e não o total de pizzas de cada pedido, como podemos ver no campo “<em>order_id</em>”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/319/1*DHejEvxTiByFepEUGVgyRw.png" /></figure><p>Por isso, para encontrar o número de pedidos na <em>query </em>acima, utilizei mais uma vez do comando “<em>DISTINCT</em>” para realizar a contagem apenas dos IDs de pedidos <strong>únicos</strong>.</p><p>Pegando o gancho desse problema que encontramos, vamos conhecer nossos próximos comandos.</p><h4>GROUP BY e HAVING</h4><p>Bancos de dados trabalham com registros que podem passar dos milhões, por isso, conseguir agrupar valores pode nos auxiliar em nossas análises.</p><p>E é exatamente essa a função do “<strong><em>GROUP BY</em></strong>”. Com ele, podemos utilizar um campo de nossa tabela como referencial para agrupar os valores. Vejamos a <em>query </em>abaixo, onde criamos o campo de quantidade de pizzas por pedido.</p><pre>SELECT <br>    order_id, COUNT(quantity) AS &#39;quantity_per_order&#39;<br>FROM <br>    order_details <br>GROUP BY <br>    order_id<br>HAVING <br>    quantity_per_order BETWEEN 10 AND 15;</pre><p>O “<em>HAVING</em>” nada mais é do que o comando “<em>WHERE</em>” utilizado após a agrupação dos valores, ou seja, ele permite criar condições na <em>query </em>e mostrar apenas os valores que atendam a elas.</p><p>Na nossa consulta acima, criei a variável “<strong><em>quantity_per_order</em></strong>” e <strong>filtrei </strong>apenas os pedidos que continham entre 10 a 15 pizzas.</p><p>É interessante pontuar que, diferentemente do “<em>HAVING</em>”, no “<em>WHERE</em>” não é possível utilizar funções de agregação para criar os filtros.</p><p>Por aqui, finalizamos a segunda parte do nosso artigo onde estamos descobrindo juntos como a linguagem SQL funciona.</p><p>Agora que já conhecemos as principais e mais comuns funções, que tal pratica-las em uma base de dados nova? Você pode dar início agora mesmo a sua primeira análise em SQL!</p><p>Na próxima parte, veremos alguns comandos e conceitos mais aprofundados sobre a linguagem. Até mais!</p><h4>Referências</h4><p><a href="https://www.alphacodingskills.com/sql/notes/sql-keyword-join.php">SQL JOIN Keyword</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7c9ad4595ec3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Banco de dados e SQL: um guia prático para novatos e curiosos — Parte 1]]></title>
            <link>https://medium.com/@pschmitzjr/banco-de-dados-e-sql-um-guia-pr%C3%A1tico-para-novatos-e-curiosos-parte-1-e5ad103d9bcf?source=rss-7d7fe1d45e08------2</link>
            <guid isPermaLink="false">https://medium.com/p/e5ad103d9bcf</guid>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[mysql]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[data-analytics]]></category>
            <category><![CDATA[data]]></category>
            <dc:creator><![CDATA[Paulo Schmitz]]></dc:creator>
            <pubDate>Thu, 21 Mar 2024 02:16:31 GMT</pubDate>
            <atom:updated>2024-03-21T02:16:31.518Z</atom:updated>
            <content:encoded><![CDATA[<h3>Banco de dados e SQL: um guia prático para novatos e curiosos — Parte 1</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/730/0*eABA8zFxIW9EptAe.png" /></figure><p>Nesta sequência de artigos, pretendo abordar o que são bancos de dados e aprender mais sobre a linguagem utilizada para manipulá-los, começando do básico até algumas funções mais avançadas.</p><h3>Bancos de dados</h3><p>Bancos de dados nada mais são do que grandes conjuntos de dados organizados e armazenados eletronicamente. São muito utilizados atualmente graças à grande expansão digital e a gigantesca produção de dados que ela trouxe.</p><p>O controle desses bancos de dados ocorre através de <em>softwares </em>conhecidos como Sistemas de Gerenciamento de Banco de Dados (SGBD ou DBMS, em inglês) criados para ser a interface entre o banco de dados e o usuário. Alguns dos mais conhecidos são o <em>MySQL</em>, <em>Oracle </em>e <em>Microsoft SQL Server</em>.</p><h4>Modelo relacional</h4><p>Na década de 1970, o matemático britânico Edgar Frank Codd criou o modelo relacional, que é, até hoje, o modelo mais difundido. Esse conceito utiliza de chaves identificadoras para, como o próprio nome diz, relacionar uma tabela com a outra. Essa configuração facilita alterações e torna o processo mais escalável.</p><p>Por exemplo, imagine um banco de dados com registros de mais de 20 milhões de vendas e, dessas, cerca de 250 mil realizadas por um único cliente. Agora imagine que esse cliente (uma empresa) decide mudar sua razão social. Se os dados estivessem agrupados em uma única tabela, seria necessário buscar e atualizar 250 mil linhas dentre as 20 milhões. E se existissem 20 tabelas que utilizassem os dados de clientes? Seria inviável alterar em todas as tabelas para manter a consistência dos dados, não acha?</p><p>Com o modelo relacional, a razão social do cliente estaria armazenada em uma tabela própria de dados cadastrais de clientes, e bastaria alterar uma única vez, já que todas as outras tabelas estariam utilizando apenas uma chave identificadora para aquele cliente, utilizada justamente para “linkar” a tabela de cadastros com qualquer outra que possua a chave.</p><h4>ACID</h4><p>Algumas propriedades foram definidas para garantir que operações em bancos de dados sejam confiáveis e válidas. A sigla “ACID” representa essas propriedades: Atomicidade, Consistência, Isolamento e Durabilidade. Vamos conhecer cada uma delas:</p><ul><li><strong>Atomicidade</strong>: para evitar que os dados sejam perdidos ou corrompidos, a instrução passada (que pode ser a leitura, gravação, atualização ou exclusão de dados) deve ser executada de forma integral. Logo, se desejamos modificar 500 mil linhas e o processo conseguiu modificar “apenas” 499 mil, todo o processo é cancelado e as modificações não são executadas.</li><li><strong>Consistência</strong>: como já citamos no exemplo acima, deve haver uma garantia de que os resultados da execução de uma instrução sejam fidedignos, e para isso algumas regras devem ser respeitadas, como as restrições e a definição prévia dos tipos de dados nas tabelas, além presença de chaves únicas e a garantia de suas relações entre si.</li><li><strong>Isolamento</strong>: as técnicas de isolamento presentes as tratam de forma independente, possibilitando que sejam feitas de forma paralela sem interferir umas nas outras, mesmo que ocorram ao mesmo tempo.</li><li><strong>Durabilidade</strong>: as requisições, quando executadas com sucesso, precisam ser mantidas mesmo em caso de falha do sistema.</li></ul><h3>SQL</h3><p>As primeiras ideias de uma linguagem utilizada especificamente em bancos de dados surgiu também de Edgar Codd, que desenvolveu uma linguagem chamada Alpha, precursora da SEQUEL (<em>Structured English Query Language) </em>que posteriormente foi renomeada como SQL (<em>Structured Query Language</em>).</p><p>SQL é uma linguagem não procedural, não possui bibliotecas e seus comandos são considerados simples, pois é fundamentalmente utilizada para a realização de consultas e, mesmo que seja possível realizar operações, não é o meio mais apropriado para tal.</p><h4>Tipos de dados</h4><p>Numéricos, temporais, literais e espaciais</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fCgbOoO0wiGi3UIcuQUAIQ.png" /></figure><p>Hierarquia banco de dados:</p><p><strong>Banco de dados &gt; Conjunto de tabelas (<em>Schema</em>) &gt; Tabela &gt; Registro &gt; Campo &gt; Caracter (byte)</strong></p><p>Um <strong>banco de dados</strong> é composto por um ou mais <strong>esquemas</strong>, que nada mais são que conjuntos de <strong>objetos </strong>(simplificadamente, <strong>tabelas</strong>). As tabelas possuem <strong>registros </strong>com diversos <strong>campos </strong>que, por fim, possuem seus <strong>caracteres </strong>(representados por <strong>bytes</strong>).</p><h3>Iniciando na linguagem — Criação do banco de dados</h3><p>O primeiro passo para utilizar o SQL para consultar em um banco de dados é… possuir um banco de dados. Para isso, vamos construir um <em>database</em> simples para uma loja.</p><blockquote>Como os SGBDs podem possuir pequenas mudanças em alguns detalhes, como a sintaxe do código, deixo registrado aqui que estarei utilizando o MySQL.</blockquote><pre>CREATE DATABASE store;<br>USE store;<br>DROP DATABASE store;</pre><p>Temos o comando “<em>CREATE”</em>, como o próprio nome diz, cria um objeto que, como referenciamos em seguida, é uma base de dados (<em>database</em>) e finalizamos com um nome.</p><p>Com a base criada, executamos o comando “<em>USE</em>” para termos acesso a ela e começar a manipulá-la. Por fim, para excluir uma base de dados, executamos o comando “<em>DROP</em>”, sempre passando o objeto que desejamos realizar a ação.</p><p>Algumas observações importantes:</p><ul><li>Comandos completos devem ser separados com ponto e vírgula (;).</li><li>Como a linguagem não aceita a grande maioria dos caracteres especiais, como letras acentuadas por exemplo, uma boa prática é sempre utilizar nomes em inglês, para facilitar o entendimento dos objetos.</li><li>O cuidado deve ser redobrado ao executar comandos críticos, pois não existe “Ctrl + Z” e, por isso, diversas técnicas de <em>backup </em>são utilizadas.</li></ul><h4>Criação de tabelas</h4><p>Com a base criada, podemos começar a construí-la:</p><pre>CREATE TABLE products (<br>    id INT PRIMARY KEY AUTO_INCREMENT,<br>    name VARCHAR(100) NOT NULL,<br>    description VARCHAR(500) DEFAULT &#39;Indefinido&#39;,<br>    category ENUM(&#39;Comida&#39;, &#39;Limpeza&#39;, &#39;Eletrônicos&#39;, &#39;Outros&#39;),<br>    stock INT UNSIGNED DEFAULT 0,<br>    price DECIMAL(6,2)<br>);</pre><p>Novamente vamos utilizar o “<em>CREATE</em>”, mas dessa vez para criar uma <strong>tabela</strong>. Passamos o nome desejado da tabela e, ao abrir o parênteses, definimos cada um dos <strong>campos </strong>(ou colunas) que a tabela precisa.</p><p>Primeiramente vem o nome do campo e, logo em seguida, os parâmetros daquele campo. No caso de “<em>id INT PRIMARY KEY AUTO_INCREMENT</em>”, definimos que o nome “<em>id</em>” receberá dados do tipo “<strong><em>INT</em></strong>”, isso quer dizer que seus valores estão limitados “apenas” a numerais entre 2 bilhões positivos ou negativos (mais precisamente -2.147.483.648 e +2.147.483.647).</p><p>O “<strong><em>PRIMARY KEY</em></strong>” garante que nenhum dos valores daquele campo seja duplicado, gerando um erro caso isso o usuário tente inserir um valor repetido.</p><p>Por fim, temos o “<strong><em>AUTO_INCREMENT</em></strong>” que nos garante que os valores sejam inseridos automaticamente quando adicionarmos uma nova linha. Esse comando facilita nossas vidas, mas também pode causar problemas de duplicidade, já que ao adicionarmos a mesma linha mais de uma vez, teremos os mesmos valores adicionados com um “<em>id</em>” diferente.</p><p>Os campos “<em>name VARCHAR(100) NOT NULL” </em>e “<em>description VARCHAR(500) DEFAULT ‘Indefinido’</em>” são campos de caracteres, isto é, textos. Seu tipo de dados é o “<strong><em>VARCHAR(100)</em></strong>” e “<strong><em>VARCHAR(500)</em></strong>”, e o número que aparece dentro dos parênteses representa o limite de caracteres aceitável em cada um dos campos.</p><p>Sobre o preenchimento desses campos, o parâmetro “<strong><em>NOT</em></strong><em> </em><strong><em>NULL</em></strong>” cria uma obrigatoriedade de que seja passado o valor para o campo, logo, caso “<em>name</em>” não seja passado no input, resultará em um erro. Já o “<strong><em>DEFAULT</em></strong>” permite que isso aconteça, pois como o próprio nome diz, por padrão o campo será preenchido com “Indefinido”.</p><p>Outro campo de caracteres é o “<em>category ENUM(‘Comida’, ‘Limpeza’, ‘Eletrônicos’, ‘Outros’)</em>”, no entanto, possui a propriedade “<strong><em>ENUM</em></strong>”, que permite que apenas os valores pré-definidos sejam aplicados ao campo, caso contrário, um erro será gerado.</p><p>Assim como o campo “<em>description</em>”, “<em>stock INT UNSIGNED DEFAULT 0</em>” também estabelece um valor padrão, igual a zero. Sua outra propriedade, o “<strong><em>UNSIGNED</em></strong>”, não permite valores negativos.</p><p>Finalizando nossos campos da tabela de produtos, o campo “<em>price DECIMAL(6,2)</em>” se apresenta como “<strong><em>DECIMAL</em></strong>”. Usado para representar números não inteiros, recebe, entre parênteses, o total máximo de caracteres permitido no numeral e o máximo de casas após a vírgula, respectivamente. Assim, temos que o maior valor possível atribuído a um produto é de R$ 9.999,99.</p><p>Finalizando, podemos ter uma visão geral dos campos da nossa tabela:</p><pre>DESCRIBE products;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/572/1*r_et1wVTo8Rln76CyFa3tA.png" /><figcaption>Autoria própria</figcaption></figure><p>Quando estamos trabalhando com bancos muito grandes e inúmeras tabelas, convém referenciar o <em>schema </em>respectivo àquela tabela que estamos manipulando, como nesse caso “<em>store.products</em>”, para garantir que estamos acessando o objeto correto.</p><h4>Adicionando dados</h4><p>Normalmente a adição de dados massiva é feita utilizando fontes externas, sejam elas arquivos CSV, XML, utilizando outras linguagens de programação (Python, Java, C# etc), por meio de interfaces gráficas coletando dados diretamente dos usuários ou até mesmo por APIs e outros <em>web services</em>. No entanto, para adições pontuais, também temos os comandos próprios do SQL para quebrar nosso galho.</p><pre>INSERT INTO store.products (name, category, stock, price) <br>VALUES (&#39;Batata frita&#39;, &#39;Comida&#39;, 123, 12.3),<br>       (&#39;TV&#39;, &#39;Eletrônicos&#39;, 12, 1234.5);</pre><p>No comando “<em>INSERT INTO</em>” é passado o objeto a ser utilizado para a adição de dados e, caso não seja necessário adicionar valores em todos os campos, estes também devem ser passados na mesma ordem em que iremos inserir os dados logo abaixo, em “<em>VALUES</em>”.</p><h4>Manipulando tabelas</h4><p>Caso desejemos alterar tabelas já criadas, temos os seguintes comandos que nos podem ser úteis:</p><pre>-- Adicionar nova coluna <br>ALTER TABLE products<br>ADD COLUMN last_sell DATE AFTER price;<br><br>-- Excluir coluna<br>ALTER TABLE products<br>DROP COLUMN last_sell;<br><br>-- Mudar tipo de coluna<br>ALTER TABLE products<br>MODIFY COLUMN price DECIMAL(7,2) NOT NULL;<br><br>-- Mudar o nome da coluna e seus parâmetros<br>ALTER TABLE products<br>CHANGE COLUMN price preco DECIMAL(7,2) NOT NULL;<br><br>-- Mudar o nome da tabela toda<br>ALTER TABLE products<br>RENAME TO produtos;</pre><p>A coluna adicionada nos apresenta a um novo tipo de dado: “<em>DATE</em>”, usado para representar, nesse caso, o formato ‘YYYY-MM-DD’ (ano-mês-dia), mas existem outros tipos, como o “<em>TIME</em>” com formato de horário ‘HH:MM:SS’ (hora : minuto : segundo) e o ‘<em>DATETIME</em>’ que armazena um formato mais completo do tipo ‘YYYY-MM-DD HH:MM:SS’.</p><p>Agora que aprendemos a manipular as tabelas como um todo, precisamos entender como realizar pequenos ajustes dentro delas. Já sabemos adicionar novas linhas, mas vamos entender um pouco sobre como podemos editar e excluir informações já existentes.</p><pre>-- Manipular uma linha<br>UPDATE produtos<br>SET description = &#39;Porção de 300g&#39;, stock = 120<br>WHERE id = 1;<br><br>-- Deletar uma linha<br>DELETE FROM produtos<br>WHERE id = 2;</pre><p>Alguns pontos importantes para se destacar:</p><ul><li>O campo passado na função “<em>WHERE</em>” deve ser, por padrão, a chave primária da tabela, ou seja, apenas uma linha poderia ser manipulada por vez.</li><li>Isso serve como uma proteção padrão da própria linguagem, para desabilitar isso, o seguinte comando deve ser executado.</li></ul><pre>SET SQL_SAFE_UPDATES = 0;</pre><p>Com esse comando, poderíamos, por exemplo, alterar todos os produtos que contenham a categoria “Comida”:</p><pre>UPDATE products<br>SET category = &#39;Limpeza&#39;<br>WHERE category = &#39;Comida&#39;;</pre><blockquote><em>Lembrando que seria apenas uma exemplificação dos comandos, obviamente no nosso caso não faria sentido algum</em>.</blockquote><h4><em>Backups</em></h4><p>Como aprendemos na prática da execução de comandos no SQL, uma vez feito, não tem como voltar atrás, por isso os <em>backups </em>são técnicas imprescindíveis para manter seguro seu banco de dados (e sua sanidade mental).</p><p>Utilizando o <em>MySQL</em>, o caminho para efetuar um <em>backup </em>manual é o seguinte:</p><ul><li>Na barra de menu do software, faremos o caminho “<em>Server </em>&gt; <em>Data Export</em>”:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/488/1*ZgsL3KQrfSJJBsESEFZtBw.png" /></figure><ul><li>A seguir, a seguinte janela irá se abrir. Nela, iremos determinar os parâmetros para o <strong><em>dump</em></strong>, ou seja, nossa cópia de segurança do banco de dados.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*a4EXF7Fr0JLmxKTNP2YYHg.png" /></figure><ul><li>Aqui, podemos selecionar qual <em>schema </em>efetuaremos a exportação e determinaremos os parâmetros da nossa escolha. Vamos marcar a opção “<em>Include Create Schema</em>” para que ele crie automaticamente o <em>schema </em>“<em>store</em>” quando importarmos novamente. Por fim, iremos exportar em “<em>Start Export</em>”.</li></ul><p>Com esses passo efetuados, mesmo que, acidentalmente ou não, deletássemos toda a nossa base (“<em>DROP DATABASE store</em>;”), estamos seguros graças ao nosso <em>dump </em>realizado. Agora, para recuperarmos nossa base em caso de problema crítico, os passos também são bem simples:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/488/1*HP1Jl0ISGOnp_o5Z_ku-Yg.png" /></figure><ul><li>No mesmo caminho para exportar, em vez de “<em>Data Export</em>”, selecionamos “<em>Data Import</em>”.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/995/1*sMBEV-PpaE5iTeCtjfpisQ.png" /></figure><ul><li>Na janela que irá se abrir, localizamos a pasta onde salvamos o <em>dump </em>e executamos a importação.</li></ul><p>Pronto! Temos novamente nossos dados intactos.</p><p>Com isso, finalizamos nossa primeira parte dessa série de artigos sobre o SQL. No próximo, iremos explorar os comandos de consulta em uma base de dados mais complexa. Te vejo lá!</p><h4>Referências</h4><ul><li><a href="https://www.oracle.com/br/database/what-is-database/">O que é um banco de dados?</a></li><li><a href="https://www.databricks.com/br/glossary/acid-transactions#:~:text=ACID%20%C3%A9%20uma%20sigla%20para,ser%20chamada%20de%20transa%C3%A7%C3%A3o%20ACID">O que são transações ACID?</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e5ad103d9bcf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Utilizando gráficos a seu favor]]></title>
            <link>https://medium.com/@pschmitzjr/utilizando-gr%C3%A1ficos-a-seu-favor-cb213e2e4db3?source=rss-7d7fe1d45e08------2</link>
            <guid isPermaLink="false">https://medium.com/p/cb213e2e4db3</guid>
            <category><![CDATA[data-visualization]]></category>
            <category><![CDATA[data-analysis]]></category>
            <category><![CDATA[análise-de-dados]]></category>
            <category><![CDATA[data]]></category>
            <category><![CDATA[analytics]]></category>
            <dc:creator><![CDATA[Paulo Schmitz]]></dc:creator>
            <pubDate>Thu, 01 Feb 2024 22:56:17 GMT</pubDate>
            <atom:updated>2024-02-01T22:56:17.333Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/612/0*meDceRR2xVF3ytwM.jpg" /></figure><p>Recentemente, conversando com um colega no espaço de membros da <a href="https://www.preditiva.ai/">Preditiva</a>, obtive um insight interessante no aspecto de visualização de dados e gostaria de compartilhá-lo.</p><p>Ele havia feito um projeto para seu portfólio, que consistia em uma análise de <em>churn</em> em um aplicativo de delivery. A análise foi apresentada em um artigo do <em>Medium </em>e estava bem completa. No entanto, algo me chamou a atenção: a apresentação dos dados.</p><p>Em uma das visualizações, ele havia utilizado o gráfico de pizza para representar a variável “Sexo”. Naquele momento, recordando um ponto frequentemente abordado no livro “Storytelling com Dados”, de Cole N. Knaflic, prontamente o aconselhei. No livro, a autora discute alguns problemas associados à utilização de gráficos de pizza, destacando a dificuldade visual em identificar as proporções entre as categorias ao ter que comparar áreas e ângulos.</p><p>Outro ponto importante a ser destacado é que um gráfico contendo apenas duas categorias (feminino e masculino) seria limitado no quesito de gerar informações relevantes para a apresentação. Por esse motivo, sugeri que ele agregasse mais valor à visualização realizando uma breve análise dentro do gráfico. Uma mudança simples, porém capaz de fazer toda a diferença na apresentação dos dados.</p><p>Obviamente, por questões éticas, não irei mostrar o gráfico real utilizado por ele, mas posso descrever que era semelhante ao seguinte:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/769/1*6xwp4zCUkxSq7Zkn0_uwiw.png" /></figure><p>Além de poucas informações, observamos uma dificuldade na leitura das legendas. O uso das cores não é necessariamente inadequado, mas não está nos auxiliando a entender melhor a mensagem a ser passada.</p><p>Para evitar muita teoria e pouca prática, vamos observar alguns ajustes que poderiam transformar completamente a maneira como transmitimos a informação.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/855/1*ZWjdH7_R708sxtZQsDlHqw.png" /></figure><p>Agora sim. Observe: nosso foco não está em saber se possuímos mais homens ou mulheres na base — o que não quer dizer que não devemos nos atentar a esse dado, apenas não é o foco principal da análise — mas sim sobre a informação de <em>churn</em>, e veja só, com uma simples visualização obtivemos um insight que, caso confirmado com um certo grau de confiança utilizando um Teste de Hipóteses, já pode ir direto para o nosso Plano de Ação: promover políticas que foquem na retenção do público feminino.</p><p>Além disso, como o assunto aqui é melhorar gráficos, podemos elencar algumas mudanças feitas para tal.</p><ul><li>Utilizamos as cores de maneira a enfatizar aquilo que estávamos querendo mostrar ao leitor. Deixando a barra de <em>churn</em> do público feminino em um tom mais forte e a barra de não <em>churn</em> em um tom neutro.</li><li>Modificamos o título para provocar a curiosidade do leitor, com o intuito de captar sua atenção.</li><li>Retiramos todos os elementos visuais que “poluíam” o gráfico, como o eixo Y (os rótulos nas barras já possuem essa informação), as linhas de grade e a “legenda da legenda” presente no modelo anterior.</li><li>Facilitamos a leitura da legenda, combinando as cores das barras com a da fonte e trazendo-a para cima, ganhando espaço útil na área de plotagem.</li></ul><p>Novamente, são detalhes simples que nos auxiliam a conversar melhor com o público ao qual queremos apresentar nossas ideias, porque uma análise perfeita não valerá de nada se esta não for eficientemente traduzida para aqueles que tem o poder de tomar as decisões. E o que nos melhor auxilia nesse processo de tradução dos conceitos técnicos de estatística e matemática para o mundo real ($$$) é construindo um gráfico de fácil leitura e entendimento.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cb213e2e4db3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>