A Manipulação de Strings (cadeias de caracteres) é uma tarefa trivial em bancos de dados e programação em geral. Tarefas como contar caracteres de uma string, converter letras de maiúsculas para minúsculas e vice-versa, obter partes de uma palavra ou frase, limpar caracteres indesejados e diversas outras são realizadas de forma corriqueira para tratar os dados que são armazenados e consultados em bancos de dados.

Os SGBDs possuem, normalmente, diversas funções internas que permitem realizar essas tarefas, e o Microsoft SQL Server possui um bom conjunto de funções de manipulação de strings disponível.

Neste artigo, veremos algumas das funções para manipular caracteres mais comuns presentes no SQL Server, com suas sintaxes, aplicações e exemplos práticos de uso.

Funções de Manipulação de Strings no SQL Server

As funções que serão vistas nesse artigo são as seguintes:

• Função LEN
• Função LOWER
• Função UPPER
• Função LTRIM
• Função RTRIM
• Função TRIM
• Função LEFT
• Função RIGHT
• Função REPLACE
• Função SUBSTRING
• Função CONCAT

Função LEN

LEN(expressão)

SELECT NomeLivro, LEN(NomeLivro) 'Tamanho do Título'
FROM Livro;

SELECT NomeLivro, ISBN13, LEN(ISBN13) AS 'Tamanho do ISBN'
FROM Livro
WHERE LEN(ISBN13) <> 13;

SELECT Nome_Livro, LEN(Nome_Livro)  'Tamanho do Título'
FROM tbl_Livro
WHERE LEN(Nome_Livro) = (
    SELECT MIN(LEN(Nome_Livro))
    FROM tbl_Livro
);

SELECT NomeLivro
FROM Livro
ORDER BY LEN(NomeLivro) ASC;

SELECT NomeEditora, LEN(NomeEditora) AS Tamanho_Nome
FROM Editora
WHERE LEN(NomeEditora) = 10;

SELECT NomeAutor, SobrenomeAutor, LEN(NomeAutor) + LEN(SobrenomeAutor) AS 'Tamanho do Nome Completo'
FROM Autor
WHERE (LEN(NomeAutor) + LEN(SobrenomeAutor)) > 20;

Funções LOWER e UPPER

LOWER(expressão)
UPPER(expressão)

SELECT NomeLivro, LOWER(NomeLivro) AS 'Nome Minúsculo'
FROM Livro;

SELECT NomeLivro
FROM Livro
WHERE LOWER(NomeLivro) = 'a arte da eletrônica';

SELECT UPPER(NomeAssunto) AS Assunto
FROM Assunto;

INSERT INTO Autor (NomeAutor, SobrenomeAutor)
VALUES (UPPER('Fábio'), UPPER('dos Reis'));

SELECT NomeAutor, SobrenomeAutor,
    UPPER(NomeAutor) AS NomeMaiusculo,
    UPPER(SobrenomeAutor) AS SobrenomeMaiusculo
FROM Autor;

Funções LTRIM, RTRIM e TRIM

LTRIM(expressão)
RTRIM(expressão)
TRIM([caracteres FROM] expressão)

• expressão: string que será modificada.
• caracteres: Caracteres que se deseja remover. Se omitido, remove espaços em branco.

SELECT NomeLivro, LTRIM(NomeLivro) 'Nome Ajustado'
FROM Livro;

SELECT NomeEditora, RTRIM(NomeEditora) AS 'Nome da Editora Ajustado'
FROM Editora;

SELECT NomeLivro, TRIM(NomeLivro) AS NomeLivroAjustado
FROM Livro;

SELECT NomeLivro, TRIM('*' FROM NomeLivro) AS NomeLivroLimpo
FROM Livro;

UPDATE Editora
SET NomeEditora = TRIM(NomeEditora);

INSERT INTO Autor (NomeAutor, SobrenomeAutor)
VALUES (TRIM(' Fábio '), TRIM(' dos Reis '));

Funções LEFT e RIGHT

LEFT(string, número_de_caracteres)

• string: A string original da qual se deseja extrair os caracteres.
• número_de_caracteres: O número de caracteres a ser extraído, começando pela esquerda.

RIGHT(string, número_de_caracteres)

SELECT ISBN13,
    RIGHT(ISBN13, 4) AS 'Título e DV'
FROM Livro;

SELECT NomeAutor,
    LEFT(NomeAutor, 2) AS 'Iniciais Autor'
FROM Autor;

SELECT NomeLivro,
    LEFT(CAST(DataPub AS VARCHAR), 4) AS AnoPublicacao
FROM Livro;

Função REPLACE

REPLACE(string_original, substring_antiga, substring_nova)

• string_original: A string na qual a substituição será realizada.
• substring_antiga: O texto que será substituído.
• substring_nova: O novo texto que substituirá a substring antiga.

UPDATE Livro
SET NomeLivro = REPLACE(NomeLivro, '2010', '2020')
WHERE NomeLivro LIKE '%Server 2010%';
-- Teste:
SELECT * FROM Livro;

UPDATE Livro
SET ISBN13 = REPLACE(ISBN13, '-', '')
WHERE ISBN13 LIKE '%-%';

Função SUBSTRING

SUBSTRING(expressão, início, comprimento)

• expressão: A expressão de string ou a coluna da qual se deseja extrair uma parte.
• início: A posição inicial (1 baseada) da extração.
• comprimento: O número de caracteres a serem extraídos.

SELECT NomeLivro, SUBSTRING(NomeLivro, 1, 3) AS SiglaLivro
FROM Livro;

UPDATE Editora
SET NomeEditora = UPPER(NomeEditora);

SELECT * FROM Editora;

UPDATE Editora
SET NomeEditora = UPPER(LEFT(NomeEditora, 1)) + LOWER(SUBSTRING(NomeEditora, 2, LEN(NomeEditora)))
WHERE NomeEditora IS NOT NULL;

SELECT NomeLivro, DataPub, SUBSTRING(DataPub, 1, 4) AS AnoPublicacao
FROM Livro;

Função CONCAT

CONCAT(valor1, valor2, valor3, ...)

• valor1, valor2, …: Valores que serão concatenados. Podem ser colunas, literais ou expressões.

SELECT CONCAT('Fábio ', 'dos Reis') AS 'Nome Cliente';

SELECT CONCAT(NomeAutor, ' ', SobrenomeAutor) AS 'Nome Completo do Autor'
FROM Autor;

SELECT NomeLivro,
    ISBN13,
    CONCAT(NomeLivro, ' (ISBN: ', ISBN13, ')') AS LivroComISBN
FROM Livro;

SELECT NomeLivro,
    DataPub,
    CONCAT('O livro "', NomeLivro, '" foi publicado em ', DataPub) AS DescricaoPublicacao
FROM Livro;

Conclusão

O post Funções de Manipulação de Strings no SQL Server apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Procedimentos armazenados são uma forma de armazenar a lógica do banco de dados no lado do servidor e podem ser executados por vários clientes. Eles são uma ferramenta muito útil para administradores e programadores de banco de dados, pois permitem encapsular a lógica complexa em uma única unidade chamável, reduzindo o código duplicado, aumentando a segurança e melhorando o desempenho.

