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.

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.

Os tipos de dados CHAR, NCHAR, VARCHAR e NVARCHAR são usados para armazenar dados de texto no SQL Server. Cada um é empregado em uma situação distinta, e saber escolher o tipo de dados adequado pode afetar a performance e o uso de espaço no banco de dados.

Neste tutorial vou mostrar cada um desses tipos, suas diferenças e quando usá-los.

Tipos de Texto no SQL Server

Os tipos nchar e nvarchar permitem armazenar caracteres Unicode, ao passo que char e varchar não o permitem – é até possível armazenar Unicode com esses tipos, mas por meio de alguns “truques” no código. Porém, os tipos nchar e nvarchar ocupam o dobro de espaço de armazenamento. Desta forma, recomenda-se utilizá-los apenas caso seja necessário suporte a Unicode na tabela – o que é bastante comum.

Os tipos char e nchar são tipos de tamanho fixo, o que significa que eles reservam espaço de armazenamento para a quantidade de caracteres que foi especificada em suas declarações, mesmo que o espaço não seja totalmente utilizado. Por exemplo, podemos criar um campo char ou nchar para 20 caracteres mas armazenar apenas 15 – os outros 5 que ficaram vagos irão ocupar espaço da mesma maneira.

Recomenda-se usar esses tipos caso os dados armazenados sempre ocupem o tamanho máximo especificado na declaração da coluna.

Já os tipos varchar e nvarchar são tipos de tamanho variável, de modo que o espaço ocupado corresponderá à quantidade de caracteres que efetivamente são armazenados + 2 (2 bytes de registro do comprimento – overhead), independente do tamanho máximo declarado.

Características dos tipos CHAR, NCHAR, VARCHAR e NVARCHAR

CHAR

• Descrição: Armazena dados de texto com comprimento fixo.
• Tamanho: O comprimento é definido ao criar a coluna e todos os valores terão exatamente esse tamanho – ou seja, o comprimento é fixo. Espaços em branco são adicionados para preencher o comprimento se necessário.
• Uso: Dados de tamanho fixo, como códigos de produtos ou identificadores.

NCHAR

• Descrição: Similar ao CHAR (também comprimento fixo), mas armazena dados de texto em formato Unicode.
• Tamanho: Cada caractere ocupa 2 bytes, permitindo armazenar caracteres de múltiplos idiomas.
• Uso: Usado para dados de texto internacionalizados ou quando é necessário suportar vários idiomas.

VARCHAR

• Descrição: Armazena dados de texto com comprimento variável.
• Tamanho: O comprimento máximo é definido ao criar a coluna, mas apenas o espaço necessário para armazenar o valor real é utilizado. Ou seja, ocupa espaço de acordo com o valor armazenado na coluna.
• Uso: Ideal para colunas onde os tamanhos dos valores podem variar significativamente, como nomes, descrições ou endereços.

NVARCHAR

• Descrição: Similar ao VARCHAR, mas armazena dados de texto em formato Unicode.
• Tamanho: Cada caractere ocupa 2 bytes, semelhante ao NCHAR, mas o espaço é utilizado de forma mais eficiente para comprimentos variáveis.
• Uso: Usado para dados de texto internacionalizados ou quando é necessário suportar vários idiomas, com comprimentos variáveis.

Performance dos tipos de texto

Com relação à performance desses tipos de texto no SQL Server, temos que:

• CHAR e NCHAR podem ser mais rápidos para acesso em colunas onde todos os valores têm tamanho fixo.
• Já os tipos VARCHAR e NVARCHAR são mais eficientes em termos de espaço para colunas onde os tamanhos dos valores variam.

Exemplos de uso

1. Tipos CHAR e NCHAR

Criamos uma tabela com dois campos, um do tipo CHAR e outro do tipo NCHAR

CREATE TABLE ExemploCharNChar (
Codigo CHAR(5),
Item NCHAR(10)
);

Inserimos uma linha de teste nessa tabela. Para o campo “Item” usarei um dado em outro idioma, inclusive com outro conjunto de caracteres – no caso, caracteres japoneses.

