Database
 sql >> Base de Dados >  >> RDS >> Database

Tutorial de SQL para iniciantes


Neste tutorial SQL para iniciantes, você criará seu próprio banco de dados, inserirá dados nesse banco de dados e, em seguida, executará consultas nesse banco de dados.

Este tutorial SQL fará com que você execute consultas SQL rapidamente!

Exemplo de SQL


Aqui está um exemplo de instrução SQL:
SELECT * 
FROM Pets;

Este é um exemplo perfeito de como pode ser fácil escrever SQL. Esta simples instrução SQL realmente faz muito. Ele retorna a tabela inteira. Ele retorna todas as colunas e todas as linhas da tabela chamada Pets .

O asterisco (* ) é um caractere curinga, que significa “todas as colunas”. É uma maneira rápida e fácil de obter todas as colunas sem precisar digitá-las.

Essa é uma das coisas bonitas do SQL. As consultas SQL mais simples são geralmente as mais poderosas. Se quiséssemos retornar menos dados, precisaríamos escrever mais .

Por exemplo, se quisermos apenas animais de estimação chamados Buscar , adicionaríamos um WHERE cláusula que estipulava essa exigência.

Assim:
SELECT * 
FROM Pets
WHERE PetName = 'Fetch';

O WHERE cláusula filtra nossa consulta apenas para as linhas em que o PetName coluna tem um valor de Fetch .

Esta consulta assume que existe uma coluna chamada PetName e uma tabela chamada Pets no banco de dados.

Neste tutorial de SQL, mostrarei como criar esse banco de dados usando SQL.

Também mostrarei como inserir dados nesse banco de dados, atualizar dados, excluir dados e executar consultas nele.

O que é SQL?


SQL é um acrônimo para Linguagem de Consulta Estruturada.

SQL é a linguagem de consulta padrão usada para trabalhar com bancos de dados relacionais.

SQL é usado por todos os principais sistemas de gerenciamento de banco de dados relacional (RDBMSs), incluindo:
  • Microsoft Access
  • SQL Server
  • Oráculo
  • PostgreSQL
  • MySQL
  • SQLite

O que posso fazer com SQL?


Você pode usar o SQL para executar consultas em um banco de dados, inserir registros, atualizar registros e excluir registros. Você também pode criar novos objetos de banco de dados, como bancos de dados e tabelas. Você também pode executar tarefas de administração de banco de dados, como criar logins, trabalhos automatizados, backups de banco de dados e muito mais.

Mesmo quando você faz coisas usando uma Interface Gráfica de Usuário (GUI), seu Sistema de Gerenciamento de Banco de Dados (SGBD) quase certamente usará SQL nos bastidores para realizar essa tarefa.

Por exemplo, quando você cria um banco de dados clicando em Criar banco de dados e inserindo os detalhes do novo banco de dados em uma caixa de diálogo, depois de clicar em OK ou Criar ou o que quer que o botão leia, seu sistema de banco de dados usará o SQL CREATE DATABASE instrução para prosseguir e criar o banco de dados conforme especificado.

O mesmo vale para outras tarefas, como executar consultas, inserir dados, etc.

O SQL também permite que você execute ações mais avançadas, como criar procedimentos armazenados (scripts independentes), exibições (consultas pré-criadas) e definir permissões em objetos de banco de dados (como tabelas, procedimentos armazenados e exibições).

Dito isso, você não precisa aprender todas as coisas avançadas para começar a usar o SQL. O bom do SQL é que algumas das tarefas mais comuns são as mais fáceis de escrever.

Padrão SQL


O SQL foi padronizado em ANSI X3.135 em 1986 e, em poucos meses, foi adotado pela ISO como ISO 9075-1987. A norma internacional (agora ISO/IEC 9075) foi revisada periodicamente desde então e atualmente existe em 9 partes.

A maioria dos principais fornecedores de banco de dados tende a aderir ao padrão SQL. O bom disso é que você não precisa aprender uma nova linguagem de consulta toda vez que aprende um novo SGBD.

Na prática, porém, existem variações entre como cada fornecedor de banco de dados implementa o padrão SQL. Portanto, o código que você escreve em um DBMS pode nem sempre funcionar em outro sem a necessidade de modificações.

A boa notícia é que todos os principais SGBDs suportam as tarefas mais comuns geralmente da mesma maneira.

Pronúncia SQL


SQL é normalmente pronunciado de duas maneiras:
  • “ess-que-el ” (ou seja, soletrando cada letra)
  • “sequência ” (como na ortografia/pronúncia original).

Veja É Pronunciado S-Q-L ou Sequela se você está se perguntando por quê.

O que preciso para este tutorial de SQL?


Para realmente se beneficiar deste tutorial SQL, você deve seguir os exemplos. Isso significa que você precisará de um lugar para inserir as consultas SQL. Você precisará ter algo assim:

Se você for executar consultas SQL, precisará de:
  • Um RDBMS instalado (como SQL Server, MySQL, PostgreSQL, SQLite etc.).
  • Uma ferramenta de banco de dados que permite executar consultas SQL nesse RDBMS (como MySQL WorkBench, Azure Data Studio (foto), DBeaver e SSMS).

