Esse artigo tem como objetivo mostrar os passos básicos de como utilizar o RDBMS MariaDB. Estou escrevendo esse artigo utilizando uma máquina windows pois como o público alvo são iniciantes em bancos de dados, nem todo mundo usa Linux. Então o primeiro passo é fazer o Download do MariaDB Server: https://mariadb.com/downloads/ Selecione a versão para o seu Windows ou Linux, uma vez que ele está instalado tanto faz o sistema operacional. No Windows a instalação é muito fácil, basicamente apertar Next,Next, Finish. Finalizada a instalação, o instalador do MariaDB traz junto com ele uma ferramenta para acessar o banco chamada HeidiSQL. Então abra o HeidiSQL.
Agora clique em New e configure a conexão como eu mostro na figura abaixo:
Na tela acima, são exibidas informações como Nome da Conexão, endereço do banco de dados, usuário e senha. Lembre-se que a senha você definiu durante a instalação. Caso tenha conectado corretamente, você chegará nessa tela:
Nessa tela é exibida a conexão ativa com 4 bancos de dados já criados por padrão no MariaDB. * information_schema * mysql * performance_schema * test Note que aparece o banco MySQL, por que o MariaDB foi baseado no MySQL, então todos os comandos vistos aqui também servem no MySQL. Em uma das abadas na imagem é mostrada a opção Query, clique nela e o resto agora é só comandos. Os comandos SQL possuem basicamente 3 categorias, DDL ( Data Definition Language ), DML ( Data Manipulation Language ) e DQL ( Data Query Language ), nos exemplos a seguir vamos passar por todas essas categorias de comandos. Sendo a primeira DDL(CREATE, DROP, ALTER), pois com esse conjunto de comandos que podemos definir a estrutura do nosso banco de dados. Para criar um banco de dados chamado tutorial:
CREATE DATABASE tutorial; /* Affected rows: 1 Found rows: 0 Warnings: 0 Duration for 1 query: 0.000 sec. */
Na parte inferior do HeidiSQL são mostrados os resultados do comando, no caso eu estou colocando tudo junto aqui. Para rodar os comandos basta selecionar a linha que você quer executar e apertar CTRL+F9. Vamos entrar nesse banco de dados.
USE tutorial; /* Affected rows: 0 Found rows: 0 Warnings: 0 Duration for 1 query: 0.000 sec. */
Agora vamos criar uma tabela:
CREATE TABLE funcionarios(id INT PRIMARY KEY AUTO_INCREMENT, nome VARCHAR(50), email VARCHAR(50), salario DOUBLE); /* Affected rows: 0 Found rows: 0 Warnings: 0 Duration for 1 query: 0.015 sec. */
Pronto, criamos uma tabela chamada funcionarios, com 3 campos:
- id do INTEIRO
- nome do tipo caracteres
- email do tipo caracteres
- salario do tipo numero decimal
O campo ID de uma tabela em um banco de dados relacional é muito importante, pois ele é o que garante a unicidade de um registro dentro da tabela, por exemplo, poderíamos ter uma tabela de funcionários somente com os campos ID e NOME , os nomes podem se repetir, pois sabemos que eu não sou o único alisson no planeta terra, as informações podem ser utilizadas para gerar um crachá que da acesso ao prédio da empresa e o que diferencia um alisson de outro alisson é esse campo ID, óbvio que isso é uma explicação muito simplista, mas de forma lógica é assim que funciona. Existem várias discussões sobre o que pode ser a chave primária de uma tabela, mas de acordo com a minha experiência profissional de praticamente 10 anos de T.I, a chave primária sempre é um campo chamado ID do tipo Inteiro e esse campo é utilizado para se relacionar com outras tabelas. Já vi casos de gente querendo utilizar os campos CPF ou EMAIL como chave primária, pois eles não se repetem, mas nesses casos assim, é comum utilizar esses campos com o que chamados de chave natural, que ele não se repete, serve como critério de unicidade, mas ainda sim não é a chave primária, então mantemos o campo ID do tipo inteiro. Agora para ver se a tabela foi criada, utilize o comando:
MariaDB [tutorial]> show tables; +--------------------+ | Tables_in_tutorial | +--------------------+ | funcionarios | +--------------------+ 1 row in set (0.000 sec)
Agora vamos um comando da categoria DML(insert, update, delete): Insira 5 funcionários nessa tabela.
INSERT INTO funcionarios(nome,email,salario) VALUES("alisson","alisson@alisson.com.br",1000);
INSERT INTO funcionarios(nome,email,salario) VALUES("leonardo","leonardo@leonardo.com.br",2000);
INSERT INTO funcionarios(nome,email,salario) VALUES("jonathan","jonathan@jonathan.com.br",3000);
INSERT INTO funcionarios(nome,email,salario) VALUES("vitor","vitor@vitor.com.br",5000);
INSERT INTO funcionarios(nome,email,salario) VALUES("galdino","galdino@alisson.com.br",2500);
/* Affected rows: 5 Found rows: 0 Warnings: 0 Duration for 5 queries: 0.000 sec. */
Ao inserir um dado em uma tabela, dentro dos parenteses após o nome da tabela, colocamos as colunas que devemos inserir os valores e em values os valores de fato. Note que eu não especifiquei o campo ID, pois ele foi definido com o tipo auto_increment, ou seja, para cada registro ele vai somar mais um como será na sequência. Agora já temos dados nessa tabela e vamos usar um comando da categoria DQL(Select). Começando pelo mais famoso que é o select *;
MariaDB [tutorial]> select * from funcionarios; +----+----------+--------------------------+---------+ | id | nome | email | salario | +----+----------+--------------------------+---------+ | 1 | alisson | alisson@alisson.com.br | 1000 | | 2 | leonardo | leonardo@leonardo.com.br | 2000 | | 3 | jonathan | jonathan@jonathan.com.br | 3000 | | 4 | vitor | vitor@vitor.com.br | 5000 | | 5 | galdino | galdino@alisson.com.br | 2500 | +----+----------+--------------------------+---------+ 5 rows in set (0.000 sec)
Quando trabalhamos com SQL acredito que 90% dos comandos que executamos são do tipo DQL, ou seja a gente normalmente sempre faz N buscas diferentes para os mesmos dados. Então é aqui que eu vou dar mais exemplo: Caso eu queira filtrar todos funcionários com salário acima de 2 mil reais, posso executar a seguinte query.
MariaDB [tutorial]> select * from funcionarios where salario > 2000; +----+----------+--------------------------+---------+ | id | nome | email | salario | +----+----------+--------------------------+---------+ | 3 | jonathan | jonathan@jonathan.com.br | 3000 | | 4 | vitor | vitor@vitor.com.br | 5000 | | 5 | galdino | galdino@alisson.com.br | 2500 | +----+----------+--------------------------+---------+ 3 rows in set (0.001 sec)
Note que temos o resultado esperado, mas está desordenado, então assim fica mais difícil de saber se está realmente certo. Se a tabela tivesse 93 mil funcionários por exemplo, seria difícil saber se alguém lá no meio apareceu com um salário menor. Para ordenar os resultados podemos fazer assim:
MariaDB [tutorial]> select * from funcionarios where salario > 2000 order by salario asc; +----+----------+--------------------------+---------+ | id | nome | email | salario | +----+----------+--------------------------+---------+ | 5 | galdino | galdino@alisson.com.br | 2500 | | 3 | jonathan | jonathan@jonathan.com.br | 3000 | | 4 | vitor | vitor@vitor.com.br | 5000 | +----+----------+--------------------------+---------+ 3 rows in set (0.000 sec)
Como foi ordenado de forma crescente, do menor para o maior, agora temos certeza de que o menor valor é acima de 2 mil. Lembre que a query é para salários SOMENTE acima de 2 mil, por exemplo, 2001 já apareceria, se eu quiser incluir o 2 mil também, posso fazer assim.
MariaDB [tutorial]> select * from funcionarios where salario >= 2000 order by salario asc; +----+----------+--------------------------+---------+ | id | nome | email | salario | +----+----------+--------------------------+---------+ | 2 | leonardo | leonardo@leonardo.com.br | 2000 | | 5 | galdino | galdino@alisson.com.br | 2500 | | 3 | jonathan | jonathan@jonathan.com.br | 3000 | | 4 | vitor | vitor@vitor.com.br | 5000 | +----+----------+--------------------------+---------+ 4 rows in set (0.000 sec)
Caso eu queria saber o maior salário da empresa:
MariaDB [tutorial]> select * from funcionarios order by salario desc; +----+----------+--------------------------+---------+ | id | nome | email | salario | +----+----------+--------------------------+---------+ | 4 | vitor | vitor@vitor.com.br | 5000 | | 3 | jonathan | jonathan@jonathan.com.br | 3000 | | 5 | galdino | galdino@alisson.com.br | 2500 | | 2 | leonardo | leonardo@leonardo.com.br | 2000 | | 1 | alisson | alisson@alisson.com.br | 1000 | +----+----------+--------------------------+---------+ 5 rows in set (0.000 sec)
Posso limitar também o número de resultados, como por exemplo os TOP 3 salários da empresa.
MariaDB [tutorial]> select * from funcionarios order by salario desc limit 3; +----+----------+--------------------------+---------+ | id | nome | email | salario | +----+----------+--------------------------+---------+ | 4 | vitor | vitor@vitor.com.br | 5000 | | 3 | jonathan | jonathan@jonathan.com.br | 3000 | | 5 | galdino | galdino@alisson.com.br | 2500 | +----+----------+--------------------------+---------+ 3 rows in set (0.000 sec)
Agora vamos a outro exemplo, onde o Alisson trabalhou bastante esse mês e vamos dar um aumento para ele. Primeiro passo é achar o alisson dentro do banco de dados.
MariaDB [tutorial]> select * from funcionarios where nome = "alisson"; +----+---------+------------------------+---------+ | id | nome | email | salario | +----+---------+------------------------+---------+ | 1 | alisson | alisson@alisson.com.br | 1000 | +----+---------+------------------------+---------+ 1 row in set (0.000 sec)
Veja que ele está ganhando 1 mil reais, vamos dar um aumento de 30% pra ele, então ele vai começar a ganhar 1300 reais.
MariaDB [tutorial]> update funcionarios set salario=1300 where nome="alisson"; Query OK, 1 row affected (0.005 sec) Rows matched: 1 Changed: 1 Warnings: 0
Note que agora o salário foi aumentado:
MariaDB [tutorial]> select * from funcionarios where nome = "alisson"; +----+---------+------------------------+---------+ | id | nome | email | salario | +----+---------+------------------------+---------+ | 1 | alisson | alisson@alisson.com.br | 1300 | +----+---------+------------------------+---------+ 1 row in set (0.000 sec)
IMPORTANTE! Nunca utilize o comando UPDATE sem o WHERE no final, pois senão é justa causa haha. A clausa WHERE é o que especifica qual dos registros dentro do
banco de dados será alterado, sem ela, vamos alterar todos os registros da tabela, por exemplo:
MariaDB [tutorial]> update funcionarios set salario=1300; Query OK, 4 rows affected (0.005 sec) Rows matched: 5 Changed: 4 Warnings: 0
Note que 4 linhas foram afetadas.
MariaDB [tutorial]> select * from funcionarios; +----+----------+--------------------------+---------+ | id | nome | email | salario | +----+----------+--------------------------+---------+ | 1 | alisson | alisson@alisson.com.br | 1300 | | 2 | leonardo | leonardo@leonardo.com.br | 1300 | | 3 | jonathan | jonathan@jonathan.com.br | 1300 | | 4 | vitor | vitor@vitor.com.br | 1300 | | 5 | galdino | galdino@alisson.com.br | 1300 | +----+----------+--------------------------+---------+ 5 rows in set (0.000 sec)
Então lembre-se, a clausula WHERE não é obrigatória no UPDATE, mas sempre lembre de colocar. Bom, agora vamos supor que o galdino não faça mais parte da empresa, no mundo real nós dificilmente deletamos efetivamente uma linha do banco de dados em uma tabela importante como é no caso de funcionários, pois pode ser que no futuro precisemos desse dado. Mas para deletar um registro podemos utilizar o comando DELETE, que faz parte da categoria DML.
MariaDB [tutorial]> delete from funcionarios where nome="galdino"; Query OK, 1 row affected (0.001 sec) MariaDB [tutorial]> select * from funcionarios; +----+----------+--------------------------+---------+ | id | nome | email | salario | +----+----------+--------------------------+---------+ | 1 | alisson | alisson@alisson.com.br | 1300 | | 2 | leonardo | leonardo@leonardo.com.br | 1300 | | 3 | jonathan | jonathan@jonathan.com.br | 1300 | | 4 | vitor | vitor@vitor.com.br | 1300 | +----+----------+--------------------------+---------+ 4 rows in set (0.000 sec)
Beleza, o galdino foi deletado.
IMPORTANTE! DE NOVO! NUNCA USE UM DELETE SEM WHERE! Se não informarmos qual é o registro que queremos deletar, o comando irá deletar todos os registros da tabela; Por exemplo:
MariaDB [tutorial]> delete from funcionarios; Query OK, 4 rows affected (0.005 sec) MariaDB [tutorial]> select * from funcionarios; Empty set (0.000 sec)
Executei um delete sem where, deletei todos os dados da minha tabela. Como delete sem WHERE também é justa causa acabou meu post haha. Até mais =)