Um procedimento armazenado no PostgreSQL é um bloco nomeado de instruções PL/pgSQL que podem ser executadas com um único comando. A sintaxe para criar um procedimento armazenado no PostgreSQL é a seguinte:

CREATE [OR REPLACE PROCEDURE] nome_procedimento(arg1 tipo_dado1, arg2 tipo_dado2, ...)
RETURNS tipo_dado_retorno
LANGUAGE plpgsql
AS $$
DECLARE
-- declaração de variáveis locais, se houver
BEGIN
-- declarações PL/pgSQL
END;
$$;

Onde:

• nome_procedimento é o nome do procedimento armazenado
• arg1, arg2, etc. são os parâmetros do procedimento armazenado
• tipo_dado1, tipo_dado2, etc. são os tipos de dados dos parâmetros
• tipo_dado_retorno é o tipo de dados do valor de retorno

e a seção DECLARE é usada para declarar variáveis locais, se necessário. A lógica real do procedimento armazenado é escrita dentro de blocos BEGIN e END, usando instruções da linguagem PL/pgSQL.

A cláusula LANGUAGE especifica o idioma do procedimento armazenado, que é plpgsql neste caso.

O símbolo $$

O símbolo $$ usado na última linha de um procedimento PL/pgSQL é usado para definir o início e o fim do corpo do procedimento. É uma sintaxe especial usada para definir uma string literal que abrange várias linhas. Na prática, é possível usar qualquer string com essa finalidade, desde que não seja uma palavra reservada da linguagem.

Em um procedimento PL/pgSQL, o $$ é usado para envolver todo o corpo do procedimento, que inclui a declaração de variáveis, a definição de estruturas de controle e qualquer outra lógica que você queira implementar. O primeiro $$ marca o início do corpo do procedimento e o segundo $$ marca o fim do corpo do procedimento.

Outra opção é usar a estrutura “BEGIN ATOMIC” … “END” no lugar de “AS $$“.

O que é PL/pgSQL?

PL/pgSQL é uma linguagem procedural usada no PostgreSQL para escrever stored procedures, triggers e funções. É uma linguagem estruturada em blocos semelhante a outras linguagens procedurais, como PL/SQL no Oracle e T-SQL no Microsoft SQL Server. Essa linguagem fornece estruturas de controle, como instruções IF-THEN-ELSE, LOOP e EXIT, bem como a capacidade de declarar variáveis, realizar tratamento de exceções e usar cursores.

O PL/pgSQL oferece uma interface procedural de alto nível para o banco de dados que permite criar lógica de negócios complexa e automatizar as operações do banco de dados. Por exemplo, podemos usar PL/pgSQL para implementar regras de negócios, validar dados ou realizar cálculos complexos em dados armazenados no banco de dados.

Assim, podemos escrever lógica que pode ser facilmente testada e reutilizada, tornando-a uma maneira eficiente de gerenciar operações de banco de dados.

Trata-se de uma linguagem do lado do servidor, o que significa que o código é executado no servidor de banco de dados, e não no cliente. Isso o torna mais rápido e eficiente do que executar o script do lado do cliente, dentro de uma aplicação de usuário, além de fornecer melhor segurança para seus dados.

Outras opções de linguagens suportadas pelo Postgres incluem SQL padrão e linguagem C, além da possibilidade de trabalhar com extensões para outras linguagens como PL/Python, PL/Perl, etc.

A instrução LANGUAGE plpgsql é necessária ao criar procedimentos armazenados no PostgreSQL porque define a linguagem de programação que será usada para escrever o corpo do procedimento.

Como executar o procedimento armazenado

Podemos chamar um procedimento armazenado no PostgreSQL usando a seguinte sintaxe:

CALL nome_procedimento(arg1_valor, arg2_valor, ...);

Aqui, arg1_valor, arg2_valor, etc. são os valores dos parâmetros passados para o procedimento armazenado. O resultado do procedimento armazenado será retornado na forma de uma tabela.

Vejamos agora alguns exemplos de criação e execução de procedimentos armazenados em PostgreSQL.

Exemplo 01 – Inserir uma linha em uma tabela

Procedimento armazenado em PostgreSQL (somente SQL) que insere uma nova linha em uma tabela, composta por três colunas: nome, sobrenome e idade:

Criar a tabela de teste:

CREATE TABLE pessoas (
    nome varchar(20),
    sobrenome varchar(40),
    idade smallint
);

Vamos a um exemplo de procedimento armazenado em PL/pgSQL que insere uma nova linha em uma tabela com três colunas: nome, sobrenome e idade. O procedimento armazenado usa três parâmetros: p_nome, p_sobrenome e p_idade e insere esses valores na tabela.

CREATE OR REPLACE PROCEDURE cadastra_pessoa(p_nome varchar(20), p_sobrenome varchar(40), p_idade smallint)
  LANGUAGE plpgsql
AS $$
BEGIN
    INSERT INTO pessoas (nome, sobrenome, idade)
    VALUES (p_nome, p_sobrenome, p_idade);
END
$$

Teste

Para executar o procedimento armazenado, basta chamá-lo com os valores desejados como parâmetros, assim:

CALL cadastra_pessoa('Fábio'::varchar, 'dos Reis'::varchar, 48::smallint);

E verificar se a tabela foi atualizada com o novo registro:

SELECT * FROM pessoas;

Especificar tipos de dados na chamada do procedimento

Ao chamar um procedimento armazenado no PostgreSQL, a necessidade de especificar explicitamente os tipos de dados para os argumentos (por exemplo, ‘Fábio’::varchar) geralmente surge devido a questões de desambiguação e coerção de tipos.

Os principais motivos para especificar tipos de dados ao chamar um procedimento armazenado no PostgreSQL são os seguntes:

1. Desambiguação: Quando o PostgreSQL possui múltiplos procedimentos com o mesmo nome, mas com assinaturas diferentes (ou seja, com diferentes tipos de parâmetros ou números de parâmetros), ele precisa saber exatamente qual procedimento deve ser chamado. Especificar o tipo de dado ajuda o PostgreSQL a escolher a versão correta do procedimento.
2. Coerção de Tipos: O PostgreSQL é uma linguagem fortemente tipada, o que significa que cada valor tem um tipo de dado associado, e algumas operações requerem tipos específicos. Quando se passa um literal (como ‘Fábio‘), ele é inicialmente interpretado como um text, a menos que se indique explicitamente um tipo diferente, como o varchar.
3. Prevenção de Erros de Tipagem: Quando o tipo de dado esperado pelo procedimento não corresponde ao tipo inferido pelo PostgreSQL, o banco de dados pode não ser capaz de fazer a coerção automaticamente, resultando em erros. Especificar o tipo assegura que o valor será tratado corretamente.

Exemplo 02 – Inserir um novo produto na tabela

Vamos criar um procedimento armazenado que permita inserir um novo produto na tabela de produtos de nosso banco de dados.