Se você já tem um de cada instalado, ótimo! Você pode continuar com o tutorial.

Se você não os tiver instalado, consulte O que preciso para executar o SQL? para obter instruções sobre como instalar um RDBMS e sua ferramenta de gerenciamento de banco de dados relevante, antes de retornar a este tutorial SQL.

Criar um banco de dados


Depois de instalar seu RDBMS e a ferramenta de banco de dados apropriada, você estará pronto para criar um banco de dados:
CREATE DATABASE PetHotel;

Feito!

Essa declaração realmente criou um banco de dados. Um banco de dados vazio, mas ainda assim um banco de dados.

Esse banco de dados conterá as tabelas e os dados usados ​​neste tutorial SQL. Quando criamos uma tabela ou inserimos dados, faremos isso dentro deste banco de dados.

Devo mencionar que o SQLite usa uma sintaxe diferente para criar bancos de dados. Se você estiver usando o SQLite, veja como criar um banco de dados no SQLite.

Conectar ao banco de dados


Antes de começar a criar tabelas, inserir dados e assim por diante, você precisa ter certeza de que está no banco de dados correto. Criar um banco de dados (como acabamos de fazer) não necessariamente conecta você a esse banco de dados.

Em muitos DBMSs (como SQL Server , MySQL e MariaDB ), podemos usar o seguinte para alternar para o banco de dados especificado:
USE PetHotel;

Isso torna o PetHotel o banco de dados atual.

Em SQLite , você provavelmente já está no banco de dados após criá-lo. Caso contrário, você pode anexar o banco de dados (que também o criará se ainda não existir):
ATTACH DATABASE 'PetHotel.db' AS Pets;

No PostgreSQL , se estiver usando a ferramenta psql, você pode usar o seguinte:
\connect PetHotel

Ou a versão reduzida:
\c PetHotel

Devo mencionar que o processo de criação e conexão com bancos de dados pode diferir amplamente entre os DBMSs.

Felizmente, a maioria das ferramentas GUI permitem que você se conecte a um banco de dados clicando duas vezes no banco de dados ou clicando com o botão direito do mouse no nome do banco de dados e selecionando uma nova guia de consulta no menu de contexto. Se você estiver preso nesta etapa, basta usar a GUI para criar e/ou conectar-se ao seu banco de dados.

Criar uma tabela


Agora que você se conectou ao banco de dados correto, você pode ir em frente e criar algumas tabelas.

Para criar uma tabela em SQL, use o CREATE TABLE demonstração.

Ao criar uma tabela, você precisa especificar quais colunas estarão na tabela, bem como seus tipos de dados. Você também pode especificar outros detalhes, mas não vamos nos precipitar.

Vamos criar uma tabela:
CREATE TABLE PetTypes
(
    PetTypeId   int NOT NULL PRIMARY KEY,
    PetType     varchar(60) NOT NULL
);

Neste caso, criamos uma tabela chamada PetTypes . Sabemos disso, porque o nome da tabela vem imediatamente após o CREATE TABLE pedaço.

Depois disso vem uma lista de colunas, entre parênteses.

A tabela acima contém as seguintes colunas:
  • PetIdId
  • PetType

Cada coluna é seguida por seu tipo de dados:
  • int significa que esta coluna aceita inteiros. Até onde eu sei, a maioria dos principais DBMSs suportam a declaração de colunas como int . Se você tiver algum problema, tente usar integer .
  • varchar(60) significa que esta coluna aceita strings de até 60 caracteres. varchar colunas são strings de comprimento variável. Outro tipo de dados de string é char (que é uma string de comprimento fixo). Se você tiver problemas ao tentar definir uma coluna como varchar(60) , tente usar char(60) .

NOT NULL Restrições


Neste exemplo, ambas as colunas são definidas com NOT NULL restrições. O NOT NULL restrição significa que esta coluna não pode estar vazia. Quando uma nova linha é inserida, qualquer NOT NULL colunas devem conter um valor. Outras colunas podem permanecer vazias se não houver dados para essas colunas.

Se NULL valores são permitidos na coluna, você pode omitir o NOT NULL parte, ou declará-lo como NULL (significando, NULL valores são permitidos nesta coluna).

Alguns DBMSs (como DB2) não suportam o NULL palavra-chave de qualquer maneira e, portanto, você precisará omiti-la ao trabalhar com esses DBMSs.

Chaves primárias


Também criamos o PetTypeId coluna a chave primária. A chave primária é uma ou mais colunas que identificam exclusivamente cada linha na tabela. Você especifica a(s) coluna(s) selecionada(s) como a chave primária usando uma restrição de chave primária. Você pode fazer isso no CREATE TABLE declaração (como fizemos aqui), ou você pode adicionar uma mais tarde com um ALTER TABLE demonstração.

As chaves primárias devem conter valores exclusivos. Ou seja, para cada linha dessa tabela, o valor na(s) coluna(s) da chave primária deve ser diferente em cada linha. Isso pode ser tão simples quanto ter números incrementais (como 1, 2, 3… etc) ou pode ser um código de produto (como pr4650, pr2784, pr5981… etc).

