PSI Linguagem de Definição de dados. Módulo 15

PSI Linguagem de Definição de dados Módulo 15

Objetivos de aprendizagem No final deste módulo os alunos devem ter adquirido conhecimentos, procedimentos e atitudes que lhe permitam: Criação, alteração e eliminação de tabelas e índices em SQL; Criação e eliminação de tabelas; Alteração de tabelas; Criação e eliminação de índices; Conceito de transação; Privilégios e controlo de acessos.

Conteúdos 1. Criação, alteração e eliminação de tabelas e índices em SQL 1.1. Criação de tabelas (comando CREATE TABLE) 1.2. Alteração de tabelas (comando ALTER TABLE) 1.3. Criação de índices (comando CREATE INDEX) 1.4. Eliminação de tabelas e índices (comandos DROP TABLE e DROP INDEX) 2. Atualização de dados 2.1. Inserção de linhas (comando INSERT INTO) 2.2. Alteração de valores nas linhas (comando UPDATE) 2.3. Eliminação de linhas (comando DELETE FROM) 3. Conceito de transação (comandos COMMIT e ROLLBACK) 4. Privilégios e controlo de acessos (comandos GRANT e REVOKE

CREATE TABLE O comando SQL CREATE TABLE permite criar uma tabela. Exemplo simples: CREATE TABLE exemplo ( id INT, nome VARCHAR(100) ); Esta tabela com o nome exemplo tem 2 campos: id e nome: id é um campo numérico; Nome é uma String.

TIPOS DE DADOS VER FOTOCÓPIA ENTREGUE NO MÓDULO 14

CREATE TABLE CONSTRAINT DEFAULT Nas tabelas no Mysql, cada coluna tem que conter um valor (incluindo o NULL). Podemos definir aquando a criação da tabela, que caso não seja inserido um valor para determinado campo, então irá ser atribuído um valor pré-definido. CREATE TABLE exemplo ( id INT, morada VARCHAR(50), Localidade VARCHAR(20) DEFAULT Lisboa );

ALTER TABLE CONSTRAINT DEFAULT Se a tabela já estiver criada, podemos definir posteriormente o DEFAULT para um determinado campo: ALTER TABLE Pessoa ALTER Cidade SET DEFAULT Lisboa Da mesma forma, podemos eliminar o DEFAULT: ALTER TABLE Pessoa ALTER Cidade DROP DEFAULT

CREATE TABLE CONSTRAINT AUTO_INCREMENT Utiliza-se o auto_increment numa chave primária para criar uma coluna que incrementa automaticamente um valor em cada nova inserção na tabela.

CREATE TABLE CONSTRAINT AUTO_INCREMENT CREATE TABLE animais ( id INT NOT NULL AUTO_INCREMENT, nome CHAR(30) NOT NULL, PRIMARY KEY (id) ); INSERT INTO animais (nome) VALUES ( cão'),( gato'),('pinguim'), ( baleia ); SELECT * FROM animais; +----+---------+ id name +----+---------+ 1 cão 2 gato 3 pinguim 4 baleia +----+---------+

CREATE TABLE CONSTRAINT UNIQUE Tem o objetivo de identificar univocamente cada registo da tabela, evitando assim que dois registos tenham valores iguais numa determinada coluna. A Chave Única fornece a garantia de exclusividade para uma coluna. Podemos aplicar a chave única a um conjunto de colunas.

CREATE TABLE CONSTRAINT UNIQUE Exemplo: CREATE TABLE Trabalhador( Id int NOT NULL, Apelido varchar(255) NOT NULL, Nome varchar(255), Morada varchar(255), Cidade varchar(255), BI varchar (13), UNIQUE(BI) ) Neste exemplo, queremos que não seja possível 2 trabalhadores terem o mesmo BI.

CREATE TABLE CONSTRAINT UNIQUE Exemplo: CREATE TABLE Trabalhador( Id int NOT NULL, Apelido varchar(255) NOT NULL, Nome varchar(255), Morada varchar(255), Cidade varchar(255), BI varchar (13), CONSTRAINT unqtrab UNIQUE(nome,apelido) ) Neste exemplo, queremos que não seja possível 2 trabalhadores terem o mesmo nome e apelido.

ALTER TABLE CONSTRAINT UNIQUE Podemos ainda acrescentar a restrição UNIQUE após a criação da tabela. Exemplos: ALTER TABLE Trabalhador ADD UNIQUE (BI) ALTER TABLE Trabalhador ADD CONSTRAINT unqtrab UNIQUE (nome, apelido) Para retirar uma restrição UNIQUE: ALTER TABLE Trabalhador DROP INDEX unqtrab; (O MySQL considera a restrinção UNIQUE como sendo um index)

CREATE TABLE CONSTRAINT PRIMARY KEY A chave primária de uma tabela identifica univocamente cada registo nessa tabela. A chave primária tem de conter valores únicos e não pode conter valores NULL. Cada tabela apenas pode conter uma chave primária, no entanto esta pode ser composta por vários campos.

CREATE TABLE CONSTRAINT PRIMARY KEY Exemplo: CREATE TABLE Trabalhador( Id int NOT NULL, Apelido varchar(255) NOT NULL, Nome varchar(255), Morada varchar(255), Cidade varchar(255), BI varchar (13), PRIMARY KEY (id) )

CREATE TABLE CONSTRAINT PRIMARY KEY Exemplo: Chave composta CREATE TABLE Requisicao( IdSocio int NOT NULL, IdLivro int NOT NULL, data date NOT NULL, CONSTRAINT pkreq PRIMARY KEY (IdSocio, IdLivro, data) )

CREATE TABLE CONSTRAINT PRIMARY KEY Exemplo: No exemplo acima iremos ter um erro pois a chave primária não poderá ter 2 campos duplicados.

CREATE TABLE CONSTRAINT PRIMARY KEY Exemplo: Aqui não iremos ter erro pois, como a chave primária é composta pelos campos nome e estado, a cidade é igual mas o estado não. Haveria problema sim, se ambos os valores cidade e estado fossem iguais em 2 registos!

ALTER TABLE CONSTRAINT PRIMARY KEY Para definir a chave primária após a criação da tabela: ALTER TABLE Trabalhador ADD PRIMARY KEY (Id) ALTER TABLE Requisicao ADD CONSTRAINT pkreq PRIMARY KEY (IdSocio, IdLivro, data)

CREATE TABLE CONSTRAINT FOREIGN KEY O papel da chave estrangeira é manter uma referência a um registo presente noutra tabela. A chave estrangeira de uma tabela está relacionada com a chave primária de outra tabela.

CREATE TABLE CONSTRAINT FOREIGN KEY Exemplo: Temos uma tabela livros e uma tabela autores. Um autor pode escrever vários livros e um livro pode ser escrito somente por um determinado autor. O relacionamento entre estas 2 tabelas vai ser feito com base num campo em comum id_autor. Todas as vezes que o valor do campo id_autor na tabela livros for igual ao valor do campo id_autor na tabela autores nós estaremos a criar uma relação autor-livro.

CREATE TABLE CONSTRAINT FOREIGN KEY CREATE TABLE autores( id_autor INT UNSIGNED NOT NULL auto_increment, nome varchar(45) NOT NULL, email varchar(45) NOT NULL, PRIMARY KEY(id_autor) ) CREATE TABLE livros( id_livro INT UNSIGNED NOT NULL AUTO_INCREMENT, titulo VARCHAR(45) NOT NULL, id_autor INT UNSIGNED NOT NULL, PRIMARY KEY(id_livro) )

CREATE TABLE CONSTRAINT FOREIGN KEY Supõe-se que excluímos um registo na tabela autores e, que o campo id_autor da tabela livros guardava uma referência para o autor excluído. Teremos uma violação da integridade referencial! A chave estrangeira é usada para evitar situações que possam destruir as ligações entre as tabelas. A chave estrangeira também evita que sejam inseridos dados inválidos na coluna da chave estrangeira (os dados têm de existir na tabela relacionada)

CREATE TABLE CONSTRAINT FOREIGN KEY CREATE TABLE livros( id_livro INT UNSIGNED NOT NULL AUTO_INCREMENT, titulo VARCHAR(45) NOT NULL, id_autor INT UNSIGNED NOT NULL, PRIMARY KEY(id_livro), FOREIGN KEY(id_autor) REFERENCES autores(id_autor) ON DELETE CASCADE ) Ou se se pretender dar um nome à restrição: CONSTRAINT fklivro FOREIGN KEY(id_autor) REFERENCES autores(id_autor) ON DELETE CASCADE

CREATE TABLE CONSTRAINT FOREIGN KEY FOREIGN KEY(id_autor) REFERENCES autores(id_autor) ON DELETE CASCADE ON DELETE CASCADE significa que, se se apagar ou alterar uma linha (registo) na tabela pai, irá automaticamente apagar ou alterar as linhas correspondentes na tabela filha, isto com base nos campos em que se estabelece o relacionamento.

CREATE TABLE CONSTRAINT FOREIGN KEY FOREIGN KEY(id_autor) REFERENCES autores(id_autor) ON DELETE SET NULL ON DELETE SET NULL significa que, se se apagar ou alterar uma linha (registo) na tabela pai, irá ser colocado automaticamente o valor NULL no campo chave estrangeira nas linhas correspondentes na tabela filha, atenção que a chave estrangeira na tabela filha não pode ser NOT NULL!

ALTER TABLE CONSTRAINT FOREIGN KEY Se se pretender adicionar a foreign key à posteriori: ALTER TABLE Livros ADD FOREIGN KEY (Id_autor) REFERENCES Autores(Id_autor) Para dar um nome à restrição e/ou definir a chave composta por vários campos: ALTER TABLE Livros ADD CONSTRAINT fklivro FOREIGN KEY (Id_autor) REFERENCES Autores(id_autor)

ALTER TABLE CONSTRAINT FOREIGN KEY Para eliminar a chave estrangeira: ALTER TABLE Livros DROP FOREIGN KEY fklivro Quando se cria uma chave estrangeira sem dar explicitamente um nome à restrição, internamente é criada uma designação. Para saber qual é a restrição, de forma a poder eliminar a chave estrangeira, usar o comando SHOW CREATE TABLE nomeatabela.

INSERT INTO A função INSERT INTO serve para inserir dados na tabela já existente. Exemplo: INSERT INTO Clientes (NomeClientes, NomeContacto, Endereço, Cidade, CodPostal, Pais) VALUES ('Carmo', Luis Santos', Av Liberdade n100', Lisboa', 1234-123', Portugal'); O que significa que se fizermos uma consulta à tabela Clientes iremos ter uma linha com os dados agora inseridos: NomeClientes NomeContacto Endereço Cidade CodPostal Pais Carmo Luis Santos Av Liberdade n100 Lisboa 1234-123 Portugal

UPDATE A sintaxe do UPDATE é bastante parecida à sintaxe do INSERT mas o comando UPDATE é usado para alterar informações na base de dados em vez de as inserir. UPDATE nome_da_tabela SET campo1 = valor1, campo2 = valor2, ; Exemplo: Considera a tabela clientes, que entre outros campos tem o campo nome. A seguinte instrução irá alterar todos os registos da tabela: UPDATE clientes SET nome = 'Rafael ;

UPDATE Exemplo: UPDATE clientes SET nome = 'Rafael', email = 'contato@rlsystem.com.br' WHERE id = 1; Nesta situação apenas irá alterar os registos que tenham o campo id=1. UPDATE Comando para atualizar os dados SET o que será alterado WHERE condição para especificar os registos a alterar

UPDATE Conclusões Podemos alterar um, vários ou todos os registos da tabela. É importante ter em mente que se não se usar a cláusula WHERE, o comando vai alterar todos os registos da tabela. Na cláusula WHERE, podemos usar várias combinações de condições (AND/OR) para definir os registos a serem alterados. Exemplo: Podemos alterar todos registos com a data inferior a hoje e (AND) que a hora seja maior que 10 horas. Podemos alterar um ou mais campos da tabela, para isto, basta depois do 'valor novo do campo', adicionar uma vírgula.

DELETE Delete é instrução em SQL, que remove um ou mais registos de uma tabela. Pode ser definido um subconjunto de registos para a exclusão usando uma condição, caso contrário, todos os registos serão removidos.

DELETE Exemplo: Considera a tabela CLIENTES com os seguintes registos: +----+----------+-----+-----------+----------+ ID NAME AGE ADDRESS SALARY +----+----------+-----+-----------+----------+ 1 Ramesh 32 Ahmedabad 2000.00 2 Khilan 25 Delhi 1500.00 3 kaushik 23 Kota 2000.00 DELETE FROM Clientes WHERE ID = 2; Irá apagar um cliente, cuja identificação é 2: +----+----------+-----+-----------+----------+ ID NAME AGE ADDRESS SALARY +----+----------+-----+-----------+----------+ 1 Ramesh 32 Ahmedabad 2000.00 3 kaushik 23 Kota 2000.00

INDEXES Os indices são usados para encontrar rapidamente linhas que tenham um valor especifico numa coluna. Sem a existência de um index, o MySQL começa pela 1.ª linha e vai ler a tabela completa à procura das linhas (registos) que pretende. Alguns indexes : PRIMARY KEY, UNIQUE, INDEX, e FULLTEXT

INDEXES Declaração que cria um indice, com base nos 10 primeiros caracteres do nome da coluna. CREATE INDEX part_of_name ON customer (name(10));

TRANSACTION Por defeito, MySQL é executado num modo em que ao se executar as declarações que modifiquem uma tabela, o MySQL armazena essa alteração diretamente no disco tornando-as permanente. (modo autocommit ativo) Declarações a usar: START TRANSACTION: começa uma nova transação; COMMIT: realiza a transação em curso, tornando as alterações permanentes; ROLLBACK: desfaz a transação atual, cancelando as suas alterações; SET autocommit: ativa ou desativa o modo de autocommit para a sessão em curso.

TRANSACTION Verificar autocommit Executar a seguinte consulta: select @@autocommit Se estiver a 1, significa que o autocommit está ativado. Alterar autocommit Set autocommit=0 Pode ser necessário reiniciar o serviço para ter efeito.

TRANSACTION Select * from clientes; START TRANSACTION; INSERT INTO clientes(nome,sobrenome) VALUES ('Teste,'Teste'); Select * from clientes; //vê-se a tabela com o novo elemento ROLLBACK; //volta trás, desfazendo as ações Select * from clientes; //vê-se a tabela

TRANSACTION Select * from clientes; START TRANSACTION; INSERT INTO clientes(nome,sobrenome) VALUES ('Teste,'Teste'); Select * from clientes; //vê-se a tabela com o novo elemento COMMIT; //Realiza as ações Select * from clientes; //vê-se a tabela

PRIVILEGIOS E CONTROLO DE ACESSOS 1.ª etapa: estabelecer uma ligação ao servidor Se se conseguir conectar ao servidor, mas se os nossos privilegios não forem o que se está à espera, podemos verificar qual a conta que o servidor está a usar para nos autenticar. Usar a seguinte função: mysql> SELECT CURRENT_USER(); Depois de estabelecer a conexão com o servidor entramos na 2.ª etapa de controlo de acessos. Para cada pedido que quiser realizar através esta conexão, o servidor vai verificar se temos ou não privilégios suficientes para o conseguir.

PRIVILEGIOS E CONTROLO DE ACESSOS Privilege System Grant Tables (sistema para conceder privilégios a tabelas) O MySQL inclui várias tabelas onde são guardadas informações acerca das contas dos utilizadores e dos privilégios que cada um tem. Para manipular o conteúdo destas tabelas, vamos fazê-lo indiretamente através das declarações de gestão de contas (permitem definir contas e controlar os privilegios disponíveis para cada uma): CREATE USER, GRANT, REVOKE

PRIVILEGIOS E CONTROLO DE ACESSOS Quando se modifica uma conta, deve-se verificar que as nossas alterações vão ter o efeito esperado. Para verificar os privilégios de uma conta usar a declaração SHOW GRANTS : SHOW GRANTS FOR 'bob'@'pc84.example.com'; SHOW GRANTS FOR username @ hostname ; Se quisermos saber os privilégios da nossa conta usar: NossoUserName'@'%'. Ou Current_user() @'%

PRIVILEGIOS E CONTROLO DE ACESSOS CREATE USER O hostname pode ser o nome do servidor ou um endereço IP O nome 'localhost' indica o servidor local com IP '127.0.0.1 Criar um user sem password: CREATE USER aluno'@ localhost Criar um user com password: CREATE USER aluno2'@'localhost' IDENTIFIED BY 'minhapw'; Atenção que temos de ter privilégio para poder criar contas!

PRIVILEGIOS E CONTROLO DE ACESSOS GRANT Atenção que temos de ter privilégio para poder definir privilégios nas contas! O administrador da BD usa 1.º o CREATE USER para criar uma conta e depois o GRANT para definir os seus privilégios e caracteristicas. Exemplo: CREATE USER 'jeffrey'@'localhost' IDENTIFIED BY 'mypass'; GRANT ALL ON db1.* TO 'jeffrey'@'localhost'; GRANT SELECT ON db2.invoice TO 'jeffrey'@'localhost'; Acede ao site indicado e verifica e testa mais alguns privilégios. https://dev.mysql.com/doc/refman/5.1/en/grant.html#grant-privileges