CREATE OR REPLACE PROCEDURE inserir_produto (
    p_cod_produto INT,
    p_nome_produto VARCHAR(30),
    p_descricao TEXT,
    p_preco NUMERIC,
    p_qtde_estoque SMALLINT
)
language plpgsql
AS $$
BEGIN
    INSERT INTO Produtos(cod_produto, nome_produto, descricao, preco, qtde_estoque)
    VALUES (p_cod_produto, p_nome_produto, p_descricao, p_preco, p_qtde_estoque);
    RAISE NOTICE 'Produto % cadastrado com sucesso.', p_nome_produto;
END;
$$;

A instrução RAISE NOTICE emite uma mensagem para o console confirmando a inserção do registro.

Para executar o procedimento:

CALL inserir_produto(4,'Detergente'::varchar,'Detergente neutro 500 ml'::text, 2.35, 2::smallint);

E então podemos verificar se produto foi inserido corretamente realizando uma consulta simples ao banco de dados:

SELECT * FROM Produtos;

Exemplo 03 – Atualizar o preço de um produto.

Este procedimento atualiza o preço de um produto específico, identificado pelo seu código de produto:

CREATE OR REPLACE PROCEDURE atualizar_preco(
    p_cod_produto INT,
    p_novo_preco NUMERIC
)
LANGUAGE plpgsql
AS $$
BEGIN
    UPDATE Produtos
    SET preco = p_novo_preco
    WHERE cod_produto = p_cod_produto;
    RAISE NOTICE 'Preço do produto % atualizado para %', p_cod_produto, p_novo_preco;
END;
$$;

Para executar o procedimento:

CALL atualizar_preco(1, 3.80);

E então podemos verificar se produto teve seu preço corretamente atualizado realizando novamente uma consulta ao banco de dados:

SELECT * FROM Produtos;

Exemplo 04 – Procedimento para consultar produtos com estoque baixo

Este procedimento retorna todos os produtos com quantidade em estoque abaixo de um valor especificado na chamada da procedure.

CREATE OR REPLACE PROCEDURE consultar_estoque_baixo (
    p_limite_estoque INTEGER
)
LANGUAGE plpgsql
AS $$
DECLARE resultado RECORD;
BEGIN
    FOR resultado in
        SELECT cod_produto, nome_produto, qtde_estoque
        FROM Produtos
        WHERE qtde_estoque < p_limite_estoque
    LOOP
        RAISE NOTICE 'Produto: %, Estoque: % ', resultado.nome_produto, resultado.qtde_estoque;
    END LOOP;
END;
$$;

Para executar o procedimento:

CALL consultar_estoque_baixo(3);

Aqui, consultamos todos os produtos cujo estoque está abaixo de 3 unidades.

Devemos notar alguns detalhes interessantes sobre a consulta realizada pelo procedimento armazenado deste exemplo:

Destino dos dados

Quando se usa a instrução SELECT em um procedimento armazenado no PostgreSQL, o resultado deve ser direcionado para algum lugar, como uma variável, uma tabela temporária, ou ser retornado ao chamador da função ou procedimento.

Caso contrário, o PostgreSQL gera a mensagem “consulta não tem destino para os dados resultantes” (no inglês: “query has no destination for result data“).

Se for necessário apenas exibir os resultados no console em um procedimento armazenado, sem retorná-los em uma consulta, podemos usar um loop para iterar sobre os resultados e então exibi-los com RAISE NOTICE.

O tipo RECORD

O tipo RECORD é um tipo de dado genérico no PL/pgSQL que pode acomodar uma linha de dados com colunas de diferentes tipos. Ao contrário de outros tipos de variáveis, que têm um tipo de dado específico (como INTEGER, VARCHAR, etc.), o RECORD pode armazenar qualquer linha inteira de resultado, independentemente de quantas colunas ou de quais tipos de dados essas colunas têm.

A instrução DECLARE r RECORD; em PL/pgSQL é usada para declarar uma variável de tipo RECORD.

Quando usamos o RECORD dentro de um loop FOR IN que itera sobre os resultados de uma consulta, o RECORD é automaticamente “preenchido” com os valores das colunas para cada linha retornada. Isso permite acessar os valores dessas colunas dentro do corpo do loop.

Além disso, uma vez que a linha é armazenada no RECORD, podemos acessar as colunas individuais usando a notação r.coluna, onde r é o nome da variável RECORD e coluna é o nome da coluna que desejamos acessar.

Exemplo 05 – Inserir e atualizar valores no mesmo procedimento.

Exemplo: criar um procedimento armazenado que insira um novo produto na tabela de produtos, ao mesmo tempo em que aplica um desconto percentual especificado a todos os produtos logo após.

CREATE OR REPLACE PROCEDURE insere_atualiza (cod int, prod varchar(30), descr text, valor numeric, qtde smallint, desc_perc numeric)
LANGUAGE plpgsql
AS $$
BEGIN
    INSERT INTO produtos(cod_produto, nome_produto, descricao, preco, qtde_estoque)
    VALUES (cod, prod, descr, valor, qtde);
    UPDATE produtos SET preco = preco * (100 - desc_perc) / 100;
END;
$$;

Executar o procedimento:

CALL insere_atualiza(6,'Alvejante'::varchar(30),'Alvejante de roupas'::text, 12.30, 12::smallint, 10);

Obs.: O tipo numeric geralmente não precisa ser informado (cast) na chamada do procedimento.

Como excluir um procedimento armazenado

Para excluir um procedimento armazenado no PostgreSQL devemos usar a declaração DROP PROCEDURE, como segue:

DROP PROCEDURE nome_procedimento;

Por exemplo, para excluir o procedimento consultar_estoque_baixo:

DROP PROCEDURE consultar_estoque_baixo;

Se houver mais de um procedimento armazenado como mesmo nome, mas com quantidade e tipos de parâmetros distintos (polimorfismo), devemos indicar os tipos de dados dos argumentos ao exclui-lo:

DROP PROCEDURE insere_atualiza(int,varchar,text,numeric,smallint,numeric);

Conclusão

Neste artigo vimos como começar a trabalhar com procedimentos armazenados no PostgreSQL. com alguns exemplos simples de criação de procedures simples. O recurso é muito útil para simplificar código e facilitar a programação de tarefas no banco de dados, principalmente quando as declarações SQL precisam ser executadas a partir de uma aplicação escrita em alguma linguagem de programação para acesso direto dos usuários.

Estudaremos recursos mais avançados de procedimentos armazenados nos próximos artigos, assim como outras formas de programação existentes para bancos de dados PostgreSQL, como Funções e Triggers.

Para saber mais sobre Procedimentos Armazenados no PostgreSQL, assista ao vídeo a seguir da Bóson Treinamentos no YouTube:

O post Procedimentos Armazenados em PostgreSQL (Stored Procedures) apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

A cláusula DELETE FROM em SQL é usada para remover registros de uma tabela. Esta cláusula permite apagar uma ou mais linhas de uma tabela com base em uma condição especificada na cláusula WHERE. Se a cláusula WHERE não for usada, todos os registros da tabela serão removidos (cuidado!!!).

Sintaxe Básica

DELETE FROM nome_da_tabela
WHERE condição;

Exemplos

1. Apagar registros específicos

Se quisermos remover todos os livros da tabela Livro cujo preço é maior que R$ 100,00:

DELETE FROM Livro
WHERE PrecoLivro > 100.00;

2. Apagar todas as linhas de uma tabela

Podemos remover todos os registros da tabela Autor, deixando a tabela vazia:

DELETE FROM Autor;

Observações importantes

Integridade Referencial: Ao excluir registros que são referenciados por chaves estrangeiras em outras tabelas, é importante considerar as restrições de integridade referencial para evitar a violação dessas restrições.
Backups: Antes de executar operações de exclusão em massa, é altamente recomendável fazer backup dos dados, pois a operação de DELETE é irreversível (não tem Ctrl+Z!!!).
Performance: Para limpar totalmente tabelas grandes, operações de DELETE podem ser lentas e consumir muitos recursos. Em alguns casos, pode ser mais eficiente truncar a tabela (usando TRUNCATE TABLE) ou recriá-la.

Para saber mais sobre SQL DELETE, assista a um vídeo da Bóson Treinamentos no YouTube:

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Como apagar linhas de uma tabela com DELETE FROM – SQL Server apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial mostro como importar um arquivo no formato CSV para uma tabela de um banco de dados SQL Server, de modo a realizar a inserção de múltiplos registros de uma só vez, por meio de uma operação INSERT INTO.

Para tal vamos usar dois arquivos: o arquivo CSV propriamente dito, contendo os dados a serem inseridos na tabela, e um arquivo especificador de formatos para ajustar os dados do arquivo CSV com as colunas específicas da tabela, além é claro do código SQL que executará a tarefa de inserção dos registros em bulk (vários de uma vez).

O que é um arquivo CSV?

Um arquivo CSV (Comma-Separated Values / Valores Separados por Vírgulas) é um tipo de arquivo de texto simples que armazena dados tabulares de forma estruturada, empregado com frequência para importar e exportar dados entre diferentes programas, sistemas e plataformas.

Neste tipo de arquivo, cada linha representa uma entrada de dados (um registro) e cada campo (coluna) é separado por um caractere delimitador, geralmente uma vírgula (“,”), ponto e vírgula (“;”) ou tabulação (“tab”). O mais comum é usar a vírgula, daí o nome do formato.

Cada linha no arquivo representa um registro e os campos podem conter texto, números, datas ou outros tipos de dados quaisquer. Usamos arquivos csv em aplicativos de planilhas, bancos de dados, programas para análise de dados e diversas outras aplicações, pois são bastante simples e fáceis de manipular.

Vamos usar neste tutorial um arquivo CSV de nome Livros.csv, que conterá dados a serem inseridos em uma tabela de nome Livro, e com ele vamos cadastrar vários registros de forma rápida e simples.

Arquivo CSV de exemplo: Livros.csv

A seguir temos o conteúdo do arquivo a ser usado no exemplo de inserção de linhas na tabela. Neste arquivo, a primeira linha é uma linha de cabeçalho, contendo os nomes das colunas da tabela que receberá os dados (tabela de nome Livro), separados por vírgulas. Você deve alterar o conteúdo desse arquivo de acordo com a tabela do banco que está usando, seguindo as instruções na sequência.

As linhas subsequentes contém os dados em si, sendo que cada linha do arquivo corresponde a uma linha a ser inserida na tabela (um registro), também separadas por vírgulas, seguindo a mesma ordem das colunas descritas no cabeçalho:

NomeLivro,ISBN13,DataPub,PreçoLivro,NumeroPaginas,IdEditora,IdAssunto
2001 - Um Odisséia no Espaço,9788576571551,20200930,55.86,336,3,1
Fahrenheit 451,9788525052247,20120601,43.56,216,3,1
Admirável mundo novo,9788525056009,20140101,50.32,312,3,1
1984,9788535914849,20090721,29.67,416,14,1
A volta ao mundo em 80 dias,9788537816134,18730101,59.41,256,11,5
O Nome da Rosa,9788501115829,20191216,51.99,592,18,5
Memórias Póstumas de Brás Cubas,9788525433131,18810101,34.90,240,14,6
O Evangelho Segundo Jesus Cristo,9788535905595,19910101,49.90,512,14,6
Cidades Invisíveis,9788535907445,19720101,42.80,176,14,6
Windows Server 2016: Installing & Configuring,9781535074094,20160712,432.00,436,4,11
Ensaio Sobre a Cegueira,9788571645118,19950101,39.90,312,14,6
Ulisses,9780141184432,19220202,78.90,450,16,6
Practical Electronics for Inventors,9781259587542,20160711,212.58,1056,9,3
Eu Robô,9788576571667,19501202,35.00,300,3,1
Dom Casmurro,9788525404186,19000101,19.90,256,14,6

Insira esse conteúdo em um arquivo de texto simples vazio, como um arquivo do bloco de notas no Windows, e salve com o nome de Livros.csv. Caso queira, acrescente mais livros à listagem. Não é necessário usar aspas para delimitar os dados do tipo VARCHAR ou DATE.

Obs.: Tome cuidado ao salvar o arquivo para não salvá-lo com a extensão .txt!!! Para evitar esse problema, selecione “Todos os arquivos” em “Tipo” na caixa de diálogo Salvar, e certifique-se de usar a codificação UTF-8, como segue:

A seguir criaremos o arquivo de formato XML a ser usado com esse csv.

Arquivo de Formato XML

Um arquivo de formato é um arquivo do tipo XML (eXtensible Markup Language) que descreve a estrutura dos dados contidos no arquivo CSV, especificando como os campos são delimitados, o comprimento máximo de cada campo e como esses campos são mapeados para as colunas da tabela do banco de dados durante o processo de importação de dados em massa..

O arquivo que usaremos possui o nome formato.xml. Crie-o com um editor de textos, usando o conteúdo a seguir, e salve-o no mesmo diretório do arquivo Livros.CSV:

<?xml version="1.0" encoding="UTF-8"?>
<BCPFORMAT xmlns="http://schemas.microsoft.com/sqlserver/2004/bulkload/format" 
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <RECORD>
    <FIELD ID="1" xsi:type="CharTerm" TERMINATOR="," MAX_LENGTH="100"/>
    <FIELD ID="2" xsi:type="CharTerm" TERMINATOR="," MAX_LENGTH="13"/>
    <FIELD ID="3" xsi:type="CharTerm" TERMINATOR="," MAX_LENGTH="8"/>
    <FIELD ID="4" xsi:type="CharTerm" TERMINATOR="," MAX_LENGTH="19"/>
    <FIELD ID="5" xsi:type="CharTerm" TERMINATOR="," MAX_LENGTH="10"/>
    <FIELD ID="6" xsi:type="CharTerm" TERMINATOR="," MAX_LENGTH="5"/>
    <FIELD ID="7" xsi:type="CharTerm" TERMINATOR="\r\n" MAX_LENGTH="5"/>
  </RECORD>
  <ROW>
    <COLUMN SOURCE="1" NAME="NomeLivro" xsi:type="SQLVARYCHAR"/>
    <COLUMN SOURCE="2" NAME="ISBN13" xsi:type="SQLVARYCHAR"/>
    <COLUMN SOURCE="3" NAME="DataPub" xsi:type="SQLDATE"/>
    <COLUMN SOURCE="4" NAME="PrecoLivro" xsi:type="SQLMONEY"/>
    <COLUMN SOURCE="5" NAME="NumeroPaginas" xsi:type="SQLSMALLINT"/>
    <COLUMN SOURCE="6" NAME="IdEditora" xsi:type="SQLSMALLINT"/>
    <COLUMN SOURCE="7" NAME="IdAssunto" xsi:type="SQLTINYINT"/>
  </ROW>