Além disso, as chaves primárias devem conter um valor. Não pode ser NULL .

Embora as chaves primárias não sejam obrigatórias, geralmente é considerado uma boa prática definir uma chave primária em cada tabela.

Criar mais tabelas


Vamos criar mais duas tabelas:
CREATE TABLE Owners
(
    OwnerId     int NOT NULL PRIMARY KEY,
    FirstName   varchar(60) NOT NULL,
    LastName    varchar(60) NOT NULL,
    Phone       varchar(20) NOT NULL,
    Email       varchar(254)
);

CREATE TABLE Pets
(
    PetId       int NOT NULL PRIMARY KEY,
    PetTypeId   int NOT NULL REFERENCES PetTypes (PetTypeId),
    OwnerId     int NOT NULL REFERENCES Owners (OwnerId),
    PetName     varchar(60) NOT NULL,
    DOB         date NULL
);

Ambas as tabelas são semelhantes à primeira, exceto pelo fato de terem mais linhas e algumas peças extras, que explicarei abaixo.

Se você estiver interessado, confira SQL CREATE TABLE for Beginners para mais alguns exemplos simples de criação de tabelas em SQL.

Relacionamentos


Quando criamos nossos Pets table, na verdade criamos um relacionamento entre as três tabelas.

Essa relação está representada no diagrama a seguir.

Os relacionamentos de banco de dados são uma parte crucial do SQL. Os relacionamentos nos permitem consultar várias tabelas para dados relacionados e obter resultados precisos e consistentes.

No nosso caso, queremos poder pesquisar animais de estimação por dono, ou animais de estimação por tipo de animal, etc. E queremos que nossos resultados sejam precisos e consistentes.

Para conseguir isso, precisamos insistir que todos os animais de estimação sejam inscritos junto com seu dono e tipo de animal de estimação. Portanto, precisamos garantir que, sempre que um novo animal de estimação for adicionado ao Pets tabela, já existe um proprietário correspondente em Owners table e um tipo de animal de estimação correspondente em PetTypes tabela.

Basicamente, nossos requisitos são os seguintes:
  • Qualquer valor no Pets.PetTypeId a coluna deve corresponder a um valor no PetTypes.PetTypeId coluna.
  • Qualquer valor no Pets.OwnerId a coluna deve corresponder a um valor no Owners.OwnerId coluna.

Podemos garantir os requisitos acima criando uma restrição de chave estrangeira nas colunas aplicáveis. Uma chave estrangeira A restrição é usada para especificar que uma determinada coluna faz referência à chave primária de outra tabela.

O código acima realmente criou duas restrições de chave estrangeira no Pets tabela.

Observe que o PetTypeId e OwnerId colunas têm algum código extra que começa com REFERENCES... . Essas são as partes que criaram as duas chaves estrangeiras.

Quando criamos os Pets tabela, seu PetTypeId coluna tem um bit que vai REFERENCES PetTypes (PetTypeId) . Isso significa que o Pets.PetTypeId coluna referencia o PetTypeId coluna em PetTypes tabela.

É o mesmo para o OwnerId coluna. Ele faz referência ao OwnerId coluna dos Owners tabela.

Na maioria dos SGBDs, chaves estrangeiras também podem ser criadas em uma tabela existente, usando o comando ALTER TABLE declaração, mas não vamos falar sobre isso aqui. Consulte Como criar um relacionamento no SQL para saber mais sobre isso.

De qualquer forma, nossas chaves estrangeiras foram criadas. Agora, sempre que alguém inserir um novo animal de estimação no Pets tabela, o PetTypeId e OwnerId valores precisarão ter um valor correspondente no PetTypes e Owners tabelas respectivamente. Se algum deles não o fizer, o banco de dados retornará um erro.

Este é o benefício das chaves estrangeiras. Isso ajuda a evitar que dados incorretos sejam inseridos. Ajuda a manter a integridade dos dados e, mais especificamente, a integridade referencial.

Verificar restrições


Uma restrição de verificação é outro tipo de restrição que você deve conhecer. Uma restrição de verificação verifica os dados antes de entrar no banco de dados. Quando uma tabela tem uma restrição de verificação habilitada, os dados só podem entrar na tabela se não violarem essa restrição. Os dados que violam a restrição não podem entrar na tabela.

Por exemplo, você pode criar uma restrição de verificação em um Price coluna para garantir que ela aceite apenas valores maiores que zero. Ou podemos aplicar uma restrição de verificação aos nossos Pets tabela para garantir que o DOB coluna não está no futuro.

Para obter um exemplo, consulte O que é uma restrição CHECK?

Espaço em branco


Você deve ter notado que meus exemplos incluem espaços em branco. Por exemplo, espalhei o código em várias linhas e usei guias para recuar os tipos de dados etc.

Isso é perfeitamente válido em SQL. Você pode fazer isso com segurança e isso não afetará o resultado. O SQL permite que você espalhe seu código em várias linhas, se desejar, e permite que você use vários espaços ou guias para melhorar a legibilidade.

