Transcrições
1. Apresentação: Olá amigos, sou
Tony e vocês estão
no lugar certo se
quiserem aprender
a usar SQL ou sequel para
obter dados de bancos de dados. Para aqueles de vocês
que não me conhecem. Alguns anos atrás, me formei em
engenharia em Boston e fui direto para a ciência de
dados por
alguns anos, até que
decidi voltar para a Venezuela, onde agora estou trabalhando uma
equipe de business intelligence para metade do meu tempo. E na outra metade do meu tempo, estou buscando o que estou ficando empolgada em fazer e
acordar todas as manhãs que é aprender a
aprender e inspirar outras pessoas
a fazerem a mesma coisa. É isso que me traz aqui hoje e também ao
meu canal no YouTube. Quando se trata de SQL, acho que é profissionalmente
há vários anos. E ele chegou ao
ponto em que eu queria compartilhar minha experiência e ensinar aos
outros o que aprendi. Nesta aula, você
aprenderá a usar o eco do zero com uma estrutura de aulas que visa acelerar
seu aprendizado. Você poderá usar o sequel
para escrever o código necessário para obter os dados que
deseja dos bancos de dados. Essa aula é
destinada a qualquer pessoa que não
tenha ideia do
que é um banco ou do que é SQL e
quer aprender como
usá-los do zero. A aula também pode ser muito
útil para quem
já está familiarizado
com esses conceitos e está procurando uma atualização. A única coisa que você
precisa ser ao fazer esta aula é um computador e a vontade de
aprender coisas novas. A aula foi projetada para
que você faça uma aula por dia, gastando
cerca de 10 minutos em cada uma. Dessa forma, novos conhecimentos
entrarão em seu cérebro após uma boa noite de sono
e você
aproveitará o descanso e a recuperação. Vamos
começar a aula
aprendendo o que é igual. Em seguida, analisaremos
a manipulação de dados. Em seguida, analisaremos a consulta de
dados e, em seguida, a agregação de dados. E, finalmente, veremos
como podemos trabalhar com várias tabelas. Também
teremos um projeto de classe que será
construir seu próprio banco de dados usando o sequel em um navegador
de banco de dados que não será baixado.
no curso, construirei um
banco de dados destinado uma empresa como exemplo
durante toda a aula. E você poderá
seguir meu exemplo e ser
criativo à sua maneira. Mas é isso por enquanto, e sem mais nada a
acrescentar, vamos começar.
2. Projeto do curso: Bem-vindo, meu amigo,
e eu só queria lhe dar mais detalhes
sobre o projeto da aula. Então, novamente,
vou construir um exemplo de banco de dados para uma empresa
em toda a classe, que
terá três tabelas, então terá
qualquer cliente estável, subscript se encaixa na tabela
e em seguida, peça de forma estável. E você poderá acompanhar
durante toda
a aula
sobre como construir
isso e como
construir qualquer coisa com a
qual você
se sinta criativo. É muito mais provável que com a
qual você
se sinta criativo terminemos . as coisas que começamos. Portanto, eu
recomendo fortemente que você comece com o
projeto da turma imediatamente. E para isso, tudo o que
você precisa fazer é clicar no
botão Projeto de Classe abaixo. E como ainda não
começamos a aula, você pode simplesmente adicionar meu novo
projeto a um título
e, para o
texto, você pode adicionar isso se transformará em meu projeto
final em breve. Então, eu recomendo fortemente
que você faça isso e faça atualizações no projeto à medida
que avança na aula. Dessa forma, você
aprende sendo ativo em vez de
absorver passivamente as informações. E também aprenderemos
uns com os outros. Mas é isso por enquanto e nos vemos
na primeira aula.
3. Dia 1 - O que é SQL?: Olá amigos e
bem-vindos ao primeiro dia. E hoje vamos abordar alguns dos principais conceitos que precisamos conhecer antes de escrever nossa
primeira linha de código em SQL Sabemos que podemos usar dados para resolver problemas do mundo real. E quando começamos a
trabalhar com dados, acabamos nos deparando com
bancos de dados. Sql significa
Structured Query Language e é uma
linguagem de programação que podemos usar para gerenciar e explorar dados
armazenados em bancos de dados. Um banco de dados é um conjunto de
dados armazenados em um computador. E esses dados geralmente são
estruturados em tabelas, que podem parecer muito semelhantes
a uma planilha do Excel. Podemos usar
consultas SQL para
obter diretamente os dados que queremos
do banco de dados. A linguagem SQL é
amplamente usada atualmente em estruturas web e aplicativos de
banco de dados. Também temos que um banco de dados
relacional é um tipo de banco de dados. Ele usa uma estrutura que
nos permite identificar e acessar dados em relação a outro dado
no banco de dados. Freqüentemente, os dados em um banco de dados
relacional são organizados em tabelas. As tabelas podem crescer e ter uma infinidade de
colunas e registros. As colunas são rotuladas
descritivamente e têm um
tipo de dados específico, por exemplo
, a. A coluna chamada ID do cliente pode ter um tipo de dados inteiro. E aqui
temos um exemplo de
um banco de dados relacional
em que temos tabelas
diferentes que se relacionam entre si com referências
de chaves diferentes e campos
diferentes que são referenciado entre as
diferentes tabelas. E esse é um tipo de
banco de dados que
examinaremos ao
longo do curso. Também temos que um sistema de
gerenciamento de banco de dados
relacional , ou RDBMS, é um programa que
permite criar, atualizar e administrar
um banco de dados relacional. A maioria dos sistemas de
gerenciamento de banco de dados relacional usa a linguagem SQL para
acessar o banco de dados. Por exemplo, temos o SQL Lite, que é um sistema de
gerenciamento de banco de dados relacional que usará, e discourse SQL, como contém um conjunto mínimo de comandos SQL, que são os mesmos em todos sistemas de
gerenciamento de banco de dados relacional. E outros sistemas
de gerenciamento de banco de dados relacional podem usar outras variantes. Alguns populares rDBMSs ou MySQL, postgresql, Oracle
DB, sql Server. E então o que usaremos, que tem SQL light. Aí está. Esses são os conceitos
que aprendemos hoje e agora estamos
prontos para começar a usar o SQL light em nossa próxima lição e começaremos a escrever nossas primeiras linhas de
programa em sequência. Então eu te vejo aqui amanhã.
4. Dia 2 — instale o SQLite (Mac e Windows): Olá meus amigos e
bem-vindos ao segundo dia. Hoje vamos
instalar o SQL light. Então, vamos
começar com o Mac. Se você estiver no Windows,
você pode pular o mesmo vídeo e verá
a instalação para isso. Mas se você é um Mac,
começamos
acessando o Google e
vamos pesquisar o navegador
sequel light. Então, este é um
navegador semelhante ao SQL e queremos encontrar o site SQL lite browser.org. Então,
vamos clicar aqui. Próximo. Vamos tentar encontrar a seção
de download. Então, vou clicar
aqui nos downloads. E já que estamos no Mac, vamos até o Mac OS. E você tem dois cenários. Você pode ter
o chip Intel
ou o chip de silicone da Apple. Então, no meu caso, eu tenho os chips de silicone
da Apple. Então, vou clicar aqui. Até o fundo. À esquerda, você verá
o downloader e ele
iniciará o download. Você vai clicar
nisso. Quando terminar, você
rolará esse ícone,
o aplicativo, até a pasta de
aplicativos. E agora você está pronto para usar o
Command Space para obter a pesquisa do
Spotlight. E você poderá fazer o navegador de
banco de dados para SQL Lite. Então eu apertei Enter, eu apertei em abrir. E isso
abrirá o aplicativo. Então, se você estiver no
Windows, pode acessar o Google e usar um navegador semelhante ao SQL. E vamos pesquisar o site SQL lite
browser.org. Então, há um. Em seguida, vamos encontrar
a seção de download. Uma vez na seção de download, você pode ir para a seção
Windows e ter quatro opções
diferentes. Você pode clicar no instalador
padrão para Windows de 64 bits e isso iniciará
a instalação. Feito isso, você
pode clicar nele. E isso
abrirá os instaladores. Então clique em Avançar,
concordar e em Avançar. E então essa é
a parte importante. Você deseja marcar essa
área de trabalho no navegador de banco de dados. Em seguida, em seguida, em seguida, em seguida, instale. Quando terminar,
você poderá
pesquisar o aplicativo do
navegador DB. E você pode abrir
isso e ver que agora você tem o
aplicativo instalado.
5. Dia 2 — crie uma tabela: Depois de abrir o navegador do
banco de dados, você verá que ele
tem muitas funcionalidades. Para os propósitos deste curso, queremos nos concentrar especificamente nos comandos
SQL. Então é aí que
vamos nos concentrar. Então, vamos ignorar a maioria dessas funcionalidades. E vamos nos concentrar no que podemos escrever em SQL, que é a coisa mais
poderosa. Uma coisa que precisamos
fazer é criar
um novo banco de dados para
que
possamos começar a criar
nossas novas tabelas e ter nosso novo banco de dados. Clicamos no novo banco
de dados aqui e isso nos
solicitará que adicionemos
um nome a esse arquivo. Vou ligar para essa
empresa no meu desktop, e ela terá
a extensão SQL. Então você verá aqui também que ele
terá a extensão dot db. Vou clicar em Salvar. E agora essa janela
aparece e eu
vou fechar essa
janela porque
vou ignorá-la por enquanto. Mas agora estamos
trabalhando, como você pode ver, na extensão na parte superior
da janela
que diz empresa dB. Estamos trabalhando em
nosso novo banco de dados que acabamos de criar. A primeira coisa
que faremos em nossos bancos é criar
uma nova tabela para
que possamos começar a adicionar dados a uma tabela e
adicionar registros a essa tabela. Então, vamos
navegar até
a seção Executar SQL. Isso nos levaria
a essa área de texto. Podemos escrever qualquer texto
que quisermos e é
aqui que vamos
digitar os comandos SQL. Então, para criar uma tabela, acrescentamos que
isso é chamado
de cláusula de sequência. Então, a classe
será create table. Em seguida, adicionamos o
nome da tabela. E nesta vamos
criar uma mesa chamada atores. Em seguida, temos
colchetes e
terminamos a declaração
com um ponto e vírgula. Temos que terminar todas as instruções
SQL com ponto e vírgula. Agora, entre esses
colchetes, é onde
colocaríamos as colunas que
queremos ter. Vou adicionar um pouco de espaço
para que fique mais legível. E nossa primeira coluna será chamada de id. Em seguida, teremos
uma coluna chamada nome. E, finalmente, vamos
adicionar uma coluna chamada idade. E como você pode ver, nós
os separamos por vírgulas. E outra coisa
que colocamos com os parâmetros de
cada coluna que precisamos
adicionar e precisamos especificar
o tipo de dados de cada coluna. Então, para ID, teremos
números inteiros. Vai ser um número inteiro. O nome será
um texto do tipo texto
e, em seguida, h também será
do tipo inteiro. Agora temos nossa declaração
completa de nossa instrução de criação de tabela
para criar a tabela chamada
médicos com todas as colunas e
todos os parâmetros. E podemos clicar
nesse vínculo aqui. Ou poderíamos fazer o Command Enter
para executar essa consulta. E podemos ver aqui embaixo que nossa consulta foi
executada sem erros. E agora podemos navegar até a seção de
estrutura do banco de dados. E podemos ver que temos uma tabela chamada atores
que acabamos de criar. E também podemos expandir
isso para ver quais são os
atributos e quais são os parâmetros que
estamos inserindo no comando
que acabamos de executar. Ok, agora que
criamos nossa tabela, podemos executar uma consulta diferente. Então, vou
excluir essa consulta porque acabamos de
criar nossa tabela. E vamos executar
uma consulta diferente para inserir valores na tabela. Acabamos de criar
a classe na qual essa consulta será inserida. E então vamos
dizer o nome
da mesa, que é atores. E então vamos
fazer colchetes. E entre os colchetes
, adicionaremos as colunas às quais
adicionaremos nome, id, nome e idade. Em seguida, adicionamos uma cláusula de valores. E, novamente, lembre-se de
que você pode escrever tudo em uma linha,
se quiser. E o espaçamento aqui realmente não
importa, mas estou apenas adicionando outra linha apenas para torná-la mais legível. Então, adicionamos a cláusula de valores
e, entre mais
colchetes, adicionamos os valores que estamos adicionando na mesma
ordem que declaramos acima. Então, se fizermos o nome e a idade do ID, primeiro
inserimos o ID
que estamos inserindo. Então vamos dizer, vamos dizer que vamos adicionar Brad Pitt como nosso primeiro fator. Então vamos
fazer 58 para a idade. E vamos
fazer um ponto e vírgula. Então, Command Enter e
vemos aqui embaixo a execução finalizada sem
erros. Então, isso é perfeito. Agora, se quiséssemos ver
o que está dentro dessa tabela, poderíamos fazer Browse Data aqui
e, em seguida, ter nossa tabela. Selecionamos a mesa aqui
na mesa para atores. E então temos ID1, Brad Pitt e 58 anos. Vemos que
acabamos de inserir esse registro em nossa tabela. Então, vamos voltar
para nossa seção Executar SQL e
adicionaremos mais valores. Então, vamos fazer o item número dois
ou o ID número dois. Vamos fazer
Scarlett Johansson com 37 anos. E se quiséssemos adicionar
mais itens aqui, poderíamos separar
os colchetes por vírgulas. Então, poderíamos fazer isso, por exemplo adicionar uma vírgula aqui, adicionar mais espaçamento para que fique mais legível e adicionar
mais campos a ele. Agora que adicionamos
mais itens à nossa tabela, podemos fazer Command Enter
ou Command Return novamente. E podemos ver que nossa execução terminou
sem erros. E então voltamos à
nossa seção Navegar por dados. E podemos ver nossa mesa
aqui com nossos quatro atores. E agora que
criamos nossa tabela com a instrução create table e depois inserimos nas instruções. Agora podemos executar uma instrução de
seleção. E uma instrução select é
executada quando queremos obter dados de uma tabela que já
existe. Então, podemos selecionar. Em seguida, vamos fazer
o curinga chamado all. Então é uma estrela e
chamamos isso de tudo. Então, selecione tudo. Em seguida, de. Usamos a
cláusula from para indicar a tabela que queremos
obter dos atores e, em seguida, colocamos um ponto e vírgula. E quando executamos isso, vemos aqui embaixo que temos tudo o
que selecionamos. Então, selecionamos
tudo do ator estável e é isso que retorna ou o que é
retornado dessa consulta. E podemos ver que nossa
mesa é devolvida. E, novamente, lembre-se de que fizemos isso para cada tipo de dados, certo? Portanto, a primeira coluna
é um número inteiro, a segunda coluna
é uma coluna de texto
e, em seguida, a terceira coluna
tem uma coluna de idade. E pudemos ver isso na estrutura
do banco de dados. Se subíssemos até aqui, estrutura
de banco de dados, abriríamos nosso estábulo de atores. Pudemos ver que id é inteiro, nome é texto e
idade é número inteiro. Uma última coisa é que as aulas são escritas em letras
maiúsculas, mas não são obrigatórias para
serem escritas em maiúsculas, mas são feitas
dessa forma para convenção. Então, lembre-se disso e
então poderíamos executar tudo em uma linha,
se quiséssemos. Isso também funcionaria
perfeitamente bem, mas estamos apenas executando linhas
separadas para que
seja mais legível. Então aí está. Hoje,
analisamos como criar uma tabela com os tipos de dados
apropriados às colunas. Em seguida, como adicionar novos
registros a essa tabela
e, em seguida, como selecionar
tudo dessa tabela. Se quiser
, fique à vontade para atualizar seu projeto de classe com as coisas que você
aprendeu hoje com seu novo banco de dados
e suas novas tabelas. Além disso, obrigado por assistir e
nos vemos novamente amanhã.
6. Dia 3 - Gerenciando tabelas: Olá amigos e
bem-vindos ao terceiro dia. E hoje
vamos analisar diferentes maneiras de
gerenciar nossas tabelas. Vamos examinar a instrução select novamente,
a instrução alter, update where Delete e
diferentes restrições. Portanto, sabemos da
última lição que podemos selecionar tudo de uma tabela
usando essa declaração. Então, se selecionarmos
todos os atores, teremos todo o nosso
estábulo de atores que será devolvido. Se quiséssemos selecionar uma coluna
diferente,
gostaríamos de recuperar da nossa tabela. Poderíamos nomeá-los
pelo nome da coluna. Então, em vez
de selecionar tudo,
podemos dizer selecionar nome, digamos nome e, em seguida,
separados por vírgula, podemos dizer h. Então, agora
selecionamos nome e idade. E quando pressionamos Enter,
vemos que recebemos
tudo de volta , exceto
da outra coluna que não especificamos. Então, temos nosso nome
e nosso H retornou. Agora, digamos que queremos que ela mude nossa tabela e que queiramos
modificar uma tabela adicionando uma
nova coluna a essa tabela. Então, vamos deletar isso. E para isso, vamos
administrar a mesa alternativa, essa nova aula que
estamos aprendendo. Então altere a tabela, vamos especificar
a tabela. Vamos dizer se atores. E vamos adicionar uma coluna. Novamente, estou fazendo isso
em uma linha separada, mas se você
quisesse, você poderia fazer tudo em uma linha. Estou apenas fazendo linhas separadas
para torná-lo mais legível. E lembre-se de que todas as
letras maiúsculas não são necessárias, mas foi feito dessa
forma para
a Convenção, a nova coluna se
chamará identificador do Instagram. E
será um texto digitado. Então aí está. Primeiro,
você especifica que deseja alterar a tabela e nomeia a tabela
que deseja alterar. Em seguida, adicione uma coluna com o nome da coluna e
o tipo de dados da coluna. Então, quando eu executo isso, ele diz que a execução
foi concluída sem erros. E agora, se eu quisesse dizer, selecione todos os atores. E lembre-se de que você pode
usar esse botão Play and Stop apenas para executar a linha
atual que você tem. Então você pode executar isso apenas
para executar essa linha atual. E você vê que
temos nossa tabela selecionada com uma nova coluna
com tudo como nulo. Portanto, nulo significa que ele
não tem dados nesse campo
ou nesse registro. E se quiséssemos atualizar nossa tabela para adicionar dados e adicionar informações a
essas colunas nulas ou aos registros nulos
que acabamos de criar para isso. Vou deletar
isso por enquanto e
vou dizer atualização. Portanto, esse seria
o cluster de atualização. Então, vou
dizer atualize atores. Então, o nome da tabela
que eu quero atualizar. E eu vou dizer que defina o identificador
do Instagram igual a. E então
seriam alguns textos. Portanto, todos os textos
que você quiser e que você queira aqui, você pode inserir os textos
que quiser aqui. Por enquanto, vamos fazer
o nome de Brad Pitt no Instagram. Então, vamos dizer Brad Pitt. E podemos adicionar uma declaração where
e aprenderemos. Aprenderemos
mais sobre a palavra “cláusula
where” em outras lições. Mas, por enquanto, podemos ver
onde id é igual a um. Então, o que estou dizendo aqui? Estou dizendo que atualize a
tabela chamada médicos e defina o campo chamado
identificador do Instagram ou a coluna
chamada identificador do Instagram. Você vai defini-lo como
igual a Brad Pitt, onde id é igual a um. Então, quando eu executo isso e digo selecionar,
selecione todos os atores e o executo apenas com a
declaração que eu selecionei. Podemos ver que Brad Pitt
agora tem um nome no Instagram. Então, vou criar
declarações para adicionar alças a outros
atores também. Ok, agora eu criei outra declaração
ou outra consulta para adicionar ou adicionar nosso identificador do Instagram também a
Scarlett Johansson e a Matt Damon
referenciando seus números de identificação. Então, se eu selecionar ou colocar meu cursor nessa consulta e eu fizer esse
botão play and stop , isso só
executará essa consulta novamente. Então, vou selecionar
essa consulta no botão. E eu vou executar isso de novo. Em seguida, basta uma declaração de seleção. E então vou
executar isso e
vou ver minha nova mesa,
ou a mesma mesa de antes, mas alterada de uma forma que agora
tenho identificadores no Instagram
para a maioria dos meus atores, exceto Morgan Freeman. E agora, a próxima declaração
que
veremos será a declaração de
exclusão. Então, eu quero excluir, digamos que eu queira
excluir Morgan Freeman. Há muitas maneiras de
fazer isso, e uma delas é usar
a classe Delete. Excluir dos atores. Eu digo excluir dos atores. Em seguida, adiciono uma cláusula where para especificar qual delas
eu quero excluir. Então, onde fica o Instagram. É nulo. Portanto, isso é conhecido como
uma nova declaração de que as
referências
aos valores que não são, você poderia fazer são nulas e você também
pode fazer não são nulas. Mas, por enquanto, isso é usado é nulo. E quando executo essa consulta, posso ver, ok, aqui embaixo, execução foi concluída
sem erros. E agora eu começo com, quando seleciono, seleciono
todos os atores. Novamente, aqui, posso ver que Morgan Freeman
foi excluído. Agora eu posso ver
Brad Pitt marcando
suas mãos e Matt
Damon apenas os, apenas os registros e somente as linhas que têm um identificador
no Instagram porque tudo o
que não tinha um O identificador do Instagram foi excluído. Então, se eu tivesse, teria mais linhas ou registros sem um
identificador do Instagram como nulo. Esses também teriam sido
excluídos. Ok, então isso era
tudo o que
aprenderíamos com nosso estábulo de atores. Agora poderíamos usar, se quiséssemos
excluir uma tabela, queremos que ela elimine uma tabela. Nós diríamos atores de mesa. Isso faria com que, ao executar isso, eu acessasse
os dados do meu navegador e veria que não tenho nenhuma
tabela e acessaria a estrutura de dados ou a estrutura do
banco de dados. E eu veria que não
tenho mesas porque deixei cair a mesa. Então é assim que você
exclui uma tabela. Agora vamos
excluir isso e criar uma nova tabela, que é
aquela que usaremos no banco de dados da
nossa empresa
e a que
usaremos durante o
resto do curso. E será a mesa
de um cliente. Então, para fazer isso, criamos uma tabela, como vimos em uma
lição anterior. Clientes. Em seguida, podemos fazer texto de ID,
número inteiro, nome, textos ,
idade, número inteiro e
nacionalidade. E também
examinaremos alguns outros parâmetros
que podemos especificar ao
criar uma nova tabela. Por exemplo,
digamos que queremos que o ID seja um identificador exclusivo na
escola e em bancos de dados
relacionais. Assim, como chamaríamos ou chamaríamos isso de
chave primária primária. Então, agora estou dizendo que estou
dizendo
ao SQL ou SQL light que transforme essa coluna id em um número inteiro e também a
torne uma chave primária. Outro parâmetro que
estou afirmando por enquanto, aprenderemos mais sobre chaves primárias
em uma lição adicional. Mas, por enquanto, digamos que o ID será exclusivo
e não pode ser nulo. E será
perfeito identificar cada linha de
forma exclusiva da tabela. Então, isso é o que é uma chave primária. Em seguida, temos nossa
coluna de texto, coluna de nome. Queremos que isso também seja
único. Não é uma chave primária, mas
queremos torná-la única para que possamos
especificar isso também. E também podemos especificar que
queremos que não seja nulo. Então, o SQL light
garantirá
que não nos permita
preencher um registro com
o nome da coluna um valor nulo porque precisamos
torná-la não nula. Então a idade
será apenas um número inteiro. E então a nacionalidade,
vamos adicionar um valor padrão. E queremos que esse
valor padrão não esteja disponível. Portanto, sempre que inserirmos
um novo registro nessa tabela e tivermos a
nacionalidade como nula
, o valor padrão
ocorrerá e isso seria um não disponível
em vez de nulo. Então aí você tem uma
maneira diferente ou diferente, uma maneira diferente de criar uma tabela com mais parâmetros
para torná-la mais específica e torná-la mais funcional quando a
usarmos mais tarde. Então, temos nossas chaves primárias, temos nossas declarações exclusivas. Também temos nosso
parâmetro NOT null
e, em seguida, temos nosso parâmetro
padrão. E quando clicamos em Command Return, podemos ver que a
execução foi concluída. E quando acessamos nossa estrutura
de banco de dados, temos nossa nova tabela chamada
clientes com um ID, nome, idade e nacionalidade
na descrição e nos
tipos de dados que temos aqui. Mas agora estamos prontos para começar
nossa próxima aula, na qual trabalhamos
com a tabela de clientes. Se quiser, você pode atualizar seu projeto com o
que aprendeu hoje. E estou ansioso
para encontrá-lo aqui para a próxima aula de
amanhã. Te vejo.
7. Dia 4 - consultas 1: Bem vindos de volta, meus
amigos hoje, por isso. E hoje
vamos analisar diferentes consultas
que podemos escrever. Portanto, temos
seções diferentes neste curso sobre consultas e hoje
será nosso primeiro
dia de análise
dessas perguntas. Portanto, temos nossa
estrutura de banco de dados por enquanto. Assim. Temos que temos apenas uma tabela em um banco de dados
relacional chamado Clientes com
essas quatro colunas ou esses quatro atributos. E temos nossa ID
como nossa chave primária, que será analisada mais adiante
em uma lição posterior. Mas agora podemos entrar na nossa seção de execução ou na seção
Executar SQL. E a primeira coisa que podemos fazer, apenas examinar o que temos, podemos selecionar todos os clientes só para
ver o que temos, certo? Então, Command Return. Vemos que nada é retornado na segunda
janela aqui embaixo, porque ainda não temos nada
nesta tabela. Portanto, no
material de apoio abaixo, você pode ver na descrição
que você pode baixar um recurso de suporte
que será mais ou menos
assim. Portanto, é uma espécie de arquivo de texto
que terá algumas
das informações que serão úteis para criar o mesmo banco de dados e para que
possamos trabalhar
no mesmo banco de dados. Então, aqui está uma
declaração de criação que já executamos, a tabela de criação de clientes. E depois há uma declaração para adicionar registros a essa tabela. Então, vou copiar
isso e colar isso aqui. E eu vou executá-lo. Depois de executá-lo,
agora posso excluí-lo e selecionar tudo dos clientes. E agora eu posso ver aqui
na execução que
coloquei minha tabela completa
no banco de dados. Então, novamente, poderíamos fazer,
em vez de selecionar tudo o que também podemos fazer, por exemplo, nome e idade Command Return. E podemos ver
que podemos selecionar somente as colunas
que especificamos. Também selecionamos cada uma
dessas colunas. Então, obtemos todos os registros
da tabela somente com essa coluna. Também podemos usar a palavra-chave, que é essa. Então você pode dizer As
e depois anos, por exemplo, e agora você está virando
esse nome em vez de dizer que idade vai dizer anos porque estamos transformando
isso usando a palavra-chave. Há outra declaração
chamada cláusula order BY. Portanto, podemos ordenar por e colocar na parte inferior de nossa consulta
SQL nesse caso. Assim, podemos fazer o
pedido e especificar o nome. E, por padrão, a ordem
BY é ascendente. Mas podemos dizer descendo
assim, DESC. E quando executamos isso, pudemos ver que nosso estado de retorno
é o conteúdo
retornado, os nomes são descendentes e também temos
os anos. Também existe uma maneira de selecionar as tabelas
distintas. Poderíamos selecionar uma nacionalidade distinta, digamos,
dos clientes. Então, agora estamos selecionando a nacionalidade, mas
apenas as distintas. Então, fazemos o Command Return e
obtemos todos os países. Vemos que todos os nossos
clientes são de sete nacionalidades únicas
, como vemos aqui embaixo. Então, lembre-se novamente de que
temos a cláusula where
que podemos usar para especificar ou filtrar coisas
específicas. Portanto, podemos dizer, por exemplo, selecionar todos os clientes. Poderíamos fazer onde h
é maior que 30. Então, é assim que selecionaríamos todos os nossos clientes com idade superior a 30 anos. Então, vemos que recebemos
sete clientes de volta. E essa é uma boa
maneira de filtrar. E porque em vez disso, maior do que você também poderia usar maior ou igual a, menor que,
menor ou igual a. E você também poderia fazer o mesmo, é
claro, que
seria assim. E você também pode
até mesmo não ser igual a. Então isso seria um
ponto de exclamação e um sinal de igualdade. Então, podemos dizer que H
nada é igual a 30. E fazemos o Command Return. E vemos que recebemos todos os
nossos clientes de volta porque nenhum deles é igual a 30. Mas, por exemplo, se o
fizermos, fizemos 25 não igual a 25? Receberíamos uma lista de clientes, então receberíamos a devolução
de nove clientes. Então foi isso por hoje. E, como exercício, vou descartar algumas
ideias e algumas coisas que você pode tentar exercitar e algumas
perguntas que você pode experimentar. Por que você não tenta selecionar todos os clientes pedidos por
idade e descendência? Então isso será um desafio. E então outro
desafio seria selecionar todas as idades distintas. Portanto, selecione todas as
idades distintas da nossa tabela de clientes. E, finalmente, selecione
todos os clientes com idade
menor ou igual a 25 anos. Vamos ver o que obtemos. Então, esses são alguns exemplos
de coisas que você pode experimentar. E por hoje, isso
vai acontecer e eu vou ver você novamente aqui amanhã para analisar
mais consultas que podemos executar.
8. Dia 5 - consultas 2: Bem vindos de volta, meus
amigos. Eles cinco. E hoje vamos
analisar mais consultas
que podemos executar. E, mais especificamente,
começaremos usando curingas. Então, digamos que se formos
aqui para pesquisar dados, temos todos os nossos usuários, certo, com todas as nacionalidades em seus nomes
e IDs. Digamos que
quiséssemos selecionar, por exemplo esses dois usuários nomes muito semelhantes. Então, Mary Madan e Mary Malin. E se quiséssemos selecionar todos os clientes chamados de uma determinada maneira com um personagem
que pode variar ou com,
com qualquer
campo de caractere intermediário? Eu vou te mostrar aqui. Eu poderia dizer que
poderíamos selecionar todos os clientes, onde
poderíamos usar nossa cláusula
onde, onde é o nome. Portanto, esta é nossa cláusula por
enquanto ou um filtro por enquanto. Vai para aquele que
estamos aprendendo agora que se chama like e quando podemos
passá-lo em uma string ou texto. E esse texto,
vamos dizer Mary, como vimos aqui antes. Então é Malin e fez isso. Então, queremos selecionar
os dois com um único comando e
vamos dizer sublinhado de
maio e
E n. Então,
isso faria com que a consulta
executasse sql, diz praticamente selecionar
todos os nomes em que é como esse nome. E isso é
chamado de curinga, que afirma que ele
pode ser preenchido com praticamente qualquer personagem e
qualquer cliente que
atenda a esses critérios. Então, quando clico em Command Return, vejo que recebo esses
dois clientes de volta porque ambos atendem aos critérios que eu especifiquei aqui com o curinga
do sublinhado que especifica que isso poderia
ser qualquer personagem. Outro exemplo
de curinga
seria que também no
nome eu posso dizer que é como se eu quisesse selecionar todos os clientes
que começam com J, J maiúsculo e não. Então eu poderia fazer, eu poderia usar
esse curinga. A porcentagem. E isso significa que a sequência é que ela
praticamente seleciona tudo o que começa com
JO e depois é seguido por qualquer outra
sequência de personagens. Então, quando eu faço o Command Return, pude ver que
recebo todos os clientes que começam com j e 0. Eu também poderia usar esse curinga
no começo. Então eu poderia fazer tudo o que começa com o que tem um a, um a seguido por um N e depois termina com o que quer que seja. Então, se eu fizer o
Command Return e executar essa consulta, vejo que recebo
Jane Doe, Simon Letterman e Mike Hannigan
porque todos eles têm um a seguido por um final. Agora, digamos que
queremos trabalhar com o operador não nulo sobre o qual
falamos antes. Então, quando queremos
selecionar linhas que tenham um valor nulo ou que
não tenham um valor nulo. Não usamos o sinal não igual ou igual ao
sinal,
mas, em vez disso, usamos
o seguinte. Digamos que quiséssemos
selecionar todos os nomes. Portanto, selecione nomes de clientes
em que a idade não seja nula. Então, eu quero ver todos aqueles, todos os clientes quando eu corro que têm a
idade não é nula. Então eu recebo uma lista
de todos os nomes. E como você pode ver, é
uma lista de dez nomes. E se voltarmos
aqui para pesquisar dados, vemos que temos 12
clientes no total, mas Liam e Matt aqui
na parte inferior não têm uma idade e têm
uma idade nula. Portanto, eles não são selecionados. Se eu quisesse selecionar os clientes que
têm um valor nulo, o que
eu faria é nulo. E então eu vejo o Lehman
e Matt serem selecionados. Mas lembre-se de que é
assim que gerenciamos valores
nulos. É assim que usamos
null nas instruções de seleção, nas piores declarações, em vez de usar o sinal
igual ou
não igual que usamos é nulo. Em vez disso, não é nulo,
mas aí está. Essas eram formas diferentes de consultas
diferentes
que poderíamos usar. Você pode brincar
com os curingas, com os itens de texto e os atributos que
selecionamos anteriormente. Você pode brincar com
isso e ficar à vontade para atualizar seu projeto com as coisas que
aprendeu até agora. E faremos questão de
conversar sobre isso ou
falar sobre isso
e dar feedback na seção da comunidade. Mas eu vou te ver novamente aqui amanhã e obrigado
novamente por assistir.
9. Dia 6 - consultas 3: Bem vindos de volta, meus amigos. Se eles seis. E hoje vamos
continuar
analisando diferentes consultas
que podemos escrever. Outro exemplo seria se quiséssemos pegar
ou se quiséssemos
selecionar todos os nossos usuários que estão entre uma faixa etária diferente ou
entre uma faixa etária especificada. Então, para isso, poderíamos selecionar, digamos que eu queira
selecionar todas as colunas. Portanto, selecione todos os clientes. Então, na cláusula onde, faríamos onde, idade e adicionaríamos literalmente
entre , digamos 29,35. É assim que você
escreveria que faria o primeiro número
e o segundo 135. Então, eu faço o Command Return e recebo um erro porque
escrevi incorretamente a idade. Mas aí está o Command Return. E aqui temos John
Doe e depois Jose Gomez, e então temos, essas
são as idades de 29 a 35 anos. Também poderíamos fazer algo
semelhante com os nomes. Então, poderíamos dizer, por exemplo selecione o nome, onde o nome está entre,
se dissermos D e g. Então, isso selecionaria todos
os nomes que começam com D
até G sem incluir o G em menos do que
o nome é puramente um. G, como no nome, é
puramente um caractere. Porque antes, quando
fazíamos 29 a 35, incluíamos tudo
até 35 e incluindo 35. E nesse caso, quando
estamos fazendo as letras, então fazemos Command Return e
fazemos um Command Return, vemos que não recebemos nada
retornado porque não
temos nomes abaixo
desses caracteres. Mas se analisarmos nossos dados, digamos que m e DOE, digamos m e 0 entre M&O, vemos que, desde que Mary se casou com Matt, Mike e Monica
são o caminho para 0. Mas digamos que quiséssemos selecionar
até S com para ver se incluímos
a tarefa. Se voltarmos aqui e fizermos S, vemos que fazemos
o comando return. Executamos a consulta
e ainda não incluímos Simon porque
o S não está incluído. Mas lembre-se de que, se o nome
dessa pessoa fosse apenas um S, literalmente apenas um caractere , ela
obteria, seria escolhido. Agora vamos ver como podemos executar instruções where
mais úteis. Então, agora, digamos que
quiséssemos selecionar todos os clientes
entre os clientes. Agora, digamos que
queremos usar declarações. Então, queremos selecionar todos
que tenham menos de 40
anos e tenham nacionalidade
dos Estados Unidos. Então, para isso, poderíamos fazer, poderíamos executar nossa
cláusula onde como antes. E podemos dizer que ele
tem menos de 40 anos, então todo mundo com menos
de 40 anos. E assim podemos especificar o final. A nacionalidade é igual
à dos Estados Unidos. Então, se adicionássemos um
ponto e vírgula e
executássemos isso, poderíamos ver apenas
John Doe porque ele tem menos
de 40 anos e é dos Estados Unidos. Há também um operador
chamado operador or. Então, se dissermos, volte aqui novamente e diga OK, selecione todos os clientes, onde a nacionalidade
é igual à Itália ou a nacionalidade é
igual à Jamaica. Nós clicamos em Command Return. E vemos as pessoas que
são da Itália e da Jamaica porque
usamos o operador or. E esse também é um comando muito
útil de usar. Lembre-se de que a ordem por agente, sobre a
qual falamos antes,
se transforma em fantasma após
a cláusula onde. Então, se quiséssemos ordenar
isso por nome, por exemplo
, descendente ou
algo parecido. E poderíamos fazer o
Command Enter e podemos ver,
ok, ele virou. Agora é Matt Damon, um
diamante louco no início e Liam Nissan no segundo porque pedimos
por descida. Eu chamei de ascendente, mas
foi isso que hoje, os caras
se sentem à vontade para
brincar com esses novos armários e aprendemos
porque eles são
muito, muito mais úteis. E, por exemplo, para a classe de palavras,
quando usamos o operador AND E
o operador OR, são muito mais
úteis do que antes. Também aprendemos como usar
a classe between e que a cláusula order BY vem
depois da instrução where. Então foi isso por hoje. Muito obrigado a todos por assistirem. Sinta-se à vontade para atualizar seus projetos de classe com o
progresso que você fez. E te vejo de
novo aqui amanhã.
10. Dia 7 - consultas 4: Então, bem-vindo de volta, meu amigo. E dois dias e sete e hoje
vamos analisar um
pouco mais a questão para
podermos escrever. E vamos começar
dizendo que
queremos que ele selecione
entre Clientes, mas limitado a dez usuários. Não queremos que
todos os usos sejam cortados
da tabela de nossos
clientes. Mas queremos obter, gostaríamos de fazer com
que todos
eles chegassem a dez. Então, para isso, poderíamos usar
a declaração de limite. Então, digamos que selecione
todos entre clientes, clientes e, em seguida,
podemos dizer o limite de dez. Se eu quisesse pegar
o limitado a dez. Então, poderíamos fazer o Command Return. E vemos a partir daqui que
recebemos apenas dez usuários retornados. Poderíamos especificar
números diferentes aqui, com certeza. Assim, podemos economizar cinco, por exemplo, e obteríamos o limite
para cinco ou uma amostra de cinco. Agora, digamos que quiséssemos
selecionar o mais velho, três pessoas ou três clientes. Então, os três principais clientes
mais antigos. Para isso, poderíamos selecionar todos os clientes da
mesma forma que selecionamos. Poderíamos ordenar por idade, decrescente, e então podemos
limitar aos três primeiros. E isso nos daria nossos três
principais clientes mais antigos. Então, analisando
Jaime, Mary e Mike, podemos fazer algo
realmente interessante, que é uma forma que
poderíamos fazer para adicionar alguma lógica aos
nossos comandos de sequência. Então, digamos que quiséssemos categorizar nossos clientes. Então, digamos que quiséssemos adicionar categorias aos nossos clientes,
dependendo da idade deles. Em alguém que diz que todos
com menos de 18 anos são menores de idade, qualquer pessoa com mais de 61
anos é idosa. E então, qualquer pessoa
intermediária está simplesmente no meio. Então, poderíamos adicionar essa
categoria dessa forma. Então, podemos dizer selecione
o nome, assim. E então, como outra coluna
que queríamos adicionar, vamos adicionar
uma declaração de caso, que é como uma instrução if, se você estiver
familiarizado com programação. Portanto, é uma forma de selecionar opções
diferentes. E podemos fazer isso assim. Podemos dizer que é o caso. Novamente, estou adicionando todo o espaçamento apenas para
torná-lo mais legível. Então, caso, mas podemos adicionar tudo isso em uma linha,
se quisermos. Mas estou apenas tentando
torná-lo mais legível. Então, posso dizer um caso em que
a idade é inferior a 18 anos. Então, abaixo de H,
assim, eu digo, eu posso fazer outro quando
h é maior que 61. Em seguida, sênior. Então eu poderia fazer outra coisa. Se nenhuma dessas
afirmações for verdadeira, então você poderia fazer
no meio, no meio, no meio, assim. E todas as nossas declarações de caso terminam com uma
declaração final como essa. Portanto, podemos ter nosso
caso B quando menores de 18 anos, menores de 61 anos do que idosos. Caso contrário,
ficará no meio. Então, quando eu fizer isso
com clientes e fizer isso, vou expandir
isso um pouco e vou fazer o Command Return. Então, vejo que cada cliente é classificado como intermediário, sênior
ou abaixo de H, assim, quando vejo abaixo. E então podemos ver que
o nome da coluna é muito longo para isso. E aqui podemos usar
as declarações ***. Então, podemos fazer o mesmo, vamos fazer a
categoria e fazer o Command Return. E então podemos ver
que o nome
da coluna agora é categoria. E então vemos que temos
a categoria para cada um
dos clientes que temos.
Era isso por hoje. Vimos como usar
a declaração de limite. Também a
declaração de limite combinada com a cláusula order BY. E agora usamos também uma declaração de caso para
que possamos ter lógica em nossas declarações e usamos a declaração de caso para categorizar diferentes
opções em nossos clientes. Mas foi isso por hoje, pessoal, muito
obrigado a todos por assistirem. Sinta-se à vontade para atualizar seus projetos de
classe com as coisas que você aprendeu até
agora em seu progresso. E te vejo de
novo aqui amanhã.
11. Dia 8 - Funções agregadas 1: Bem-vindo de volta, meu
amigo. E hoje oito e hoje vamos examinar
funções agregadas em SQL. vamos começar falando No entanto, vamos começar falando
um pouco sobre
comentários. Há duas maneiras de
fazer comentários. Poderíamos fazer o forward slash star e, em seguida, tudo o que
incluirmos entre elas. Então, barra para frente
e barra de estrela para fechar, isso transformaria isso
em um comentário. Ou você pode fazer dois traços como este são dois
hífens como este. Isso seria um
comentário de uma linha em oposição
ao comentário de várias linhas que mencionei antes, como este. Mas essa é uma boa maneira de adicionar. Digamos, digamos, por exemplo que
você queira adicionar uma descrição ao código que está executando. Dessa forma, você pode adicionar uma descrição sem
interferir com o, com o editor de código,
porque seria apenas, não será executado, será ignorado porque é
isso que é um comentário é quatro. Então, voltando às funções agregadas,
examinaremos, por exemplo a função de contagem,
também a função soma, as
funções máximo e mínimo, média. E, finalmente, a função redonda. Então, essas são as funções
agregadas que vamos
analisar hoje. E isso adicionaria muito mais funcionalidade
à forma como
escrevemos nossas consultas. E isso nos dará muito
mais informações do que as que
estávamos recebendo antes. Começamos a ficar muito mais flexíveis com as coisas que
podemos solicitar ou com as consultas que podemos executar para obter dados
do nosso banco de dados. Então, digamos, por exemplo,
que quiséssemos examinar selecionar todos os clientes novamente, apenas para examinar nossa tabela. Então, temos nossa identidade,
temos nosso nome, temos a idade e a nacionalidade. Então, digamos que quiséssemos contar todos os clientes que
temos com mais de 30 anos. Então, para isso,
faríamos aqui, selecionaríamos todas as coisas que sabemos de nossas lições
anteriores, certo? Então, poderíamos fazer onde
a idade é maior que 30. Mas como contamos isso? Bem, não tínhamos
ouvido o começo. Podemos contar e adicionar
o que você quiser contar entre os colchetes
. Aqui queremos contar simplesmente todas as linhas
que recebemos. Se executarmos o comando,
executaremos isso. Vemos o número sete, o que significa que temos uma
contagem de sete clientes. E aqui, novamente, podemos
fazer e como garras e dizer :
Digamos que poderíamos
dizer, vamos contar. Novamente, temos sete clientes. Digamos que também quiséssemos
adicionar ou obter a idade, a soma da idade dos
clientes que tínhamos. Esses dados não são muito úteis. Mas neste exemplo está
o que podemos fazer com a função de soma agregada. Podemos adicionar a idade. Podemos adicionar aqui
o sol e dizer:
Ok, o que é o DH adicionado? Então, quantos anos nossos
clientes viveram no total? Novamente, também podemos
usar a função max. Então, podemos dizer o que
é, quem é o mais velho de nossos clientes? E então vemos que o
mais velho tem 67 anos. Poderíamos fazer o mesmo
com o mínimo. Nós os colocamos aqui. E isso nos daria 21
anos de idade, é o mais novo. Ok, interessante. E também poderíamos
fazer a média. Poderíamos fazer a
idade média como média. E podemos ver que a idade
média é de 38,9 anos. E agora, e se quiséssemos
contornar isso de forma diferente? E se quiséssemos arredondar
isso para dois decimais? Poderíamos dizer em torno da média. Adicionamos duas afirmações a cerca, separadas por uma vírgula e
, em seguida, dizemos duas com duas o número de casas
decimais que
queremos que seja arredondado. Então, obtemos o mesmo
resultado porque só tínhamos
um número antes. O que dissemos? Zero aqui? Ele é arredondado para
o, o número inteiro. Então isso seria um 39. Mas aí está. Essas são algumas
maneiras diferentes de usar e algumas funções
agregadas diferentes que você pode usar
com suas consultas. Você pode contar, pode ser bom obter o máximo ou o mínimo, também o
número médio e também pode arredondar esse
número médio. Então, essas são algumas funções
úteis e
você pode usar para isso. Então foi isso por hoje. Se tiver alguma
dúvida, publique-a na seção
da comunidade e
faremos questão de ser úteis. Eles também estão à vontade para adicionar quaisquer alterações ao
seu projeto de classe e também fazer upload de dados. E se não, muito
obrigado a todos por assistirem e nos
vemos novamente aqui amanhã.
12. Dia 9 - Funções agregadas 2: Olá meus amigos
e bem vindos de volta. Hoje se chama nove, e
falaremos um
pouco mais sobre
funções agregadas hoje. Então, a primeira coisa sobre a qual
vamos falar é como usar o grupo BY. Então, digamos, por exemplo, que
quiséssemos obter a idade média, mas não para a tabela inteira. Mas queremos que ele obtenha
toda a idade por nacionalidade. Então, há uma maneira de
fazermos isso. Poderíamos selecionar nacionalidade porque essa é a primeira
coisa que queremos obter. E então dizemos média. E então diga a idade dos clientes. Em seguida, fazemos o grupo BY aqui embaixo
após a declaração de Fromm. Então, agrupe por nacionalidade. E é assim que faríamos isso. E também podemos fazer pedidos por
nacionalidade, se quisermos,
fazemos o Command Return. E vimos aqui que
obtemos todas as nacionalidades ordenadas
por nacionalidade. E então obtemos a idade média de cada uma
dessas nacionalidades. Então é assim que
usamos o grupo por declaração ou o
grupo por cláusula. Também poderíamos, se quiséssemos, também
poderíamos agrupar por
um campo calculado. Então, por exemplo, poderíamos fazer,
digamos, selecionar. Vamos ver por
volta dos dez anos. E então vamos contar
os nomes. Queremos receber a contagem
dos nomes dos clientes. Grupo, agrupado pela mesma
afirmação acima, certo? Idade. E então
também vamos fazer o pedido por volta dos dez anos, certo? Então, fazemos o Command Enter, recebemos um erro porque
eu perdi uma vírgula lá, então obtemos o campo de
idade redonda e também temos outra coluna com uma
contagem de todos os usuários. Portanto, essa seria uma maneira
útil de ver, por exemplo quantos usuários existem
em cada década. Então, quantos usuários estão na casa dos 20, 30
e 40 anos e assim por diante. Cbo também tem uma maneira de tornar
nossas vidas muito mais fáceis uma
forma que possamos realmente
referenciar no grupo
BY, pela coluna que estamos
declarando como um número. Então, podemos dizer, por exemplo, grupo por um, e isso fará referência a essa
primeira afirmação aqui. E então eu poderia fazer
a mesma referência aqui
embaixo do mesmo grupo, e eu obteria a mesma
referência aqui embaixo. Então, eu poderia fazer o Command Return e isso resultaria na
mesma consulta de antes. E, finalmente,
vamos voltar à nossa consulta anterior que tínhamos. Então, digamos que
quiséssemos agrupar ou contar os nomes dos
usuários em cada nacionalidade. Então, poderíamos contar o nome, nacionalidade e
depois agrupar por um. E se quiséssemos selecionar apenas as nacionalidades que tivessem uma contagem maior que um ou maior
e igual a um. Então, a coisa intuitiva a fazer seria algo
assim, certo? Faça uma cláusula onde
tenha um desconto um
pouco maior que um. Mas o fato é que,
com funções agregadas, não
podemos usar uma cláusula where. Precisamos usar uma declaração de
ter ou uma cláusula de ter. Dessa forma,
poderíamos dizer que
o nome da conta é
maior ou igual a dois, por exemplo, este eu faço o comando run. Podemos ver que
saímos das nacionalidades e todos os países
com mais de, com dois ou mais
usuários dentro deles, ou como uma contagem de dois ou
mais usuários dentro de. Então, em vez de usar
a palavra classe, usamos o having
sempre que estamos usando uma função agregada
para fazer essa comparação. Mas foi isso por hoje, pessoal,
vocês viram hoje como vocês poderiam
usar o grupo por cláusula. Como você pode referenciar por números, usando números
diferentes, você pode referenciar
as colunas para não precisar digitar
tudo. E você também aprendeu
a usar a cláusula de ter. Muito obrigado a todos por assistirem. Sinta-se à vontade para atualizar o projeto da turma com o
progresso que você fez. E nos vemos novamente
aqui na próxima lição.
13. Dia 10 - várias mesas - Inscrição interna: Sejam amigos no décimo dia. E hoje
vamos falar sobre várias tabelas e
junções de forma mais específica. Porque, para
armazenar dados com mais eficiência, podemos espalhar informações
relacionadas em diferentes tabelas. Em vez de ter uma tabela
incontrolável
com todos os dados, organizamos nossos registros
em várias tabelas. Então, como você pode ver aqui,
talvez tenhamos a tabela de usuários
neste exemplo. Isso tem várias tabelas. Portanto, isso seria um banco de dados
relacional com outras tabelas, por exemplo, essa tabela de classificações teria
uma referência a um ID de usuário. Em vez de ter todas as
informações em uma tabela, distribuímos as
informações em várias tabelas com
os dados espalhados, precisamos combinar os
IDs entre as tabelas. E fazer esse tipo de combinação
é chamado de unir tabelas. Então, quando combinamos esse ID, o ID do usuário com o
ID do usuário e uma classificação estável. Aqui estamos fazendo uma
correspondência e isso
é chamado de junção de tabelas em SQL. Então, voltando agora para
o navegador do banco de dados, vamos adicionar mais
duas tabelas. Então, vamos ver
nosso material de apoio. Aquele que usamos para adicionar os dados na coluna do
cliente. Vamos copiar essas informações
abaixo, certo, para elas. Vamos copiar a tabela de pedidos,
eliminar
os pedidos da tabela,
criar pedidos de tabela e inserir esses dados nos
pedidos. E então também vamos adicionar o mesmo para assinaturas. Então, vamos criar uma assinatura
de tabela,
inserir em suficiente. E aí também temos essa
informação. Então, vamos copiar isso, voltar ao nosso navegador de banco de dados. E eu vou falar
sobre isso muito rapidamente. Portanto, é uma tabela suspensa, se existir. Esse comando está dizendo ao SQL que elimine os pedidos da tabela
se, se existirem, no caso de existirem, então aqui embaixo estamos criando os pedidos da tabela com um ID, ID assinatura, ID de cliente, mês de início e mês de término. E observe que o ID é um número inteiro que é uma
chave primária que será unida. Em seguida, temos os dados
que vamos inserir nessa
tabela, em pedidos. Em seguida, temos assinaturas do Create
Table com um ID que também será um número inteiro. E a chave primária,
vamos ter uma descrição. E então vamos
inserir nas assinaturas
da tabela
três linhas de dados. Então, vou seguir em frente
e fazer o Command Return. E eu executei isso. Em seguida, posso me sentir à vontade para
excluir o código que escrevi. E eu poderia voltar a
procurar dados, certo? E aqui temos nossos clientes de
mesa, e essa lista suspensa nos
permite alterar a tabela. Portanto, se quisermos examinar
nossa tabela de pedidos, podemos ver que temos uma
coluna de identificação com a chave primária. Em seguida, temos um ID de assinatura, depois temos um ID de cliente
e, em seguida, temos um mês de
início e um mês de término. E esses meses seriam
os meses do ano. Portanto, esta, por exemplo ,
esta linha, a primeira linha, teria o mês inicial sendo janeiro e, em seguida, janeiro ,
fevereiro, março, abril,
o mês final sendo abril e aquele para o resto
do registros também. E, como você pode notar, esta coluna e esta coluna, então ID da assinatura
e ID do cliente, estão referenciando
IDs em outras tabelas. Então, por exemplo, se eu quisesse fazer o cliente
e ver o ID aqui e voltar aos pedidos. Quando vejo o
ID do cliente de um, por exemplo, eu sei que nesta
linha esse cliente seria o cliente um aqui. Então, Jane Doe. E nos pedidos, eu sei
que essa é Jane Doe que criou a desordem e
tem o mês de início sendo abril e depois junho com o mês final e tem o ID de
assinatura de dois. Então, se eu passar para as assinaturas de
mesa, sei que a ideia de duas, que é essa, é
uma assinatura Gold. Então, eu sei que Jane Doe
pediu Jane Doe, que tem um cliente pedido uma assinatura
Gold, que é a assinatura id2. E esses são os meses, então abril, até junho. E é assim que relacionamos as informações entre
as diferentes tabelas. Então, agora vamos para a
seção Executar SQL. Assim, podemos escrever consultas nas
quais podemos unir essas informações
diretamente usando SQL. Então, para fazer isso, o que fazemos é
selecionar, exatamente como antes. Vamos
selecionar tudo. Então, selecione tudo de, vamos selecionar
todos os pedidos. E vamos nos juntar a isso. Então juntamos as informações
entre as tabelas. Então, fazemos a cláusula de adesão
e vamos nos
juntar à tabela de
clientes, Clientes. E dizemos para especificar
se estamos aderindo. Então, vamos dizer pedidos, ID do
cliente. Então, esta é a notação,
à direita, a tabela, e então use um ponto e depois. IDs de clientes. Então, o campo que você está
referenciando nessa coluna. Então, solicita o ID do cliente e
, em seguida, o ID do cliente. E, na verdade, aqui, esse ID de cliente
na tabela é chamado simplesmente
reproduzindo o ID. Então, quando eu faço isso, eu posso ver aqui embaixo que eu
obtenho uma junção das duas tabelas. Então, eu tenho a
tabela completa de pedidos e depois tenho a união com os clientes
que mencionamos anteriormente. Então, por exemplo, para esta primeira ordem,
temos que ela é de fato
ou de segunda ordem. Na verdade, é Jane Doe desses meses e vemos que na verdade é
ela e
obtemos as informações em conjunto. Lembre-se de usar essa notação de
pontos para
garantir que a
referência não seja ambígua. Quando fazemos uma junção como essa, estamos fazendo o que é
chamado de junção interna. Portanto, é uma junção interna, o
que significa que os campos, todos os registros em um, na coluna da esquerda ou
na tabela da esquerda. Isso é o que é chamado
de mesa esquerda. No primeiro dia, o que você
mencionou precisa ser incluído ou deve estar presente
na tabela de clientes, na segunda tabela ou
na tabela à direita à
qual você está referenciando. Portanto, observe que a
tabela à esquerda
dos campos está presente
na tabela à direita. E todos os da
direita são referenciados ou estão presentes em todos os campos
da tabela à esquerda. Então, se olharmos para
este diagrama, por exemplo, podemos ver que isso
seria uma junção interna. E aqui ele especifica especificamente a união
interna, mas você pode simplesmente dizer união, e isso implica que
é uma união interna. E ele ocupará todos os
campos que estão nas duas tabelas desta forma. Mas voltando ao
nosso navegador de banco de dados, vamos ver como podemos
fazer juntas diferentes. Assim, podemos selecionar ou fazer
uma junção interna diferente. Podemos ver uma seleção. Vamos
selecionar entre os pedidos. Então eu posso dizer ordens. Quero ver o ID
do pedido. O ID do pedido. Então eu quero ver o
cliente, dos clientes. Quero ver o
nome do cliente. E então, a partir das assinaturas, quero ver a
descrição disso como uma assinatura. Então agora eu tenho de, de pedidos e preciso
juntar todas as mesas.
As pessoas participarão. Em primeiro lugar, os clientes. E eu tenho que especificar nos pedidos ID
do cliente igual
ao ID do cliente. Eu também posso participar. Eu posso fazer outro conjunto e posso dizer Pedidos, participar de assinaturas. Sob encomendas. ID de assinatura igual
ao ID de assinaturas. E agora, quando faço
o Command Return, vejo que tenho a
ideia do pedido. Então, o ID do pedido,
e eu recebo o nome porque é
aqui que eu
especifiquei aqui nas colunas
que eu queria ver. Eu recebo o nome e também a descrição da
assinatura que eles receberam. E esse é um exemplo
de como poderíamos unir as três tabelas. Então, pedidos, clientes e
assinaturas, tudo por ID. E aqui é onde você
especifica essas informações. Agora vamos fazer um lembrete
da opção de contagem
que temos antes, as funções agregadas de contagem. Então, queríamos contar, vamos ver se podemos
contar tudo da tabela de clientes. Então, vemos que temos 12
clientes quando executamos isso, vemos que temos 12 clientes. Se fizermos o mesmo com os pedidos, veremos que temos nove pedidos. Mas agora, digamos que quiséssemos
contar tudo, desde clientes,
a tabela de
clientes estáveis. E queremos participar,
unir pedidos de clientes. ID, igual ao ID do cliente do pedido. Agora vemos, ok, temos,
temos o mesmo número de
pedidos, então cada cliente, ou digamos que quando juntamos
os clientes com pedidos, vemos que temos nove
linhas no total. Então isso faz sentido porque, porque é uma união
interna, certo? E há outra coisa
que podemos fazer: criar aliases para as tabelas. Então, se adicionarmos alguns textos
após o nome da tabela. Portanto, se dissermos, por exemplo , aqui, consulte os clientes e,
após os pedidos, adicionarmos um OH
, podemos referenciar nossas
tabelas com esses aliases. Então, por exemplo, seriam clientes, 0 seriam pedidos. Em seguida, podemos executar isso
e veríamos que poderíamos obter os
mesmos resultados esperados porque estamos usando
aliases de tabela e isso é muito mais
fácil de ler e escrever. Portanto, é mais conveniente e isso também é algo que
podemos usar. Mas essa foi a lição de hoje. Muito obrigado a todos por assistirem. Lembre-se de que
as junções internas são o que vimos hoje. E a união interna
ocorre quando você duas tabelas e você pode
unir mais tabelas e obter somente os campos que são compartilhados entre as tabelas
que você está unindo. Então, obrigado novamente por assistir e nos vemos novamente
aqui na próxima lição.
14. Dia 11 - Múltiplas tabelas - Inscrição à esquerda: Olá amigos e
bem-vindos ao dia 11. Hoje, examinaremos várias tabelas e
junções esquerdas especificamente. Então, ontem vimos, falamos sobre as articulações internas, que são apenas os
campos que são os dois seios e, portanto, Brett, presente nas duas
mesas, estão unidos. Agora vamos
examinar esse tipo de junção, que é uma junção à esquerda, que é um tipo de junção que
fazemos sempre que queremos
manter todos os registros
da tabela esquerda, mesmo os que não estão compatível com a
mesa à direita. Então, vamos ver como podemos
fazer isso em sequência. Então, digamos que
queremos selecionar tudo. Então, selecione tudo da
nossa tabela de clientes. Vamos dar a
ele o pseudônimo de
C. Então, os clientes procuram uma mesa. E vamos fazer uma
junção à esquerda em uma tabela de pedidos. Vou dar a ele
um alias de 0. E vamos dizer que no
CID é igual ao ID do cliente do pedido. E vamos
fazer o Command Return. E vamos ver o que
recebemos na devolução. Vemos que temos praticamente toda a mesa do
cliente. Então, de 123456 até 12, todos os clientes. Então, à direita, temos a mesa à
qual juntamos. E observe como existem
alguns registros como este e todos
esses três, por exemplo, e depois Matt Diamond. Então, vemos que todos
esses campos têm a tabela certa com
todos os valores nulos. Isso basicamente significa que não
havia nenhum item ou registro presente na tabela
da direita que pudéssemos
juntar à tabela esquerda. Então, simplesmente obtemos
valores nulos e retornamos. Portanto, essa é uma ótima
maneira de ver, por exemplo se tínhamos a pergunta de ok, quantos clientes existem, quais clientes não fizeram nenhum pedido ou não fizeram nenhum
pedido. Então, aqui podemos dizer que,
na mesma consulta que
acabamos de escrever, podemos dizer podemos adicionar uma cláusula where e
dizer onde não está o ID do pedido. E então, quando
executamos isso, vemos que recebemos os mesmos quatro campos que
indicamos anteriormente, que são os quatro clientes que não fizeram nenhum pedido, não fizeram nenhum pedido. Então aí está. É assim que usamos junções à esquerda. E observe que
toda vez que fizemos uma junção, fizemos isso usando as chaves primárias
das diferentes tabelas. Então, neste exemplo, que estamos usando a chave
primária do cliente, que também é referenciada
na tabela Pedidos. E quando essa chave ou quando uma chave primária é referenciada
em uma tabela diferente, ela é chamada de
chave estrangeira na tabela de pedidos. Então, quando vamos para
a seção de proa, temos nossa tabela de pedidos. Vemos que a
ID do cliente está aqui, então podemos A chave primária
da tabela de clientes está
presente nessa tabela. Aqui, essa coluna é
chamada de chave estrangeira. E quando vamos até o
cliente, estabilizamos o id, é o que chamamos
de chave primária. Então, novamente, usamos chaves primárias para combinar as tabelas e
unir as tabelas. E, novamente, as regras para chaves
primárias são que
elas devem ser exclusivas. Uma tabela não pode ter mais de uma
coluna de chave primária e elas não podem ser nulas. E o que eu mencionei antes
foi que quando uma chave primária de uma tabela aparece
em uma tabela diferente, ela é chamada de chave estrangeira. E, novamente, isso é
importante porque os tipos
mais comuns
de
junções serão a união em uma chave estrangeira de uma tabela com a
chave primária de outra tabela. Então aí está.
Falamos sobre juntas de
energia em uma
lição anterior e hoje
falamos sobre junções à esquerda e
vimos como elas funcionam e
como elas se relacionam com
chaves primárias e chaves estrangeiras. Mas
muito obrigado a todos por assistirem e vemos novamente aqui
em nossa próxima aula.
15. Dia 12 - Múltiplas mesas - Faça parte do cruzamento: Olá amigos e
bem-vindos de volta ao dia 12. E hoje vamos
falar novamente sobre
várias tabelas e, mais
especificamente, sobre uma junção cruzada. Quando falamos sobre juntas cruzadas, estamos falando sobre
juntas que correspondem todas as linhas em todas as combinações
possíveis. Não requer uma declaração estranha, pois você
não está juntando nenhuma coluna. Então, por exemplo, se você quiser que ele
faça uma junção cruzada, digamos que selecione
todos os clientes. E então vamos dizer assinaturas de junção
cruzada. E, novamente, não
precisamos especificar instrução ou uma não classe
porque não estamos unindo
nenhuma coluna específica,
estamos simplesmente obtendo tudo, estamos simplesmente obtendo tudo, todas as
combinações possíveis retornadas. Então, quando eu executo isso,
vejo na execução abaixo que
vemos que temos
cada cliente com todas as combinações possíveis com a coluna de assinaturas. Então, temos Jane Doe três vezes porque temos Jane Doe com prêmio dourado
básico e depois Jack Johnson novamente com
ouro básico e premium e assim por diante. E então obteríamos um total de 36 colunas porque a 36ª linha, desculpe, porque
tínhamos de clientes no total e 12 vezes
três seriam 36. Então, estamos basicamente obtendo
todas as combinações de linhas entre
as duas tabelas. Portanto, isso será útil
em casos muito específicos. E, por exemplo, uma pergunta
que podemos responder é quantos meses ou
quantos clientes foram inscritos em cada
mês do ano. E para isso,
vamos analisar nosso material de apoio
e estabilizar nosso mês. Então, vamos fazer a tabela
de existências, criar uma tabela de mês
e, em seguida, simplesmente
inserir
os valores dos meses e simplesmente obter uma lista
dos números de 1 a 12. Então, quando copiarmos isso e colarmos
em nosso editor de SQL, vamos executá-lo. E quando acessamos os dados do
nosso navegador, vemos que temos um mês estável com todos os
meses do ano de 1 a 12. Então, voltando ao nosso editor de
execução, vamos executar uma consulta que veremos select, vamos dizer selecione a
cada mês no instável, e então vamos
contar todas as linhas, vamos dizer como usuários. E isso será de pedidos, dê a ele um alias de 0. E vamos
fazer a junção cruzada, e vamos fazer a
junção cruzada da tabela por meses. Então, agora estamos recebendo, estamos recebendo tudo dos
pedidos e vamos cruzar a junção com
a tabela, meses. E diremos
onde os pedidos começaram, mês é menor ou igual ao mês. No mês estável e o mês final é maior ou igual ao mês
dessa tabela. Então, aqui estamos falando
basicamente de filtrar todos os meses
que estão lá fora. Quando voltamos a esse intervalo de
datas nos pedidos, vemos que temos um mês de
início e fim. E estamos praticamente
filtrando aqueles que não estão dentro
desse intervalo de datas. E também vamos
mover isso por grupo por um. E quando fizermos o Command Enter, veremos que
temos todos os
meses do ano. Então, de um
até 12 aqui embaixo. Então, de um aqui
em cima até 12 aqui em cada
mês do ano. E então vemos quantos
usuários foram inscritos ou tinham uma assinatura ativa nessas
datas ou nesses meses. Então, no sexto mês, por exemplo, teríamos para usuários
com uma assinatura, assinatura
ativa ou inativa. Vemos que em abril
temos seis
assinaturas ativas e assim por diante. Então, esse é um exemplo
de como poderíamos usar uma junção cruzada. Precisamos comparar praticamente todas as linhas dos pedidos com
cada linha de meses. Outra coisa que
aprenderemos hoje é que, para empilhar um conjunto de dados sobre
o outro, usamos a cláusula de união aqui. Isso é o que ele faz é acrescentar
dados de dois conjuntos de dados. Então, por exemplo, se eu fiz uma seleção, digamos que um registro e, em seguida, uma união com outro registro
e execute o comando. Podemos ver que temos duas linhas, essas linhas acrescentadas
porque são ambas, ambas
têm o mesmo
número de colunas. Eles precisam ter
o mesmo número de colunas e o mesmo tipo de dados. Neste exemplo,
temos apenas uma coluna e cada declaração de seleção
e ambas são texto. Outro exemplo
poderia ser que, se
quiséssemos selecionar todos os clientes em que o ID é
menor ou igual a três, digamos, poderíamos
unir isso a um select. Novamente, todos os
clientes em que nosso ID é maior ou
igual a oito, por exemplo, e agora podemos executar
isso e ver que os dois resultados são empilhados
um em cima do outro. Então é assim que você pode
usar a declaração sindical. Então, novamente, hoje vimos como
poderíamos fazer junções cruzadas e vimos como poderíamos usar a declaração sindical e
pronto por hoje. Muito obrigado a todos
por assistirem e nos
vemos novamente aqui
em nossa próxima aula.
16. Dia 13 - Tabelas temporárias: Então, bem-vindos de volta, meus
amigos até o dia 13. E hoje vamos
falar sobre mesas temporárias. Podemos usar
tabelas temporárias que são criadas com uma cláusula de largura. E veremos como isso
funciona em um segundo. E, essencialmente, adicionamos
uma consulta inteira dentro dos parênteses,
damos a ela um nome e referenciamos os
resultados que obtemos. Então, vamos fazer um exemplo de consulta. Digamos que quiséssemos selecionar
a ID do cliente
e, digamos, a ID do cliente. E queremos obter a contagem,
contar o ID da assinatura
como o número de assinaturas. E vamos fazer a partir dos pedidos, da tabela de pedidos, e
vamos agrupar por um, o primeiro, o ID do cliente. Então, quando executamos isso, vemos que temos nossos IDs de clientes. Então, qual dos clientes? E vemos quantas assinaturas
cada uma delas tem. Vemos que
praticamente todo mundo tem uma assinatura, exceto
a ID do cliente, que tem duas assinaturas. Agora, digamos que
quiséssemos transformar isso em uma tabela temporária porque
será útil para a segunda
tabela, enquanto queremos fazer, porque queremos obter os nomes dos clientes a
partir dela execução. Então, poderíamos fazer
algo assim. Poderíamos fazer com esse nome temporário, qualquer nome que você queira
colocar na tabela temporária. E então você faz As. E entre os parênteses. Você pode colocar qualquer execução de
consulta que você
gostaria que alguém fizesse
aqui, a que acabei de fazer. E agora os resultados dessa execução
temporária ou
dessa consulta que eu coloquei
aqui
serão colocados nessa tabela de nomes
temporários. Agora posso referenciar esse nome temporário como se
fosse qualquer outra tabela. Então, agora eu poderia dizer, por exemplo , que é para selecionar o nome do cliente. E então eu posso dizer assinaturas
de nomes temporários
a partir do nome temporário. E então eu posso associar esse
cronograma aos clientes com nome temporário, ID de cliente
igual ao ID do cliente. Então, quando executo isso, recebo um erro porque eu tinha um ponto e vírgula e meu horário
, que não deveria estar lá. E quando executo isso novamente, percebo que cada nome, cada nome aqui agora é mostrado com o número de assinaturas ou a contagem de
assinaturas. Novamente, vamos revisar
o que acabamos de fazer. Então, temos nossa
tabela temporária aqui, que pode ser praticamente
qualquer execução aqui. Portanto, você não adicionaria um ponto e vírgula
no final dessa execução. E então você pode referenciar esse nome temporário ou
essa tabela temporária, qual você pode dar a ela
o nome que quiser. Você pode referenciá-la como uma tabela. E aqui podemos até
adicionar, digamos, aliases. Então, podemos fazer c e d, podemos referenciar
essa tabela da mesma forma, você pode tratá-la como outra,
simplesmente outra tabela. Então, podemos fazer aliases
aqui embaixo e poderíamos executar e ver que ele também seria
executado com sucesso. E também se você quiser
adicionar mais tabelas temporárias, você pode fazer essa notação. Então você tem uma
vírgula até o final
da primeira que
ele acabou de fazer. E então você pode
adicionar outro As
e, em seguida, especificar tudo entre parênteses
e dizer, por exemplo, selecionar. Eu não sei. Digamos que Tony e depois assinaturas,
sei lá, digamos cinco como
assinaturas como essa. E então, aqui embaixo, eu
poderia fazer uma união, selecionar tudo da segunda tabela. Outro que acabei de
criar assim. Quando executo isso, obtenho C. Ok, acabei a união de outra
tabela temporária que criei. Então você pode ver Tony aqui
embaixo no final. E o número de
assinaturas cinco, porque era isso que a tabela
temporária tinha dentro. Então, outro, esse
segundo cronograma. Portanto, você pode usar essa notação
para adicionar vários horários, mas tudo dentro ou o
uso dessa cláusula de largura. Mas aí está.
É assim que você pode usar tabelas
e sequências temporárias, e foi isso por hoje. Muito obrigado a todos por assistirem. Sinta-se à vontade para atualizar
seu projeto de classe com tudo o que você aprendeu até agora no progresso que fez. E te vejo de
volta aqui amanhã.
17. Dia 14 - Conclusão: Então, muito obrigado a todos por assistirem e parabéns
por terminarem esta aula. A maioria das pessoas não termina
as coisas que
começaram e você acabou de fazer. Então isso significa que
você é um outlier. Ao longo dessa aula,
você aprenderá a usar diferentes comandos SQL para extrair exatamente os dados
desejados do seu banco de dados. Começamos criando nosso próprio banco de dados local
com SQL light. Depois, aprendemos como
podemos gerenciar nossas tabelas. Em seguida, analisamos
diferentes consultas. Também podemos executar funções
agregadas, várias tabelas com junções
e, finalmente, tabelas temporárias. Se há uma coisa que espero que você aprenda nesta aula não é apenas como escrever uma sequência
para obter os dados que você deseja, mas também que a consistência é poderosa quando se trata de
aprender algo novo. Portanto, lembre-se sempre voltar quando estiver
aprendendo algo novo, mas sem mais nada a acrescentar. Muito obrigado a todos por assistirem. Se você gostou dessa aula, fique à vontade para deixar um
comentário, seguir meu canal e conferir meus outros
cursos que
me ajudam a criar um
conteúdo muito melhor para vocês. Além disso, não se esqueça de fazer
o upload da galeria de projetos da sua turma para que todos
possamos aprender uns com os
outros e dar feedback
uns aos outros. E, finalmente, fique à
vontade para conferir meu canal no YouTube por meio
do link em meu perfil. Mas, novamente, muito obrigado a todos por assistirem e
nos vemos por aí.