</BCPFORMAT>

O funcionamento deste arquivo é o seguinte:

• <BCPFORMAT>: Elemento raiz do arquivo XML que define o formato do arquivo de dados.
• <RECORD>: Define a estrutura de cada registro (linha) no arquivo CSV.
• <FIELD>: Define os campos (colunas) do registro. Cada tag <FIELD> especifica o identificador do campo (ID), o tipo de terminador que separa os campos (TERMINATOR), e o comprimento máximo (MAX_LENGTH) do campo.
• <ROW>: Define a correspondência entre os campos do arquivo CSV e as colunas da tabela do banco de dados.
• <COLUMN>: Especifica como cada campo do arquivo CSV (SOURCE) é mapeado para uma coluna na tabela do banco de dados (NAME). Além disso, define o tipo de dados da coluna (xsi:type), que pode ser:
  • SQLVARYCHAR para strings
  • SQLDATE para datas
  • SQLMONEY para valores monetários
  • SQLSMALLINT para números inteiros pequenos
  • SQLTINYINT para números inteiros muito pequenos.

Código SQL

E a seguir temos o código SQL que deverá ser executado no SQL Server, por exemplo usando o SSMS (SQL Server Management Studio):

INSERT INTO Livro (NomeLivro, ISBN13, DataPub, PrecoLivro, NumeroPaginas, IdEditora, IdAssunto)
SELECT 
    NomeLivro, ISBN13, DataPub, PrecoLivro, NumeroPaginas, IdEditora, IdAssunto
FROM OPENROWSET(
    BULK 'C:\SQL\Livros.CSV',
    FORMATFILE = 'C:\SQL\Formato.xml',
CODEPAGE = '65001',  -- UTF-8
FIRSTROW = 2
) AS LivrosCSV;

SELECT * FROM Livro;

Conclusão

Inserir alguns poucos registros em uma tabela de banco de dados é uma tarefa simples e rápida. Porém, cadastrar muitos registros – centenas, milhares ou até mesmo milhões – pode se tornar extremamente trabalhoso e demorado, e neste caso podemos recorrer à importação em massa dos dados. Neste tutorial vimos uma forma simples de fazer isso no SQL Server: usando arquivos de texto do tipo CSV.

Nos próximos tutoriais veremos outras formas de importação (e também exportação) de dados em bancos de dados.

Prefere assistir a uma aula? Então assista ao vídeo da Bóson Treinamentos no YouTube sobre Arquivos CSV no MySQL:

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Importar arquivo CSV no SQL Server para inserir registros em uma tabela apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

• SQL é uma Linguagem de Consulta Estruturada padrão para acesso a Bancos de Dados
• Usada em inúmeros sistemas, como MySQL, SQL Server, Oracle, Sybase, Access, DB2, PostgreSQL, etc.
• Cada um desses sistemas pode utilizar um “dialeto” diferente do SQL, como T-SQL (SQL Server), PL/SQL (Oracle), JET SQL (Access), etc.

História Resumida do SQL

Foi o matemático britânico Edgar F. Codd, no início dos anos 1970, quem propôs o famoso modelo relacional para bancos de dados e, sendo um matemático, ele formalizou diversos conceitos resultando no que chamamos de álgebra relacional e cálculo relacional.

Essa álgebra e cálculo relacional eram conceitos teóricos até que empresas como a IBM e outras começaram a implementar esses conceitos em projetos internos, acadêmicos e de pesquisa. Essas empresas também queriam criar uma linguagem que fosse padrão para realizar consultas em bancos de dados relacionais.

No início, foi desenvolvida uma linguagem chamada de QUEL (Querying Using the English Language / Consulta Usando a Língua Inglesa), na Universidade da Califórnia, Berkeley. Na IBM especificamente, os pesquisadores queriam criar uma linguagem própria e iniciaram um projeto de nome SQUARE (Specifying Queries Using a Relational Environment / Especificação de Consultas Usando um Ambiente Relacional).

Esse trabalho resultou em uma linguagem de consulta que tinha uma notação científica com subíndices e superíndices, na prática difícil de digitar em teclados de computador (da época). Para resolver isso, a linguagem foi redefinida para usar apenas caracteres padrão da língua inglesa, sendo então batizada de SEQUEL. Porém, este nome era uma marca registrada no Reino Unido, o que os impedia de usá-lo. Então, resolveram o problema simplesmente removendo as vogais da palavra SEQUEL, e assim nasceu o termo SQL. Em 1986, o SQL se tormou um padrão ISO e ANSI.

De forma interessante, apesar de seus desenvolvedores terem renomeado o SEQUEL para SQL, muitos continuaram a chamá-lo de “sequel“. E ainda hoje, muitos desenvolvedores de software e profissionais da área de bancos de dados (de língua inglesa, não no Brasil) ainda pronunciam esse nome como “sequel”. A descrição da sigla como sendo Structured Query Language (Linguagem de Consulta Estruturada) foi aparecer posteriormente apenas.

Funções Principais do SQL

• Permite o acesso a dados em SGBDR
• Permite definir os dados no banco de dados e manipulá-los.
• Pode ser embutido em outras linguagens usando módulos SQL, bibliotecas, etc.
• Permite criar e excluir bancos de dados e tabelas.
• Permite a criação de Visões (Exibições), Stored Procedures e Funções em um Banco de Dados.
• Permite configurar permissões de acesso em tabelas, procedimentos e visões.

Grupos de Comandos

Os comandos SQL podem ser divididos em quatro grupos principais:

• DDL
• DML
• DCL
• DQL

DDL – Data Definition Language

DML – Data Manipulation Language

DCL – Data Control Language

DQL – Data Query Language

O vídeo a seguir explica em detalhes cada um dos grupos de comandos SQL apresentados neste tutorial:

Sobre Fábio dos Reis

Fábio dos Reis trabalha com tecnologias variadas há mais de 25 anos, tendo atuado nos campos de Eletrônica, Telecomunicações, Programação de Computadores e Redes de Dados. É um entusiasta de Linux e Open Source em geral, Astrônomo Hobbysta e estudante de idiomas, além de ministrar cursos e palestras sobre diversas tecnologias em São Paulo.

O post O que é SQL: Introdução e grupos de comandos – Curso de SQL Server – 01 apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

A linguagem Python possui suporte a uma grande quantidade de sistemas de bancos de dados, por meio do uso de bibliotecas específicas para cada SGBD.

Neste tutorial vou mostrar como usar uma biblioteca de código aberto para acessar um banco de dados Microsoft SQL Server a partir de um script em Python, realizando a conexão ao banco e, posteriormente, uma consulta simples em uma de suas tabelas.