Comentários


Você também pode incluir comentários em seu código. Os comentários podem ser úteis quando você começa a escrever scripts SQL mais longos. Quando um script fica bastante longo, os comentários podem facilitar a identificação rápida do que cada parte faz.

Comentários embutidos


Você pode criar comentários embutidos prefixando seu comentário com dois caracteres de hífen (-- ):
SELECT * FROM Pets; --This is a comment

-- This is a comment
SELECT * FROM Owners;

Neste exemplo, ambas as consultas serão executadas sem problemas. Os comentários serão ignorados pelo DBMS.

Comentários em várias linhas


Você pode espalhar comentários em várias linhas cercando o comentário com /* e */ :
/*
This is a longer comment so
it's spread across multiple lines
*/
SELECT * FROM Pets;

Neste exemplo, ambas as consultas serão executadas sem problemas. Os comentários serão ignorados pelo DBMS.

MySQL


Se você estiver usando MySQL, você também pode usar o sinal numérico/sinal de hash (# ) para comentários de linha única. 
# This is a comment
SELECT * FROM Pets;

Código de comentário


Outro benefício interessante dos comentários é que você pode comentar código. Por exemplo, se você tem um script SQL longo que faz muitas coisas, mas só quer executar uma ou duas partes dele, você pode comentar o resto do roteiro.

Aqui está um exemplo:
-- SELECT * FROM Pets;

SELECT * FROM Owners;

Neste caso, o primeiro SELECT foi comentada e, portanto, apenas o segundo SELECT instrução será executada.

Você também pode usar comentários de várias linhas para essa técnica.

Inserir dados


Agora que criamos três tabelas e criamos as chaves estrangeiras apropriadas, podemos prosseguir e adicionar dados.

A maneira mais comum de inserir dados no SQL é com o INSERT demonstração. Fica mais ou menos assim:
INSERT INTO MyTable( Column1, Column2, Column3, ... )
VALUES( Value1, Value2, Value3, ... );

Você simplesmente substitui MyTable com o nome da tabela na qual você está inserindo dados. Da mesma forma, você substitui Column1 , etc com os nomes das colunas e Value1 , etc com os valores que vão para essas colunas.

Por exemplo, poderíamos fazer isso:
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

Cada valor está na mesma ordem em que a coluna é especificada.

Observe que os nomes das colunas correspondem aos nomes que usamos quando criamos a tabela.

Você pode omitir os nomes das colunas se estiver inserindo dados em todas as colunas. Assim, poderíamos alterar o exemplo acima para ficar assim:
INSERT INTO Pets
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

Para este tutorial, adicionaremos mais algumas linhas, então adicionaremos mais INSERT INTO instruções – uma para cada linha que queremos inserir.

Então vamos em frente e preencher nossas tabelas. 
INSERT INTO Owners( OwnerId, FirstName, LastName, Phone, Email )
VALUES( 1, 'Homer', 'Connery', '(308) 555-0100', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone, Email)
VALUES( 2, 'Bart', 'Pitt', '(231) 465-3497', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 3, 'Nancy', 'Simpson', '(489) 591-0408' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 4, 'Boris', 'Trump', '(349) 611-8908' ); 

INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 1, 'Bird' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 2, 'Cat' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 3, 'Dog' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 4, 'Rabbit' );

INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-11-20' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 2, 3, 3, 'Fetch', '2019-08-16' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 3, 2, 2, 'Scratch', '2018-10-01' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 4, 3, 3, 'Wag', '2020-03-15' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 5, 1, 1, 'Tweet', '2020-11-28' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 6, 3, 4, 'Fluffy', '2020-09-17' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 7, 3, 2, 'Bark' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 8, 2, 4, 'Meow' );

Observe que preenchemos os Pets mesa por último. Há uma razão para isso.

Se tivéssemos tentado inserir dados no arquivo Pets table antes de preencher os outros dois, teríamos recebido um erro, devido à nossa restrição de chave estrangeira. E por um bom motivo. Afinal, estaríamos tentando inserir valores nas colunas de chave estrangeira que ainda não existiam nas colunas de chave primária das outras tabelas. Isso é um grande “não, não” quando se trata de chaves estrangeiras.

Então, preenchendo os Owners e PetTypes tabelas primeiro, garantimos que os valores apropriados já estivessem nas colunas de chave primária antes de preenchermos as colunas de chave estrangeira em Pets tabela.

Consulte SQL INSERT para iniciantes para obter mais exemplos de inserção de dados em tabelas.

Verifique nossos dados


Ufa! Finalmente, podemos começar a executar consultas em nosso banco de dados.

Vamos verificar os dados em todas as nossas tabelas. 
SELECT * FROM Pets;
SELECT * FROM PetTypes;
SELECT * FROM Owners;

Resultado:
+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)
+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)
+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
+-----------+-------------+------------+----------------+-------------------+
(4 rows affected)

Ótimo, parece que os dados foram inseridos com sucesso.

Selecione colunas específicas