Note o caractere ‘N’ que precede o valor a ser armazenado, para indicar ao SQL Server que se trata de um valor Unicode.

INSERT INTO ExemploCharNChar (Codigo, Item)
VALUES ('012', N'ピザ');

Consegue descobrir que item foi inserido?

E realizamos uma consulta para ver o dado inserido.

SELECT * FROM ExemploCharNChar;

Resultado:

Codigo  Item
012     ピザ 

2. Tipos VARCHAR e NVARCHAR

Agora vamos criar outra tabela também com dois campos, um do tipo VARCHAR e outro do tipo NVARCHAR

CREATE TABLE ExemploVarcharNVarchar (
Descricao VARCHAR(50),
Pedido NVARCHAR(100)
);

Inserimos uma linha de teste nessa tabela. Para o campo “Pedido” usarei novamente um dado em idioma japonês, desta vez com mais caracteres.

INSERT INTO ExemploVarcharNVarchar (Descricao, Pedido)
VALUES ('Prato Típico Italiano', N'ピザが食べたい.');

E realizamos a consulta para ver o dado inserido.

SELECT * FROM ExemploVarcharNVarchar;

Resultado:

Descricao             Pedido
Prato Típico Italiano ピザが食べたい.

Importante

Uma dica importante é a seguinte: Hoje em dia, os sistemas operacionais e plataformas de desenvolvimento usam internamente o sistema Unicode.

Sendo assim, se usarmos os tipos nvarchar em vez de varchar, e nchar em vez de char, evitamos que ocorram conversões de codificação sempre que operaçoes de leitura ou escrita forem realizadas no banco de dados.

Essas conversões consomem recursos do servidor e podem ocasionar erros, ainda que raramente, além do que não é fácil recuperar de erros de conversão em uma tabela.

Conclusão

Neste tutorial estudamos os tipos de dados CHAR, NCHAR, VARCHAR e NVARCHAR no SQL Server, suas diferenças e exemplos de uso.

Ao escolher o tipo de dados para colunas de texto, considere o tamanho dos dados que você espera armazenar, a necessidade de suporte a múltiplos idiomas e a eficiência de armazenamento. Para texto que precisa ser armazenado em múltiplos idiomas, use os tipos NCHAR ou NVARCHAR. Para texto de tamanho fixo, use CHAR, e para tamanho variável, use VARCHAR.

Lembre-se:

• Usamos CHAR e NCHAR quando o comprimento dos dados for fixo.
• Usamos VARCHAR e NVARCHAR quando o comprimento dos dados for variável.
• A letra ‘N’ antes dos tipos Unicode (NCHAR e NVARCHAR) indica que eles suportam caracteres Unicode.

* ピザ significa “pizza” e ピザが食べたい significa “quero comer pizza” (“piza ga tabetai”).

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 usar os tipos de dados char, nchar, varchar e nvarchar no 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.

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.

Neste artigo discuto os comandos SQL do grupo que chamamos de “comandos DDL”, ou Data Definition Language (Linguagem de Definição de Dados), com a sintaxe das principais declarações e exemplos gerais.

O que são comandos DDL – Data Definition Language

Os comandos DDL são um subconjunto dos comandos da linguagem SQL cujo propósito é definir a estrutura de um banco de dados. Assim, esse comandos são empregados para criar, alterar e excluir objetos do banco, como tabelas, colunas e até mesmo o banco de dados em si.

Os comandos DDL que estudaremos são os seguintes:

• CREATE
• ALTER
• DROP
• RENAME
• TRUNCATE

Comandos DDL

Declaração CREATE

Este comando permite criar um objeto no banco, como uma nova tabela, visão, índice ou outro elemento estrutural.

Vejamos sua sintaxe em diversos SGBDs e alguns exemplos.

1. Para criar um banco de dados no MySQL:

CREATE DATABASE [IF NOT EXISTS] nome_banco;

O uso dos colchetes na sintaxe indica que a cláusula é opcional.

Por exemplo, para criar um banco de dados de nome db_MeusLivros:

CREATE DATABASE IF NOT EXISTS db_MeusLivros;

A sintaxe para outros sistemas de bancos de dados é a seguinte:

Criar banco de dados no SQL Server:

CREATE DATABASE nome_banco;

Criar banco de dados no PostgreSQL:

createdb nome_banco;

2. Para criar uma tabela no MySQL:

CREATE TABLE [IF NOT EXISTS] nome_tabela (
    coluna1 tipo_dado restrições,
    coluna2 tipo_dado restrições,
    colunaN tipo_dado restrições,
    [restrições extras]
);

Por exemplo, para criar uma tabela de autores em um banco, contendo as colunas id de autor, nome e sobrenome:

CREATE TABLE tbl_autores (
    IdAutor SMALLINT AUTO_INCREMENT,
    NomeAutor VARCHAR(30) NOT NULL,
    SobrenomeAutor VARCHAR(60) NOT NULL,
    CONSTRAINT pk_id_autor PRIMARY KEY (IdAutor)
);

A sintaxe para outros sistemas de bancos de dados é a seguinte:

Criar tabela no SQL Server:

CREATE TABLE [nome_banco].[nome_esquema].nome_tabela (
    coluna1 tipo_dado restrições,
    coluna2 tipo_dado restrições,
    colunaN tipo_dado restrições,
    [restrições extras]
) ON [Filegroup];

Criar tabela no PostgreSQL:

CREATE TABLE [IF NOT EXISTS] nome_tabela (
    coluna1 tipo_dado restrições,
    coluna2 tipo_dado restrições,
    colunaN tipo_dado restrições,
    [restrições extras]
);

Criar tabela no Oracle Database:

CREATE TABLE nome_esquema.nome_tabela (
    coluna1 tipo_dado restrições,
    coluna2 tipo_dado restrições,
   colunaN tipo_dado restrições,
    restrições_da_tabela
);

3. Para criar um índice em uma tabela:

CREATE INDEX nome_índice ON tabela(colunas);

Exemplo – criar um índice na tabela de editoras, na coluna NomeEditora:

CREATE INDEX idx_editora ON tbl_Editoras(NomeEditora);

Declaração ALTER

Com a declaração ALTER podemos adicionar, modificar ou excluir colunas em uma tabela. Também é possível alterar outros objetos do banco de dados, como procedimentos armazenados.

Sintaxe e exemplos a seguir.

1. Adicionar uma coluna a uma tabela existente:

ALTER TABLE tabela
ADD coluna tipo_dados constraints;

Exemplo – adicionar a coluna ISBN10 a uma tabela de livros, de nome tbl_livro:

ALTER TABLE tbl_livro
ADD isbn10 VARCHAR(10) NOT NULL;

2. Excluir uma coluna de uma tabela:

ALTER TABLE nome_tabela
DROP COLUMN nome_coluna;

Exemplo – excluir a coluna SobrenomeAutor da tabela de autores:

ALTER TABLE tbl_autores
DROP COLUMN SobrenomeAutor;

Neste caso combinamos o uso da declaração ALTER com a declaração DROP, que exclui objetos do banco de dados.

3. Alterar o tipo de dados de uma coluna

Podemos alterar colunas, por exemplo mudando o tipo de dados, com a seguinte sintaxe:

ALTER TABLE nome_tabela
MODIFY COLUMN nome_coluna tipo_dado constraints;

Exemplo: Vamos alterar o tipo de dado da coluna IdAutor da tabela de livros para o tipo TINYINT:

ALTER TABLE tbl_livros
MODIFY COLUMN IdAutor TINYINT NOT NULL;

Declaração DROP

O comando DROP permite excluir objetos do banco de dados (lida com a estrutura ou esquema, não com os registros).

Sintaxe e exemplos a seguir.

1. Excluir um banco de dados existente:

DROP DATABASE [IF EXISTS] nome_BD;

2. Excluir tabelas:

DROP TABLE [IF EXISTS] nome(s)_tabela(s);

Exemplo: excluir a tabela de editoras:

DROP TABLE IF EXISTS tbl_editoras;

3. Excluir um índice configurado em uma tabela:

DROP INDEX nome_índice ON tabela;

Por exemplo, para excluir o índice idx_editora executamos o comando:

DROP INDEX idx_editora ON tbl_Editoras;