Para acessar bancos de dados SQL Server usando Python, podemos usar a biblioteca pyodbc. Esta biblioteca permite, na verdade, acessar diversos bancos de dados ODBC, sendo o SQL Server apenas um deles.

Vamos ao tutorial passo a passo.

Python e SQL Server

1. Instalar o driver de acesso ao SQL Server

Antes de começar, precisamos instalar a biblioteca ODBC para Python. Podemos usar o pip ou o conda para instalá-la com um dos seguintes comandos:

$ pip install pyodbc  # ou
$ conda install pyodbc

2. Importamos a biblioteca necessária e criamos uma nova conexão com o banco de dados

import pyodbc

# String de conexão com o banco de dados
conn = pyodbc.connect('Driver={SQL Server};'
'Server=nome_servidor;'
'Database=nome_banco_dados;'
'Trusted_Connection=yes;')

Substituimos nome_servidor e nome_banco_dados pelo nome do servidor e do banco de dados ao qual desejamos nos conectar (por exemplo, localhost e db_biblioteca, respectivamente).

Se precisamos usar a autenticação SQL Server, em vez de autenticação do Windows, a string de conexão fica assim:

conn = pyodbc.connect('Driver={SQL Server};'
'Server=nome_servidor;'
'Database=nome_banco_dados;'
'UID=usuário;'
'PWD=senha')

Substituimos usuário e senha pelo nome de usuário e senha de acesso ao SQL Server.

3. Agora criamos um objeto do tipo cursor e o empregamos para executar os comandos SQL desejados

# Criar um objeto cursor
cursor = conn.cursor()

# Comando SQL a executar
cursor.execute('SELECT * FROM nome_tabela')

# Buscar todos os resultados
for row in cursor:
    print(row)

Devemos substituir nome_tabela pelo nome da tabela que desejamos consultar. Também é possível executar comandos SQL de atualização, inserção e exclusão usando o método execute.

4. Por fim fechamos a conexão com o banco de dados:

conn.close()

Essa instrução irá encerrar a conexão com o banco de dados SQL Server.

Exemplo completo

Vamos usar o banco de dados db_biblioteca neste exemplo, acessando a tabela de livros (tbl_livros) e retornando todas as linhas dessa tabela. O servidor SQL Server em questão utiliza autenticação do Windows:

import pyodbc

# Conexão com o banco de dados
conn = pyodbc.connect('Driver={SQL Server};'
'Server=localhost;'
'Database=db_biblioteca;'
'Trusted_Connection=yes;')

# Criar o objeto cursor
cursor = conn.cursor()

# Executar a consulta SQL
cursor.execute('SELECT * FROM tbl_livro')

# Busca todos os resultados
for row in cursor:
    print(row)

Resultado:

Inserir novas linhas no banco de dados

E se quisermos inserir novos registros em uma tabela?

Neste caso podemos criar um dicionário contendo pares chave:valor representando os nomes das colunas da tabela e os respectivos dados a serem inseridos, e então criar uma consulta SQL para enviar esses dados ao banco, como no exemplo a seguir, onde eu crio um novo registro na tabela de autores:

# Criar um dicionário com os dados a inserir no banco

autor = {
"ID_Autor": 10,
"Nome_Autor": "Fábio",
"Sobrenome_Autor": "dos Reis"
}

# Criar a consulta SQL
sql_query = f"INSERT INTO tbl_autores (ID_Autor, Nome_Autor, Sobrenome_Autor) VALUES (?, ?, ?)"

# Cursor para executar a consulta
cursor = conn.cursor()

# Executar a consulta
cursor.execute(sql_query, autor["ID_Autor"], autor["Nome_Autor"], autor["Sobrenome_Autor"])

# Confirmar a transação (comitar)
conn.commit()

# Encerrar a conexão
conn.close()

No exemplo acima, o cursor é criado usando a conexão estabelecida na etapa anterior. Em seguida, a consulta é executada usando o método execute() do cursor. Certifique-se de passar os valores a serem inseridos na consulta como argumentos para o método execute().

Por fim, é importante confirmar a transação usando o método commit() da conexão. Se você não fizer isso, os dados inseridos não serão salvos no banco de dados.

É isso aí! Este foi um tutorial básico para acesso a bancos de dados SQL Server usando a linguagem Python com a biblioteca pyodbc. Existem muitas outras opções de configuração e métodos disponíveis na biblioteca pyodbc, e algumas delas serão discutidas nos próximos tutoriais dessa série.

.

O post Como acessar bancos de dados SQL Server usando Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Os comandos DCL (Data Control Language / Linguagem de Controle de Dados) em SQL são um conjunto de declarações responsáveis por controlar e gerenciar a segurança e permissões de acesso aos dados armazenados em um banco de dados relacional.

Esses comandos permitem que o administrador do banco de dados conceda ou revogue privilégios de acesso para usuários e grupos de usuários, controlando quem tem permissão para visualizar, modificar ou excluir dados específicos.

Os comandos DCL mais comuns são GRANT e REVOKE. O comando GRANT é usado para conceder permissões a usuários ou grupos de usuários, permitindo que eles executem determinadas operações em objetos específicos, como tabelas ou views.

O comando REVOKE, por sua vez, é usado para revogar essas permissões, removendo o acesso aos objetos especificados.

Os comandos DCL também incluem outras funcionalidades importantes, como a capacidade de definir papéis (roles) e definir políticas de segurança para proteger dados sensíveis. Os papéis são usados para agrupar usuários com permissões semelhantes, simplificando a administração de permissões em grandes bancos de dados com muitos usuários.

Para implementar políticas de segurança, os comandos DCL também permitem que o administrador defina restrições de acesso para determinados usuários ou grupos de usuários. Isso pode incluir a restrição de acesso a determinadas tabelas, limitações na execução de certos comandos, ou a definição de restrições de acesso baseadas em funções ou papéis.

Vejamos com mais detalhes as declarações GRANT e REVOKE. usarei a sintaxe e exemplos dessas declarações no SGBD MySQL neste artigo.

A Declaração GRANT

A declaração GRANT em MySQL é usada para conceder permissões a usuários ou grupos de usuários para executar determinadas ações em um banco de dados específico.

A sintaxe básica da declaração GRANT no MySQL é a seguinte:

GRANT permissão(s) ON nome_banco.nome_tabela TO 'usuario'@'host' IDENTIFIED BY 'senha';

Onde:

• permissão(s) é a permissão ou conjunto de permissões que você deseja conceder, como SELECT, INSERT, UPDATE, DELETE, ALL PRIVILEGES, etc.
• nome_banco.nome_tabela é o nome do banco de dados e da tabela em que você deseja conceder as permissões.
• ‘usuario’@’host’ é o nome do usuário e o host (nome da máquina, como localhost ou ainda um endereço IP) a quem você deseja conceder as permissões.
• IDENTIFIED BY ‘senha’ é a senha para o usuário especificado.

Você deve substituir permissão(s) pelo conjunto de permissões que deseja conceder ao usuário especificado. Por exemplo, podemos usar a sintaxe:

GRANT SELECT, INSERT, UPDATE ON db_biblioteca.tbl_livros TO 'fabio'@'localhost' IDENTIFIED BY '123';