Geralmente é considerado uma prática ruim selecionar todas as linhas e todas as colunas de uma tabela (como fizemos no exemplo anterior), a menos que você realmente precise. Isso pode afetar o desempenho do servidor de banco de dados, especialmente se houver muitas linhas na tabela.

Não é um problema quando você está usando pequenos conjuntos de dados como estamos aqui, ou se você está em um ambiente de desenvolvimento ou similar. Caso contrário, geralmente é melhor selecionar apenas as colunas necessárias.

Portanto, se quiséssemos os IDs, nomes e datas de nascimento de todos os animais de estimação, poderíamos fazer isso:
SELECT PetId, PetName, DOB 
FROM Pets;

Resultado:
+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 2       | Fetch     | 2019-08-16 |
| 3       | Scratch   | 2018-10-01 |
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 6       | Fluffy    | 2020-09-17 |
| 7       | Bark      | NULL       |
| 8       | Meow      | NULL       |
+---------+-----------+------------+

Se quiséssemos os IDs e a data de nascimento de todos os animais de estimação chamados Fluffy, poderíamos usar isso:
SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy';

Resultado:
+---------+------------+
| PetId   | DOB        |
|---------+------------|
| 1       | 2020-11-20 |
| 6       | 2020-09-17 |
+---------+------------+

Você também pode usar o SELECT instrução para retornar dados sem tabela. Ou seja, pode retornar dados que não estão armazenados em uma tabela. Veja SQL SELECT Declaração para Iniciantes para ver um exemplo.

Classificação


SQL fornece o ORDER BY cláusula que nos permite classificar dados.

Podemos adicionar um ORDER BY cláusula ao nosso exemplo anterior para que os animais de estimação sejam classificados por seus nomes:
SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName ASC;

Resultado:
+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 7       | Bark      | NULL       |
| 2       | Fetch     | 2019-08-16 |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 8       | Meow      | NULL       |
| 3       | Scratch   | 2018-10-01 |
| 5       | Tweet     | 2020-11-28 |
| 4       | Wag       | 2020-03-15 |
+---------+-----------+------------+

O ASC parte significa ascendente . Quando você usa o ORDER BY cláusula, o padrão é ascendente, então você pode omitir o ASC parte se desejar.

Para classificá-lo em decrescente ordem, use DESC . 
SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC;

Resultado:
+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

Você também pode classificar os resultados usando várias colunas. Ele classificará pela primeira coluna especificada e, se houver duplicatas nessa coluna, classificará essas duplicatas pela segunda coluna especificada e assim por diante. 
SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC, DOB ASC;

Resultado:
+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 6       | Fluffy    | 2020-09-17 |
| 1       | Fluffy    | 2020-11-20 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

Veja como os dois Fluffys trocaram de posição.

Se você não usar o ORDER BY cláusula, não há garantia de qual ordem seus resultados estarão. Embora possa parecer como seu banco de dados está classificando os resultados por uma coluna específica, isso pode não ser o caso. Em geral, sem um ORDER BY cláusula, os dados serão classificados na ordem em que foram carregados na tabela. No entanto, se as linhas tiverem sido excluídas ou atualizadas, o pedido será afetado pela forma como o DBMS reutiliza o espaço de armazenamento recuperado.

Portanto, não confie no DBMS para classificar os resultados em qualquer ordem significativa.

Conclusão:se você deseja que seus resultados sejam classificados, use ORDER BY .

Veja SQL ORDER BY Cláusula para Iniciantes para mais exemplos.

Conte as linhas em um conjunto de resultados


Você pode usar o COUNT() função agregada para contar as linhas que serão retornadas em uma consulta. 
SELECT COUNT(*) AS Count
FROM Pets;

Resultado:
+---------+
| Count   |
|---------|
| 8       |
+---------+

Isso nos diz que há 8 linhas na tabela. Sabemos disso porque selecionamos todas as linhas e todas as colunas.

Você pode usar COUNT() em qualquer consulta, por exemplo, consultas que usam um WHERE cláusula para filtrar os resultados.

Você também pode especificar uma coluna específica para contar. O COUNT() função conta apenas não-NULL resultados, portanto, se você especificar uma coluna que contém NULL valores, esses valores não serão contados.

Aqui está um exemplo para demonstrar o que quero dizer. 
SELECT COUNT(DOB) AS Count
FROM Pets;

Resultado:
+---------+
| Count   |
|---------|
| 6       |
+---------+
Warning: Null value is eliminated by an aggregate or other SET operation.

Você deve se lembrar que os Pets tabela contém dois NULL valores no DOB coluna (dois animais de estimação não forneceram a data de nascimento) e, portanto, COUNT(DOB) retorna 6, em vez de 8 quando usamos COUNT(*) . O motivo COUNT(*) retornou todas as linhas, é porque essas duas linhas fizeram tem dados nas outras colunas.

No meu exemplo, meu DBMS também retornou um aviso sobre isso. Você pode ou não receber um aviso, dependendo do seu DBMS e da sua configuração específica.

Consulte SQL COUNT para Iniciantes para mais exemplos.

