Alterando registros em SQL
outubro 25, 2007
Vou iniciar este post escrevendo sobre como alterar registros em tabelas utilizando SQL. A sintaxe é simples:
UPDATE
[NOME_TABELA]
SET
[NOME_CAMPO] = [EXPRESSÃO][…n]
WHERE
{
[CONDICAO_SQL]
}
Como podem ver, inicia-se com a palavra-chave UPDATE, em seguida insere o nome da tabela desejada para ser alterada, logo após a palavra chave SET e o nome do(s) campo(s) à ser(em) alterado(s) e uma possível condição, caso necessite atualizar registros específicos.
UPDATE
Livros
SET
Nome = ‘The Art of War’
WHERE
LivroID = 5
Pode-se utilizar a instrução UPDATE unindo informações de diversas tabelas, caso precise comparar um valor que a tabela que deseja alterar não possua.
UPDATE
Livros
SET
L.Nome = ‘The Art of War’
FROM
Livros L,
Autores A
WHERE
L.AutorID = A.AutorID
AND
A.Nascimento BETWEEN ‘1950-01-01 00:00:00.000’ AND ‘1970-01-01 23:59:59.999’
A instrução SQL acima irá alterar todos os registros do campo ‘Nome’ da tabela ‘Livros’ cujo o autor coincidir com o do livro e a data de nascimento (Nascimento) do autor estiver entre 1950 e 1970.
Também pode utilizar funções no campo que deseja alterar.
UPDATE
Livros
SET
Valor = CAST(RAND() * 150 AS MONEY)
WHERE
ID > 10
Acima será alterados todos os livros que o ‘ID’ (chave primária) for maior que 10. A função RAND retorna um número aleatório entre 0 e o número especificado (no nosso caso 100) e após isso é feito uma conversão para o tipo MONEY, que indica que é moeda.
Existe outra maneira de atualizar um registro de uma tabela unindo informações de uma outra tabela. Isto pode ser feito utilizando o operador JOIN, que serve para juntar informações de tabelas que possuem registros diferentes, porém que tenham campo(s) relacionados entre si.
UPDATE
Livros
SET
Livros.Publicacao = Autores.Nascimento
FROM
Livros
INNER JOIN
Autores ON
(Autores.AutorID = Livros.AutorID)
E por último, pode alterar diversos campos de uma só vez utilizando o UPDATE.
UPDATE
Livros
SET
Nome = ‘O Alquimista’,
Publicacao = ‘1988-01-01’,
AutorID = 75
WHERE
LivroID = 23
Está ai a atualização de 3 campos de uma só vez…
Como criar consultas SQL mais rápidas
setembro 29, 2007
Estou abordando este assunto aqui no blog, pelo fato de ser um assunto muito importante atualmente para organizações que possuem uma grande quantidade de dados e muitos acessos simultaneamente.
Uma consulta mal projetada pode acarretar em lentidão ao servidor ou até mesmo fazer com que o servidor permaneça fora do ar por um período, impossibilitando o usuário de utilizar algum serviço do sistema ou site, gerando prejuízo a organização.
Otimizar uma consulta SQL nem sempre é uma tarefa fácil e simples, precisa um pouco de conhecimento para desenvolver filtros que obtenham resultados que não custe ao servidor muitos recursos de hardware. Muitos dos exemplos que irei demonstrar foram resultados de pesquisas e testes executados no próprio Query Analyser do MS SQL Server 2000.
Uma forma de prejudicar bastante o desempenho ao acessar a base de dados, é a criação de TRIGGERS. Esta instrução é acionada sempre que uma determinada tabela sofre alguma alteração (INSERT, UPDATE, DELETE). Portanto, ao invés de criar uma ‘TRIGGER‘ prefira criar uma PROCEDURE que será acionada sempre que uma tarefa for feita.
Ao criar um simples filtro em uma tabela, pode-se encontrar alguns pontos que prejudicam a performance da consulta. A consulta abaixo demonstra um dos exemplos:
SELECT
*
FROM
Cliente
Ao fazer algum filtro em uma tabela, evite informar todos os campos de uma tabela em uma consulta, a menos que isso for realmente necessário. Muitas das vezes não será utilizado todos os campos. A consulta acima pode ser executada rapidamente se a tabela da base de dados contiver poucos registros, mas para adquirir uma melhor performance da consulta é recomendável filtrar apenas os campos que serão utilizados, o exemplo abaixo demonstra um cenário parecido:
SELECT
Nome,
CPF,
RG,
Endereco
FROM
Cliente
Outro ponto importante é a utilização da instrução COUNT, esta instrução informa a quantidade de registros retornados em uma consulta.
SELECT
COUNT(*)
FROM
Cliente
Porém não há a necessidade de utilização desta consulta, porque ao executá-la, será contado um registro de cada vez. Para isto existe as tabelas ‘sysobjects‘ e ‘sysindexes‘. Com estas duas tabelas é possível obter muitas informações de diversos todos objetos existentes na base de dados.
SELECT
sysobjects.name AS [Nome da Tabela],
sysindexes.rowcnt AS [Qtde. de Registros]
FROM
sysobjects
INNER JOIN
sysindexes ON
sysindexes.id = sysobjects.id
WHERE
sysobjects.name = ‘Cliente’
AND
sysindexes.indid = 1
A consulta acima informa a quantidade de registros existentes na tabela ‘Cliente’. Reparem que foi utilizado uma nova instrução, o INNER JOIN. Esta instrução serve para fazer a junção de duas ou mais tabelas, lembrando que isto significa que DEVE possuir algum registro na tabela secundária, ou seja na tabela que está recebendo o INNER JOIN, sendo assim, é necessário fazer a comparação de campos em comum que as duas possuem. Certifique-se que o nome da tabela escrito na cláusula WHERE está correto, caso contrário não será retornado nenhum registro. Esta consulta é outro exemplo que poderá trazer problemas de performance, porque ao utilizá-la, a consulta toda pode acessar qualquer uma das informações (campos) existentes nas tabelas. Uma outra forma de consultar a quantidade de registros de uma tabela é a seguinte:
SELECT
sysindexes.rowcnt AS [Qtde. de Registros]
FROM
sysindexes
WHERE
sysindexes.indid = 1
AND
EXISTS(
SELECT
sysobjects.id
FROM
sysobjects
WHERE
sysobjects.id = sysindexes.id
AND
sysobjects.name = ‘Cliente’
)
Ao fazer um filtro como o acima, pode-se obter resultados muito eficazes em relação ao desempenho. A instrução EXISTS é uma instrução extremamente rápida porque utiliza pouco recurso de hardware. É como se retornasse uma variável booleana.
Outra instrução que consome um maior processamento é a instrução IN, que é utilizada quando é necessário fazer o filtro de um vetor de dados. O exemplo abaixo informa os todos clientes que possuir algum telefone.
SELECT
Nome
FROM
Cliente
WHERE
ID IN(SELECT ClienteID FROM Telefone)
Outra maneira de informar estes registro seria utilizar (novamente) a instrução EXISTS ao invés da instrução IN.
SELECT
Cliente.Nome
FROM
Cliente
WHERE
EXISTS(
SELECT
Telefone.ClienteID
FROM
Telefone
WHERE
Telefone.ClienteID = Cliente.ID
)
São inúmeras as tarefas que se pode fazer para melhorar a performance de uma consulta. Estas são apenas algumas operações que devem ser feitas caso necessita de resultados mais rápidos em consultas SQL.
Vou ficando por aqui, deixe sua crítica, dúvidas ou sugestões referente ao artigo. Até a próxima.