para conceder permissões de seleção, inserção e atualização na tabela especificada para o usuário especificado na tabela de livros do banco db_biblioteca.

Também é possível conceder permissões a todos os bancos de dados ou tabelas de uma só vez usando o caractere curinga (*). Por exemplo:

GRANT ALL PRIVILEGES ON *.* TO 'fabio'@'localhost' IDENTIFIED BY '123';

concederia acesso a todos os bancos de dados e tabelas no servidor MySQL ao usuário ‘fabio’.

Exemplos da declaração GRANT SQL

Vejamos mais alguns exemplos:

1. Conceder acesso total ao banco de dados db_biblioteca para o usuário fabio:

GRANT ALL PRIVILEGES ON db_biblioteca.* TO 'fabio'@'localhost' IDENTIFIED BY '123';

2. Conceder acesso somente leitura a um banco de dados para o usuário:

GRANT SELECT ON db_biblioteca.* TO 'fabio'@'localhost' IDENTIFIED BY '123';

3. Conceder acesso somente para inserir dados na tabela de autores para o usuário:

GRANT INSERT ON db_biblioteca.tbl_autores TO 'fabio'@'localhost' IDENTIFIED BY '123';

4. Conceder acesso a todos os bancos de dados para o usuário:

GRANT ALL PRIVILEGES ON *.* TO 'fabio'@'localhost' IDENTIFIED BY '123';

5. Conceder acesso total ao usuário com base em seu endereço IP:

GRANT ALL PRIVILEGES ON db_biblioteca.* TO 'fabio'@'192.168.1.100' IDENTIFIED BY '123';

A Declaração REVOKE

A declaração REVOKE em MySQL é usada para revogar as permissões concedidas anteriormente a um usuário ou grupo de usuários em um banco de dados ou tabela específica.

A sintaxe básica da declaração REVOKE no MySQL é a seguinte:

REVOKE permissão(s) ON nome_banco_dados.nome_tabela FROM 'usuario'@'host';

Onde:

• permissão(s) são as permissões que queremos revogar, como SELECT, INSERT, UPDATE, DELETE, ALL PRIVILEGES, etc.
• nome_banco_dados.nome_tabela é o nome do banco de dados e tabela em que você deseja revogar as permissões.
• ‘usuario’@’host’ é o nome do usuário e o host (como localhost ou um endereço IP) de quem você deseja revogar as permissões.

Devemos substituir permissão(s) pelo conjunto de permissões que deseja revogar do usuário especificado. Por exemplo, podemos usar a sintaxe:

REVOKE SELECT, INSERT, UPDATE ON nome_banco_dados.nome_tabela FROM 'usuario'@'localhost';

para revogar as permissões de seleção, inserção e atualização na tabela especificada para um usuário especificado.

Também é possível revogar permissões de todos os bancos de dados ou tabelas usando o caractere curinga (*). Por exemplo:

REVOKE ALL PRIVILEGES ON *.* FROM 'usuario'@'localhost';

revogaria todas as permissões de todos os bancos de dados e tabelas no servidor MySQL para o usuário especificado.

Note que, ao revogar permissões, você precisa ter as permissões necessárias para executar a declaração REVOKE. Além disso, se você estiver revogando permissões de um usuário específico, certifique-se de que não haja outros usuários que dependam dessas permissões para acessar o banco de dados ou tabela.

Exemplos da declaração REVOKE SQL

Vejamos alguns exemplos:

1. Revogar todas as permissões do usuário fabio no banco de dados db_biblioteca:

REVOKE ALL PRIVILEGES ON db_biblioteca.* FROM 'fabio'@'localhost';

2. Revogar a permissão de seleção da tabela de editoras específica para o usuário:

REVOKE SELECT ON db_biblioteca.tbl_editoras FROM 'fabio'@'localhost';

3. Revogar a permissão de inserção na tabela de autores para um grupo de usuários:

REVOKE INSERT ON db_biblioteca.tbl_autores FROM 'grupo_usuarios'@'localhost';

4. Revogar todas as permissões do usuário fabio para todos os bancos de dados:

REVOKE ALL PRIVILEGES ON *.* FROM 'fabio'@'localhost';

Resumo

Em resumo, os comandos DCL em SQL são fundamentais para a segurança e integridade dos dados em um banco de dados.

Eles permitem que o administrador do banco de dados conceda ou revogue permissões de acesso para usuários e grupos de usuários, controlando quem pode visualizar, modificar ou excluir dados específicos. Além disso, os comandos DCL incluem recursos importantes, como a definição de papéis e políticas de segurança para proteger dados sensíveis.

Por isso, é importante que os desenvolvedores e administradores de bancos de dados tenham conhecimento desses comandos para garantir a segurança dos dados armazenados.

O post Comandos DCL SQL e sua sintaxe apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Em bancos de dados relacionais é comum o emprego de objetos variados para simplificar o acesso aos dados, assim como melhorar a performance de operações como consultas, inserções e atualizações, entre outras. Alguns desses objetos incluem procedimentos armazenados, triggers e eventos. 

Visualizações são uma outra categoria de objetos com esses propósitos, e dois tipos principais existem: as visualizações comuns (“views“) e as visualizações materializadas (“materialized views“).

Mas qual a diferença entre ambas?  E quando usar uma e quando usar outra?

É o que explico a seguir.

Visualização SQL

Em bancos de dados, uma view (visualização ou exibição) e uma materialized view são dois tipos diferentes de objetos de banco de dados que atendem a propósitos diferentes.

Uma view é uma tabela virtual derivada de uma ou mais tabelas em um banco de dados. Trata-se de uma consulta SQL armazenada que define um conjunto de linhas e colunas que podem ser consultadas como se fossem uma tabela normal. Uma visualização não armazena dados próprios, mas é uma consulta pré-definida salva que pode ser usada para recuperar dados das tabelas subjacentes quando necessário.

Assim, atua como se fosse uma tabela comum aos olhos do usuário.

Uma visualização não ocupa espaço de armazenamento no banco de dados, por não armazenar nenhum dado em si, apenas referenciando os dados das tabelas que a constituem.

As views geralmente são usadas para simplificar consultas complexas, restringir o acesso a dados confidenciais ou fornecer uma exibição personalizada dos dados para diferentes usuários. São usadas da mesma forma que uma tabela qualquer é usada no banco de dados, ou seja, os dados podem ser consultados da mesma maneira que em uma tabela física real.

View é uma tabela armazenada SQL

Visualização Materializada SQL

Por outro lado, uma materialized view (“visualização materializada“) é uma cópia física de uma view que fica armazenada no banco de dados.

É uma tabela pré-computada que contém os resultados de uma consulta realizada em uma ou mais tabelas no banco de dados.

Ao contrário de uma view, uma materialized view realmente armazena dados e pode ser usada para melhorar o desempenho da consulta, reduzindo a quantidade de computação necessária para recuperar os dados. As materialized views costumam ser usadas em aplicativos de armazenamento de dados e inteligência de negócios para armazenar dados de resumo cujo cálculo é custoso ou que são usados com frequência em relatórios.