Outras funções agregadas incluem:AVG() , SUM() , MIN() e MAX() .

Agrupar por


Outra cláusula útil é a GROUP BY cláusula. Isso faz muito bem o que seu nome promete. Permite agrupar os resultados por uma determinada coluna. 
SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
ORDER BY Count DESC;

Resultado:
+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
| 1           | 1       |
+-------------+---------+

Neste exemplo, estamos contando quantos animais de estimação temos para cada tipo de animal de estimação, classificando-os em ordem decrescente (com a contagem mais alta no topo).

Veja SQL GROUP BY Cláusula para Iniciantes para mais exemplos.

O HAVING Cláusula


Podemos usar o HAVING cláusula para filtrar os resultados no GROUP BY cláusula. O HAVING A cláusula retorna linhas em que os valores agregados atendem às condições especificadas.

Aqui está um exemplo. 
SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;

Resultado:
+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
+-------------+---------+

Nesse caso, retornamos dados apenas para os tipos de animais de estimação que possuem mais de 2 animais de estimação atribuídos a esse tipo.

Veja SQL HAVING Cláusula para Iniciantes para mais exemplos.

Participações


No SQL, uma junção é onde você executa uma consulta que combina dados de várias tabelas.

Os dois exemplos anteriores estão corretos, mas seriam melhores se retornassem os tipos reais de animais de estimação (por exemplo, Gato, Cachorro, Pássaro etc.) em vez do ID (por exemplo, 1, 2, 3, etc).

O único problema é que os Pets tabela não contém esses dados. Esses dados estão em PetTypes tabela.

Felizmente para nós, podemos fazer uma junção entre essas duas tabelas. Aqui está um exemplo que usa um LEFT JOIN :
SELECT 
    PetTypes.PetType,
    COUNT(Pets.PetTypeId) AS Count
FROM Pets 
LEFT JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType
ORDER BY Count DESC;

Resultado:
+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Dog       | 4       |
| Cat       | 3       |
| Bird      | 1       |
+-----------+---------+

Este conjunto de resultados é muito mais fácil de ler do que os anteriores. É mais fácil entender quantos de cada tipo de animal de estimação estão na tabela.

A sintaxe usa o tipo de junção (neste caso LEFT JOIN ), seguido pela primeira tabela (esquerda), seguida por ON , seguido pela condição de junção.

Vamos usar um INNER JOIN para retornar todos os nomes de animais de estimação com seus respectivos tipos de animais de estimação. 
SELECT 
    Pets.PetName,
    PetTypes.PetType
FROM Pets 
INNER JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId;

Resultado:
+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+

As junções realmente abrem nossas opções, porque agora podemos pegar dados de várias tabelas e apresentá-los como se fosse uma única tabela.

Você notará que nos exemplos de junção, qualificamos nossos nomes de colunas com os nomes das tabelas. O motivo pelo qual fazemos isso é para evitar qualquer ambiguidade em relação aos nomes das colunas das colunas entre as tabelas. Ambas as tabelas podem ter colunas com o mesmo nome (como em nosso exemplo) e, nesses casos, o DBMS não saberá a qual coluna você está se referindo. Prefixar os nomes das colunas com seus nomes de tabela garante que você esteja referenciando a coluna correta e evita erros que possam resultar de qualquer ambiguidade sobre a coluna à qual você está se referindo.

Veja meu Tutorial de junções SQL para mais exemplos e uma explicação dos vários tipos de junção.

Aliases


Podemos dar um passo adiante e atribuir um alias para cada nome de tabela e nome de coluna. 
SELECT 
    p.PetName AS Pet,
    pt.PetType AS "Pet Type"
FROM PetTypes pt
LEFT JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;

Resultado:
+---------+------------+
| Pet     | Pet Type   |
|---------+------------|
| Tweet   | Bird       |
| Fluffy  | Cat        |
| Scratch | Cat        |
| Meow    | Cat        |
| Fetch   | Dog        |
| Wag     | Dog        |
| Fluffy  | Dog        |
| Bark    | Dog        |
| NULL    | Rabbit     |
+---------+------------+

Isso resultou em novos cabeçalhos de coluna, além de o código ser mais conciso.

Um alias permite atribuir temporariamente outro nome a uma tabela ou coluna pela duração de um SELECT inquerir. Isso pode ser particularmente útil quando tabelas e/ou colunas têm nomes muito longos ou complexos.

Um alias é atribuído através do uso do AS palavra-chave, embora essa palavra-chave seja opcional, portanto, você pode omiti-la com segurança. Observe que o Oracle não suporta o AS palavra-chave em aliases de tabela (mas acontece em aliases de coluna).

No exemplo acima, incluí o AS palavra-chave ao atribuir os aliases de coluna, mas a omitiu ao atribuir os aliases de tabela.

Um nome de alias pode ser qualquer coisa, mas geralmente é mantido curto para fins de legibilidade.