Declaração TRUNCATE

Permite excluir todas as linhas de uma tabela (todos os registros), sem no entanto excluir a tabela em si.

Sintaxe e exemplos a seguir.

TRUNCATE TABLE nome_tabela;

Exemplo: Vamos limpar a tabela de editoras:

TRUNCATE TABLE tbl_editoras;

A sintaxe para outros sistemas de bancos de dados é a seguinte:

Limpar tabela no SQL Server:

TRUNCATE TABLE [nome_banco].[esquema].nome_tabela;

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

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

Uma subconsulta é uma consulta embutida dentro de outra consulta, de forma aninhada, passando os resultados da consulta mais interna para a consulta mais externa por meio de uma cláusula WHERE ou de uma cláusula HAVING.

Desta forma, é possível restringir mais ainda os dados retornados por uma consulta, permitindo a criação de filtros bastante aprimorados. A subconsulta retorna os dados que serão empregado pela consulta “principal”, alimentando-a com informações a serem utilizadas como condições de filtragem.

Podemos utilizar subconsultas não apenas em consultas com a cláusula SELECT, mas também em operações INSERT, UPDATE e DELETE.

Quando usamos uma subconsulta em uma query, a subconsulta é resolvida primeiro, e então a consulta externa (principal) é resolvida de acordo com o resultado retornado pela subconsulta (subquery).

Regras gerais para aplicação de subconsultas

Algumas regras gerais precisam se seguidas para que seja possível empregar subconsultas. Entre elas, temos:

• A subconsulta pode ter apenas uma única coluna em sua cláusula SELECT, exceto quando a consulta principal tiver múltiplas colunas para comparação com as colunas selecionadas
• Se a subconsulta retornar mais de uma linha de dados, é necessário usar operadores de valores múltiplos, como o operador lógico IN
• As subconsultas são escritas dentro de parênteses
• Não é possível usar a cláusula ORDER BY em uma subconsulta – mas a consulta principal pode.
• É possível usar uma cláusula GROUP BY em uma subconsulta.
• Não podemos usar o operador BETWEEN com uma subconsulta (na consulta principal), mas podemos usar esse operador dentro da subconsulta.

Sintaxe Básica de uma Subconsulta SQL

A sintaxe básica para a criação de uma subconsulta SQL é a seguinte:

SELECT coluna(s)
FROM tabela(s)
WHERE coluna operador (SELECT coluna
                       FROM tabela WHERE condições);

Onde operador pode ser qualquer operador lógico ou relacional, como >, <, >= ,<= ,=, <>, IN, NOT, AND, OR, etc.

Vejamos exemplos de aplicação de subconsultas SQL, usando o SGBD MySQL Server.

1. Subconsulta com operação SELECT

Vamos efetuar uma consulta à tabela de livros de nosso banco de dados db_biblioteca, retornando os livros (tbl_livro) publicados pela editora Wiley (tbl_editora), porém usando uma subconsulta em vez de usar INNER JOIN:

SELECT NomeLivro, PrecoLivro, IdEditora
FROM tbl_livro
WHERE IdEditora = 
    (SELECT IdEditora
     FROM tbl_editora
     WHERE NomeEditora = 'Wiley');

Resultado:

2. Subconsulta com operação INSERT INTO

Podemos usar subconsultas também com a instrução de inserção de registros INSERT INTO, e outras instruções de linguagem de manipulação de dados (DML). Com a instrução INSERT INTO, os dados retornados por uma subconsulta são usados para realizar a inserção de um registro em outra tabela.

Sintaxe:

INSERT INTO tabela (colunas)
                   (SELECT coluna(s)
                   FROM tabela(s)
                   WHERE coluna operador valor);

Exemplo: Vamos criar uma tabela de exemplo chamada de LivrosAssuntos, contendo os campos ID, NomeLivro e NomeAssunto:

CREATE TABLE LivrosAssuntos (
  ID TINYINT PRIMARY KEY AUTO_INCREMENT,
  NomeLivro VARCHAR(50),
  NomeAssunto VARCHAR(40)
)

Usando uma subconsulta, vamos popular esta nova tabela com os livros que tenham mais de 600 páginas e seus respectivos assuntos:

INSERT INTO LivrosAssuntos (NomeLivro, NomeAssunto)
  (SELECT L.NomeLivro, A,NomeAssunto
  FROM tbl_livro L
  INNER JOIN tbl_assunto A
    ON L.IdAssunto = A.IdAssunto
  WHERE L.NumPaginas >= 600);

Após executar o comando, efetuamos uma consulta à nova tabela para verificar se os dados foram inseridos com sucesso:

SELECT * FROM LivrosAssuntos

Resultado:

3. Subconsulta com operação UPDATE

Também podemos usar uma subconsulta com uma instrução UPDATE, permitindo atualizar os valores de registros de uma tabela com base no resultado retornado pela subconsulta.

Sintaxe:

UPDATE tabela
SET coluna(s) = valor
WHERE coluna operador (SELECT coluna(s)
                       FROM tabela
                       WHERE coluna operador valor);

Exemplo: Vamos aumentar os preços dos livros da editora Microsoft Press em 12% usando a declaração UPDATE. Como não sabemos o ID desta editora de memória, vamos usar uma subconsulta para nos auxiliar:

UPDATE tbl_livro
SET PrecoLivro = PrecoLivro * 1.12
WHERE IdEditora = 
    (SELECT IdEditora
     FROM tbl_Editora
     WHERE NomeEditora = 'Microsoft Press');

A subconsulta retorna o ID da editora de acordo com o nome da editora fornecido, e este ID é então empregado na consulta principal para aplicar a atualização nos valores dos registros desejados.

4. Subconsulta com operação DELETE

Finalmente, podemos usar subconsultas em instruções DELETE, selecionando o valor a ser excluído de uma tabela de acordo com o retorno da subconsulta.

Sintaxe:

DELETE FROM tabela
WHERE coluna operador (SELECT coluna
                       FROM tabela
                       WHERE coluna operador valor);

Exemplo: Desejamos excluir os livros publicados cujo assunto é “Dinossauros“, porém não sabemos o ID deste assunto na tabela de livros. Suponha também que não sabemos com exatidão se o nome do assunto é “Dinossauros”, “Dinossauro” (no singular), “Dinos” ou algo do gênero – apenas os lembramos que o nome do assunto começa com “Dino”:

DELETE FROM tbl_livro
WHERE IdAssunto =
   (SELECT IdAssunto
    FROM tbl_Assunto
    WHERE NomeAssunto LIKE 'Dino%');

Subconsultas encadeadas

Podemos aninhar uma subconsulta dentro de outra subconsulta, da mesma maneira que uma subconsulta é aninhada dentro de uma consulta principal. Neste caso, a subconsulta mais interna é resolvida primeiro, depois a subconsulta intermediária, e finalmente o resultado é repassado para a consulta principal.

Sintaxe básica:

SELECT coluna(s)
FROM tabela(s)
WHERE coluna operador (SELECT coluna
                       FROM tabela
                       WHERE coluna operador (SELECT coluna
                                              FROM tabela
                                              WHERE coluna operador valor);

Na prática, podemos pensar na subconsulta intermediária como fazendo o papel de uma consulta principal para a subconsulta de nível mais interno, e, assim, o processo é similar para quantos níveis de subconsultas forem aninhados.

Há um limite para a quantidade das subconsultas que podem ser aninhadas? 

Isso depende muito da implementação de banco de dados que está sendo empregada. Por exemplo, o SGBDR Microsoft SQL Server suporta até 32 níveis de aninhamento (subconsulta dentro de subconsulta), porém esse limite pode ser diferente em outros sistemas, muitas vezes por conta de restrições de memória disponível ou da complexidade em si das consultas. Consulte sempre a documentação do sistema em uso para saber mais a respeito.

Confira também o conteúdo deste tutorial em uma aula em vídeo:

Veja também: Cláusula INNER JOIN – Retornar dados de duas ou mais tabelas relacionadas

O post O que é uma Subconsulta SQL (Subquery) apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste artigo vamos abordar o armazenamento de data e hora em bancos de dados Microsoft SQL Server. Existem seis tipos que permitem armazenar informações temporais (sobre data e/ou hora) no SQL Server. São eles:

• DATE
• TIME
• SMALLDATETIME
• DATETIME
• DATETIME2
• DATETIMEOFFSET

A seguir temos listadas as características principais de cada um desses tipos.

Tipo DATE

• Armazena apenas a data de um evento
• Não é adequado caso seja necessário armazenar também o horário de um evento
• Formato padrão de armazenamento: AAAA-MM-DD
• Permite armazenar datas com valores de 0001-01-01 a 9999-12-31
• Ocupa 3 bytes de espaço, e é armazenado como um valor INT
• O tipo DATE pode ser convertido para DATETIME, SMALLDATETIME, DATETIME2 ou ainda DATETIMEOFFSET; nesses casos, o valor de horário é ajustado para 00:00.
• Datas no tipo DATE não podem ser convertidas para o tipo TIME.

Tipo TIME

• Usado para registrar o horário específico em que uma atividade ou transação ocorreu.
• Dados no tipo TIME independem de data
• Possui precisão de 100 ns, e seu valor padrão é 00:00:00.
• Formato padrão: hh:mm:ss[.nnnnnnn], onde a parte fracionária (frações de segundo) é representada por nnnnnnn.
• Faixa de valores: de 00:00:00.0000000 a 23:59:59.9999999
• Ocupa 5 bytes de espaço e não é possível convertê-lo para tipo DATE.
• Se convertido para outros tipos de data compostos, a parte da data assumirá o valor 1900-01-01

Tipo SMALLDATETIME

• Faixa de valores: 1900-01-01 a 2079-06-06
• Ocupa 4 bytes de espaço de armazenamento
• Esse tipo não é compatível com o padrão ANSI
• Arredonda os segundos de acordo com o valor passado
• Não trabalha com fuso horário e nem com horário de verão, assim como os tipos DATE e TIME.

Tipo DATETIME

• Este tipo também não segue o padrão SQL. Possui limitações relativas à acurácia de frações de segundo (precisão).
• Faixa de valores: 1753-01-01 a 2999-12-31
• Tamanho: ocupa 8 bytes de espaço
• Não é recomendado por não ser compatível com padrão ANSI

Tipo DATETIME2

• Armazena data e hora com precisão de até 100 ns.
• É uma boa escolha para cenários onde é necessário armazenar o valor de tempo até frações de segundo
• Não apresenta os problemas de arredondamento de DATETIME
• Faixa de valores: de 1753-01-01 até 2999-12-31, e hora de 00:00:00 a 23:59:59.9999999
• Sua precisão é ajustável, e seu tamanho depende da precisão escolhida.
• Limitação: não suporta fuso horário nem horário de verão.

Tipo DATETIMEOFFSET

• Este tipo possui alto nível de precisão, até 100 ns
• Formato: AAAA-MM-DD hh:mm:ss.nnnnnnn+|-hh:mm, onde +|-hh:mm tem a haver com o offset (deslocamento de tempo)
• O offset pode variar de +14 a -14 para o número de horas em que um horário específico pode ser deslocado
• Faixa de valores: de 0001-01-01 até 2999-12-31 para datas, e de 00:00:00 até 23:59:59.9999999 para hora.
• Tamanho ocupado: 10 bytes, fixo.

Perguntas e Respostas

1. Quais são os tipos de dados usados para trabalhar com data e hora no SQL Server?
   Os tipos de dados de data e hora no SQL Server são DATE, TIME, DATETIME, DATETIME2, SMALLDATETIME e DATETIMEOFFSET.
2. Qual tipo de dados suporta fuso horário no SQL Server?
   O tipo que suporta fuso horário (e também horário de verão) é o DATETIMEOFFSET.
3. Preciso armazenar data e hora em um mesmo campo em uma tabela no SQL Server. Qual o tipo de dado mais adequado neste caso?
   O melhor tipo de dado neste caso é o DATETIME2, que permite armazenar data e hora com precisão de até 100 nanossegundos, sem problemas de arredondamento de valores que existem no tipo DATETIME.

O post Tipos de Data e Hora no SQL Server apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.