Por conta disso, as visualizações materializadas consomem espaço de armazenamento no banco de dados, e devemos pensar com cuidado se realmente precisamos usar esse tipo de objeto para realizar consultas ou outras operações quaisquer nos dados.

Conclusão

Em resumo, a principal diferença entre uma view e uma materialized view é que uma view é uma tabela virtual derivada de uma ou mais tabelas em um banco de dados, enquanto uma materialized view é uma cópia física de uma visualização armazenada no banco de dados.

As views são normalmente usadas para simplificar consultas ou restringir o acesso aos dados, enquanto as materialized view são usadas para melhorar o desempenho da consulta e armazenar dados resumidos.

Uma visualização comum não ocupa espaço de armazenamento no banco de dados, ao passo que uma visualização materializada ocupa, e isso deve ser levado em consideração ao determinar que tipo de objeto será mais adequado para as nossas necessidades.

Referências

Plew, R.R.; Stephens, R.K. Aprenda em 24 horas SQL. 2ª edição. Editora Campus, ano 2000

O post Qual a diferença entre View e Materialized View em Bancos de Dados? apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma tarefa comum ao realizar gerenciamento de um servidor é a desinstalação de pacotes ou serviços, um processo rápido e, normalmente, tranquilo. Porém, nem sempre uma remoção simples é efetiva, pois é comum que, ao remover um serviço do sistema, dependências não mais necessárias e arquivos de configuração ainda permaneçam no servidor, ocupando espaço em disco e, possivelmente, podendo vir a causar problemas caso o serviço precise ser reinstalado no futuro.

Neste tutorial vou mostrar como desinstalar totalmente o MySQL Server do Linux Debian 11 “bullseye” e outras distros derivadas, como o Linux Mint e o Ubuntu.

Desinstalação do MySQL do Linux

Vamos aos passos necessários para realizar a desinstalação do MySQL Server do Linux Debian e derivados.

1. Parar o serviço do MySQL

$ sudo systemctl stop mysql

2. Desinstalar os pacotes

Aqui nós temos duas opções:

a. Desinstalar todos os pacotes relacionados ao MySQL, incluindo o servidor, clientes, ferramentas, etc. (objetivo principal do tutorial):

$ sudo apt purge mysql*

b. Ou então podemos remover apenas o pacote do MySQL Server, mantendo os demais pacotes e configurações:

$ sudo apt purge mysql-server

3. Remover dependências não mais utilizadas e limpar o cache

$ sudo apt autoremove
$ sudo apt autoclean

Após a execução desses comandos, o MySQL estará desinstalado o sistema. Porém, existem alguns passos extras opcionais que podemos realizar, para evitar problemas em uma futura nova instalação do MySQL.

Apesar de opcionais, os passos a seguir são altamente recomendados.

4. Remover as configurações do MySQL

a. Remover os arquivos de configuração presentes no diretório /etc/mysql:

$ sudo rm -rf /etc/mysql

5. Remover dados de bancos de dados

a. Armazenamento de bancos de dados no diretório /var/lib/mysql:

$ sudo rm -rf /var/lib/mysql

6. Verificar o resultado da remoção

Por fim, verificamos se o mysql realmente foi eliminado do sistema:

dpkg -l | grep -i mysql

Após realizar todos os passos, recomendo reiniciar o servidor.

O post Como desinstalar totalmente o MySQL Server do Linux Debian 11 bullseye apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

No primeiro artigo da série sobre famílias de comandos SQL, estudamos os comandos DDL (Data Definition Language). Neste segundo artigo discuto os comandos SQL do grupo que chamamos de “comandos DML”, ou Data Manipulation Language (Linguagem de Manipulação de Dados), com a sintaxe das principais declarações e exemplos gerais.

O que são comandos DML?

Os comandos DML são declarações SQL para manipulação de dados em tabelas, o que inclui tarefas para inserção, atualização e exclusão de registros (linhas) em uma tabela.

A tabela a seguir sumariza os comandos para manipulação de dados disponíveis em SQL:

Vejamos a sintaxe e um exemplo de uso de algumas dessas declarações SQL.

Comandos DML

Declaração INSERT

Este comando permite realizar a inserção de dados em uma tabela, por meio da criação de um novo registro.

Vejamos sua sintaxe geral e alguns exemplos.

Sintaxe:

INSERT INTO nome_tabela(coluna1, coluna2, coluna3, ..., colunaN)
VALUES (valor1, valor2, valor3, ..., valorN);

Os valores são inseridos em cada coluna na ordem em que são discriminados na lista de valores em VALUES().

Exemplo: Inserir dados na tabela de livros.

INSERT INTO tbl_livros(Nome_Livro, Data_Pub, Preco_Livro, Genero, Autor, Editora)
VALUES
('Linux Command Line and Shell Scripting', '20150109', 68.35, 1, 5, 4),
('SSH, the Secure Shell', '20050517', 58.30, 1, 1, 2),
('Using Samba', '20031221', 61.45, 1, 2, 2),
('Practical Electronics for Inventors', '20160324', 67.80, 1, 13, 5);

Declaração UPDATE

Com a declaração UPDATE SQL podemos modificar o valor de uma ou mais colunas em um registro.

Sintaxe

UPDATE tabela
SET coluna(s) = novo_valor_armazenado
WHERE coluna = valor_filtro;

Obs.: Se não for empregada a cláusula WHERE para filtrar os registros, TODOS os dados da coluna serão alterados para o mesmo valor!

Exemplo

Neste exemplo vamos alterar o nome de um livro na tabela tbl_livros, cujo ID é igual a 101, para “SSH, o Shell Seguro”:

UPDATE tbl_Livro
SET Nome_Livro = 'SSH, o Shell Seguro'
WHERE Id_Livro = 101;

Declaração DELETE

Com a cláusula DELETE podemos excluir registros específicos, indicados (filtrados) por meio de uma condição na cláusula WHERE

Sintaxe

DELETE FROM tabela
WHERE coluna = valor;

Obs.: Assim como acontece coma cláusula UPDATE, se não for empregada a cláusula WHERE para filtrar os registros, TODOS os dados da coluna serão afetados – no caso, excluídos para sempre! Cuidado!

Exemplo

Vamos excluir o autor da tabela de autores cujo id é igual a 5:

DELETE FROM tbl_autores
WHERE Id_Autor = 5;

Declaração SELECT INTO

Seleciona dados de uma ou mais tabelas e os insere em uma tabela diferente.

Pode ser usado, por exemplo, para criar cópias de backup de tabelas, ou ainda tabelas para relatório, contendo campos selecionados especialmente provenientes de várias tabelas distintas..

Sintaxe

SELECT coluna(s)
INTO nova_tabela
FROM tabela_atual
[WHERE campo = valor];

Exemplo

Criar uma tabela contendo somente os campos Nome_Livro e IdAutor, correspondentes aos livros cujo Id é maior do que 105:

SELECT Nome_Livro, IdAutor
INTO Livro_Autor
FROM tbl_livros
WHERE IdLivro > 105;

É isso aí! No próximo artigo vamos explorar os comandos DQL (Data Query Language) em SQL.

O post Comandos DML SQL e sua sintaxe apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.