No nosso caso, alteramos as duas tabelas para p e pt , e os nomes das colunas para Pet e Pet Type . Observe que cerquei Pet Type entre aspas duplas. Eu fiz isso, porque há um espaço no nome. Para aliases sem espaços, você não precisa fazer isso. No SQL Server, você também pode usar colchetes ([] ) em vez de aspas duplas (embora também suporte aspas duplas).

A prática de usar espaços em colunas e aliases geralmente é desencorajada, pois pode causar todos os tipos de problemas com alguns aplicativos clientes.

Observe que ainda precisamos usar os nomes completos das colunas ao referenciá-los na junção (após o ON palavra-chave).

Devo salientar que atribuir um alias não renomeia a coluna ou a tabela.

Consulte SQL Alias ​​explicado para obter mais exemplos.

Atualizando dados


Você pode usar o UPDATE instrução para atualizar dados em suas tabelas.

A sintaxe básica é bem simples:
UPDATE Owners
SET LastName = 'Stallone'
WHERE OwnerId = 3;

Nesse exemplo, atualizamos o LastName coluna para ter um novo valor de Stallone onde o OwnerId é 3 .

Para atualizar várias colunas, use uma vírgula para separar cada par de coluna/valor.

Mas faça o que fizer, não se esqueça do WHERE cláusula (a menos que você realmente pretenda atualizar todas as linhas da tabela com o mesmo valor).

Veja SQL UPDATE para Iniciantes para mais exemplos e uma explicação mais detalhada.

Exclusão de dados


Você pode usar o DELETE instrução para excluir dados de suas tabelas.

The basic syntax is even more simple than the UPDATE demonstração:
DELETE FROM Owners
WHERE OwnerId = 5;

Here, we’re deleting owner number 5 from the Owners tabela.

As with the UPDATE statement, don’t forget the WHERE clause (unless you intend to delete every row in the table ).

See SQL DELETE for Beginners for more examples and a detailed explanation.

Dropping Objects


While we’re on the subject of deleting things, when you delete a database object (such as a table, view, stored procedure, etc), it’s said that you “drop” that object. For example, if you no longer need a table, you “drop it”.

The syntax is extremely simple, and it goes like this:
DROP TABLE Customers;

Those three words completely obliterated a table called Customers . The table and all its data is now gone.

As you can imagine, this can be a very dangerous statement, and should be used with extreme caution.

The same syntax can be used for other object types, except you would replace table with the object type (for example DROP VIEW vPets drops a view called vPets ).

If you try to drop a table that is referenced by a foreign key, you’ll probably get an error. In this case, you’ll need to either drop the foreign key (using the ALTER TABLE statement) or the child table itself.

Operadores SQL


In SQL, an operator is a symbol specifying an action that is performed on one or more expressions.

Operators manipulate individual data items and return a result. Os itens de dados são chamados de operandos ou argumentos . In SQL, operators are represented by special characters or by keywords.

We’ve already seen some operators in action. Some of our previous example queries had a WHERE clause that included the Equals operator (= ). We also ran a query that used the Greater Than operator (> ). These are both comparison operators – they compare two expressions.

See 12 Commonly Used Operators in SQL for examples of operators that you’re likely to need when working with SQL.

You can also use this list of SQL Operators as a reference for the operators available in SQL.

SQL Views


In SQL, a view is a query that’s saved to the database as a database object (just like a table). The term can also be used to refer to the result set of a stored query. Views are often referred to as virtual tables .

To create a view, you write a query, then save it as a view. You do this using the CREATE VIEW sintaxe.

Here’s an example of creating a view:
CREATE VIEW vPetTypeCount AS
SELECT 
    PetTypes.PetType,
    COUNT(Pets.PetTypeId) AS Count
FROM Pets 
LEFT JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType;

Running that code creates the view and stores it as an object in the database.

We can now query the view, just like we’d query a table.

Resultado:
SELECT * FROM vPetTypeCount;
+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Bird      | 1       |
| Cat       | 3       |
| Dog       | 4       |
+-----------+---------+

So we get the same result as we would have got if we’d run the original query, but saving it in a view made it a lot easier to query.

This benefit would become greater, the more complex the query is.

Views and the ORDER BY Clause


One thing I should point out is that the original query had an ORDER BY clause, but I didn’t include that in the view. The SQL standard does not allow the ORDER BY clause in any view definition. Also, most RDBMSs will raise an error if you try to include an ORDER BY clause.

This isn’t a problem though, because you can sort the results when you query the view. Therefore, we can do something like this:
SELECT * FROM vPetTypeCount
ORDER BY Count DESC;

Resultado:
+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Dog       | 4       |
| Cat       | 3       |
| Bird      | 1       |
+-----------+---------+

Most RDBMSs also include a large set of system views that you can use to retrieve information about the system.

For more about views, see What is a View?

Stored Procedures


A stored procedure is a series of SQL statements compiled and saved to the database. Stored procedures are similar to views in some respects, but very different in other respects.

One of the benefits of stored procedures is that they allow you to store complex scripts on the server. Stored procedures often contain conditional programming such as IF... ELSE statements, for example. Stored procedures can also accept parameters.

Here’s an example of creating a simple stored procedure in SQL Server to get pet information from our database:
CREATE PROCEDURE uspGetPetById
    @PetId int
AS
    SET NOCOUNT ON;
    SELECT 
        p.PetName, 
        p.DOB, 
        pt.PetType,
        CONCAT(o.FirstName, ' ', o.LastName) AS OwnerName
    FROM Pets p 
    INNER JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId
    INNER JOIN Owners o 
    ON o.OwnerId = p.OwnerId
    WHERE p.PetId = @PetId;

This stored procedure accepts a parameter called @PetId . This means that when you call the procedure, you need to pass the ID of the pet that you’d like information about. The procedure then selects data from various tables and returns it.

To call the stored procedure, use the EXECUTE demonstração. You can alternatively shorten it to EXEC . In PostgreSQL, use the CALL demonstração. 
EXEC uspGetPetById @PetId = 3;

Resultado:
+-----------+------------+-----------+-------------+
| PetName   | DOB        | PetType   | OwnerName   |
|-----------+------------+-----------+-------------|
| Scratch   | 2018-10-01 | Cat       | Bart Pitt   |
+-----------+------------+-----------+-------------+

In this case I was interested in pet number 3, and so that’s the info that I got.

I should mention that the syntax for creating stored procedures can differ quite significantly between DBMSs (as well as their implementations of various SQL statements and commands that you’d use inside a procedure), so I would suggest that you look at the documentation for your particular DBMS if you want to create a stored procedure.

Most RDBMSs also include a large set of system stored procedures that you can use to perform various administration tasks, and to retrieve information about the system.

For a basic overview of stored procedures, including their benefits, see What is a Stored Procedure?

Also, if you’re interested, see How to Create a Stored Procedure in SQL Server to see another example of creating a stored procedure in SQL Server. That example includes some screenshots.

SQL Triggers


A trigger is a special type of stored procedure that automatically executes when an event occurs in the database server.

Most major RDBMSs support DML triggers, which execute when a user tries to modify data through a data manipulation language (DML) event. DML events are INSERT , UPDATE , or DELETE declarações.

Some DBMSs (such as SQL Server and PostgreSQL) allow triggers to be associated with both tables and views. Others only allow triggers to be associated with tables.

SQL Server also supports DDL triggers and logon triggers.

DDL triggers execute in response to DDL events, such as CREATE , ALTER , and DROP statements, and certain system stored procedures that perform DDL-like operations.

Logon triggers are fired in response to the LOGON event that’s raised when a user’s session is being established.

Here are some articles explaining how to do various things with triggers in SQL Server:
  • Create a DML Trigger in SQL Server
  • Create a “last modified” column
  • Automatically send an email when someone tries to delete a record
  • Update a column’s value whenever another column is updated
  • Update a column’s value whenever certain other columns are updated

SQL Transactions


SQL transactions are an important part of transactional databases, where data consistency is paramount.

A transaction manages a sequence of SQL statements that must be executed as a single unit of work. This is to ensure that the database never contains the results of partial operations.

When a transaction makes multiple changes to the database, either all the changes succeed when the transaction is committed, or all the changes are undone when the transaction is rolled back.

Transactions help maintain data integrity by ensuring that a sequence of SQL statements execute completely or not at all.

A classic example of a transaction is to move money from one bank account to another. You wouldn’t want money to be deducted from the first bank account, but not appear in the second bank account.

Therefore, you could use a transaction which goes along the lines of this:
START TRANSACTION
Debit account 1
Credit account 2
Record transaction in transaction journal
END TRANSACTION

You could write conditional logic inside that transaction that rolls back the transaction if anything goes wrong.

The end result is that, either the transaction is completed in its entirety, or it’s not completed at all. It’s never half-done.

See my SQL Transactions Tutorial for examples of SQL transactions.

SQL Functions


A function is a routine that can take parameters, perform calculations or other actions, and return a result.

Most DBMSs provide you with the ability to create your own functions, while also providing a range of inbuilt functions.

User-Defined Functions


A user-defined function (UDF) is a function that you create for a specific purpose, and save to the database. You would create such a function for tasks that aren’t catered for by an inbuilt function.

See Introduction to User-Defined Functions in SQL Server for an overview. Although that article is written for SQL Server, most of the general concepts also apply to other DBMSs.

Inbuilt Functions


Most DBMSs have a large range of inbuilt functions that you can use in your SQL queries. For example, there are functions that return the current date and time, functions that format dates and numbers, functions that convert data from one data type to another, and more.

The range of inbuilt functions can be pretty extensive, and depend on the DBMS in use, so I won’t go over them in this SQL tutorial. But I would encourage you to try to find out what inbuilt functions your DBMS supports.

To get you started, the following articles contain some of the most commonly used functions in SQL programming.

SQL Server

  • SQL Server String Functions
  • SQL Server Mathematical Functions
  • SQL Server Date &Time Functions

MySQL

  • MySQL String Functions
  • MySQL Mathematical Functions

PostgreSQL

  • PostgreSQL Date &Time Functions
  • PostgreSQL Math Functions

SQLite

  • SQLite Aggregate Functions
  • SQLite Date &Time Functions