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.

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.

Nesta lição vamos explicar o que são Cursores em Bancos de Dados, e mostrar como utilizar esse recurso em SQL Server.

O que é um Cursor

A declaração SELECT, empregada para realizar consultas em SQL, retorna um conjunto de linhas que chamamos de “resultset“, ou conjunto-resultado. Porém, às vezes é necessário processar dados retornados em uma consulta não em conjuntos, mas uma linha por vez.

Para que isto seja possível, usamos um objeto de banco de dados chamado de “Cursor”.

Os cursores podem ajudar a criar um processo repetível que opere em um registro por vez.

Lembrando que manipular registros no SQL Server um por vez quase sempre irá resultar em uma performance inferior em comparação com a manipulação padrão de dados em grupos (blocos).

Um cursor seleciona um conjunto de dados, busca um registro por vez desse conjunto, e então modifica o registro atual. Ao terminar a ação requerida no registro, o próximo registro é buscado para ser processado. Basicamente, um cursor é um ponteiro para uma linha em um conjunto de resultados ou uma tabela.

Antes de falar sobre operações e modo de funcionamento de cursores, um aviso: Cursores podem ser extremamente lentos. Sempre que possível, tente usar outro tipo de estrutura no lugar de um cursor, como subconsultas, procedimentos armazenados, funções definidas pelo usuário, etc.; o ganho de performance pode variar na faixa de 5 a 10 vezes, ou mais em alguns casos!

Operações de Cursores

Existem diversas operações que devem ser realizadas para que possamos usar um cursor. As operações incluem abrir o cursor, buscar linhas, fechar e desalocar o cursor, entre outras.

Primeiramente, é preciso declarar um cursor para que seja possível usá-lo. Usamos a seguinte sintaxe para realizar a declaração de um cursor no SQL Server:

DECLARE nome_cursor CURSOR [opções]
FOR declaração_SELECT;

Quando abrimos um cursor, a declaração SELECT criada para ele é executada, e o conjunto-resultado da consulta é armazenado em um local na memória do sistema.

Para abrir um cursor em SQL Server e preenchê-lo com dados usamos a seguinte sintaxe:

OPEN nome_cursor

Para recuperar os dados contidos no resultado da consulta do cursor (já aberto), usamos a instrução FETCH, que irá buscar as linhas do resultado uma a uma, como segue:

FETCH direção FROM nome_cursor INTO lista_variáveis

Usamos um laço WHILE para iterar pelas linhas até que o cursor atinja o final do conjunto de dados.

A direção pode ser (dependendo do tipo de cursor) um dos métodos a seguir:

• FIRST Busca apenas a primeira linha da tabela retornada ao cursor.
• LAST Busca apenas a última linha da tabela retornada ao cursor.
• NEXT Busca dados na direção “para frente”.
• PRIOR Busca dados na direção “para trás”
• ABSOLUTE n Busca exatamente a linha de número n
• RELATIVE n Busca os dados de forma incremental ou decremental.

O mais comum é usar a direção NEXT (“próximo registro à frente”), como veremos no exemplo do cursor FORWARD ONLY.

Após terminar de processar todos os registros, o cursor deve ser fechado, de modo que não estará mais disponível para o programa que o executou. Para tal, basta usar a instrução CLOSE:

CLOSE nome_cursor

Após fechá-lo, é necessário liberar a memória que foi alocada a ele para armazenar os resultados de sua consulta. Isso é importante pois, em muitas implementações de bancos de dados, fechar um cursor não libera automaticamente a área de memória utilizada.

Para liberar a memória, devemos desalocá-la usando a operação DEALLOCATE, como segue:

DEALLOCATE nome_cursor

Agora a memória está livre para ser usada por outros processos.

A ilustração abaixo mostra o fluxo das operações de cursor explicadas:

Sequência de operações em um cursor

Funções de sistema

Além dos comandos apresentados anteriormente, também usamos algumas funções de sistema para gerenciar cursores. As mais importantes são:

• Função @@CURSOR_ROWS – Retorna o número de linhas no cursor.
• Função @@FETCH_STATUS – Reporta o estado do cursor após o último comando FETCH executado. Os estados são os seguintes:
  • 0: O último FETCH obteve uma linha com sucesso
  • -1:O último FETCH falhou pois alcançar o final do conjunto de dados, ou falhou por outro motivo não especificado.
  • -2: A última linha buscada não estava disponível – a linha foi excluída.

Tipos de Cursores

Existem alguns tipos básicos de cursores no SQL Server, tais como:

• Forward-Only (cursor padrão)
• Estático
• Keyset
• Dinâmico

Vamos explicar do que se tratam esses tipos de cursores, e ver um exemplo completo de uso do cursor Forward-Only, que é o mais comum.

Cursor Forward-Only

Neste tipo de cursor os dados somente podem ser buscados em uma direção. É possível realizar as operações padrão insert, update e delete nos dados.

Exemplo

SET NOCOUNT ON;

DECLARE @idLivro SMALLINT, @nomeLivro VARCHAR(50), @mensagem VARCHAR(60);

PRINT '----Listagem de Livros----';

DECLARE cursor_livros CURSOR FORWARD_ONLY
FOR
SELECT ID_Livro, Nome_Livro FROM tbl_livros
ORDER BY ID_Livro;

OPEN cursor_livros

FETCH NEXT FROM cursor_livros -- NEXT busca o próximo registro "á frente"
INTO @idLivro,@nomeLivro

WHILE @@FETCH_STATUS = 0
BEGIN
 PRINT ' '
 SELECT @mensagem = '---Dados do livro ' + @nomeLivro + '---'
 PRINT @mensagem

 SELECT L.Nome_Livro Livro, L.Preco_Livro 'Preço', A.Nome_AUTOR + ' ' + A.SOBRENOME_Autor Autor, E.Nome_Editora Editora
 FROM tbl_livros L
  JOIN tbl_autores A
  ON L.ID_Autor = A.ID_Autor
  JOIN tbl_editoras E
  ON L.ID_editora = E.ID_Editora
 WHERE L.ID_Livro = @idLivro

 FETCH NEXT FROM cursor_livros
 INTO @idLivro,@nomeLivro

END
CLOSE cursor_livros;
DEALLOCATE cursor_livros;

-- Comparar com consulta sem cursores:
SELECT L.Nome_Livro Livro, L.Preco_Livro 'Preço', A.Nome_AUTOR + ' ' + A.SOBRENOME_Autor Autor, E.Nome_Editora Editora
FROM tbl_livros L
JOIN tbl_autores A
ON L.ID_Autor = A.ID_Autor
JOIN tbl_editoras E
ON L.ID_editora = E.ID_Editora;

Cursor Estático

Algumas vezes precisamos nos mover para frente e para trás ao executar um cursor. Quando usamos um cursor estático, o conjunto de resultados não é alterado após o cursor ter sido aberto. Este tipo de cursor nos dá a opção de ser somente-leitura ou de permitir leitura e escrita de dados. Em um cursor somente-leitura, os dados não podem ser modificados – se você tentar modificá-los, não existe a garantia de que o cursor irá retornar esses dados alterados.

Ou seja, as operações update, insert e delete não modificam o conjunto de dados de um cursor estático, a menos, é claro, que o cursor seja fechado e reaberto após a realização dessas operações.

Cursor Keyset

Ao definir um novo cursor, pode ser que haja um conjunto de colunas que criam, em conjunto, uma entrada única. Caso seja possível identificar essas colunas, e se você precisar interagir com linhas que foram alteradas, usar esse tipo de cursor é uma opção interessante.

O “keyset” é um “conjunto de chaves” derivadas deste conjunto único de colunas – são identificadores únicos. Aqui, o cursor pode se mover para frente e para trás. É sensível a alterações na fonte de dados, e suporta as operações triviais de atualização e exclusão de dados.

Cursor Dinâmico

Um cursor dinâmico permite visualizar as alterações realizadas nos dados pelas operações insert, update e delete enquanto o cursor está aberto, sendo, desta forma, sensível a atualizações na fonte dos dados.

Perguntas e Respostas

1. É recomendável usar um cursor para realizar consultas em uma tabela?
   No geral, não. Sempre que possível, tente escrever suas consultas ou outras declarações SQL utilizando técnicas que não envolvam a iteração linha a linha em um conjunto de dados.
2. Quais os cinco comandos básicos requeridos para criar e usar um cursor no SQL Server?
   Os comandos são: DECLARE, OPEN, FETCH, CLOSE e DEALLOCATE.
3. Quais os tipos de cursores suportados pelo SQL Server?
   O SQL Server suporta cursores dos tipos Forward-Only, Estático (Static), Dinâmico (Dynamic) e Keyset.

Referências

• Nielsen, P.; White, M.; Parui, U. Microsoft SQL Server 2008 Bible. Editora Wiley
• Plew, R. R.; Stephens, R. K. Aprenda em 24 horas SQL. Editora Campus. 2ª Edição.

O post Introdução aos Cursores no SQL Server apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste artigo mostraremos como realizar as operações de commit e rollback em transações no SQL Server. Antes, vejamos uma breve explicação sobre esses termos.

Transação

Chamamos de Transação, em bancos de dados, a um conjunto de uma ou mais operações que constituem uma única tarefa ou unidade lógica de trabalho a ser processada.

Os sistemas de bancos de dados devem garantir a execução correta das transações, mesmo que venham a ocorrer falhas; a transação deve executada por completo (incluindo todas as operações) ou então nenhuma de suas operações deve ser executada (a transação é abortada).

A transação é a propagação de alterações para o banco de dados, como por exemplo a alteração ou exclusão de registros em uma tabela.

Operações COMMIT e ROLLBACK

Se um transação for concluída com sucesso (todas as operações bem-sucedidas), o banco de dados será alterado permanentemente, com os dados alterados persistidos (salvos em disco); essa operação é chamada de COMMIT.

Porém, se houver falha em qualquer uma das operações que compõem a transação, o banco deverá ser retornado ao estado anterior ao início da transação; chamamos a essa operação de ROLLBACK.

Assim, podemos caracterizar as transações da seguinte forma:

• Todas as transações possuem início e fim
• As transações podem ser salvas (consolidadas no banco de dados) ou desfeitas
• Caso uma transação falhe no meio da execução de suas operações, nenhuma das operações será salva no banco de dados – todas serão desfeitas. 

No SQL Server, iniciamos uma transação com a declaração BEGIN TRANSACTION, e finalizamos o bloco que compõe a transação com as declarações COMMIT TRANSACTION ou ROLLBACK TRANSACTION, dependendo do estado que se deseja alcançar – salvar ou desfazer as operações, respectivamente.

Vamos a um exemplo.

Exemplo

No exemplo a seguir criamos uma tabela para testes de nome Livro_ISBN, com dados oriundos da tabela de livros que usamos em nosso curso de SQL Server. Logo após, experimentamos realizar duas transações: uma com rollback, desfazendo a transação, e outra com commit, confirmando a transação e alterando definitivamente os dados no banco.

Os comentários explicam o que acontece em cada exemplo:

-- criar tabela para testes
SELECT Nome_Livro,ISBN
INTO Livro_ISBN
FROM tbl_livros;

-- transação com rollback
BEGIN TRANSACTION
  DELETE FROM Livro_ISBN -- apaga todos registros da tabela, "sem querer"
  SELECT * FROM Livro_ISBN -- mostra tabela vazia
ROLLBACK TRANSACTION; -- desfaz a transação
SELECT * FROM Livro_ISBN; -- mostra os dados normalmente

-- transação com commit
BEGIN TRANSACTION
  DELETE FROM Livro_ISBN -- apaga todos registros da tabela
  SELECT * FROM Livro_ISBN -- mostra tabela vazia
COMMIT TRANSACTION; -- confirma a transação
SELECT * FROM Livro_ISBN; -- agora mostra a tabela vazia em definitivo

Além de podermos trabalhar com commit e rollback, também é possível criarmos pontos de salvamento para as transações. Abordaremos os pontos de salvamento no SQL Server no próximo artigo sobre transações.

Perguntas e Respostas

1. Quais comandos podem ser controlados por transações no SQL Server?
   Em transações colocamos os comandos DML, que causam alterações nos dados armazenados nas tabelas. São eles: insert, update e delete.
2. Qual a diferença entre COMMIT e ROLLBACK?
   COMMIT consolida a transação, ou seja, executa os comandos em definitivo. Já o ROLLBACK desfaz a transação inteira – nenhuma declaração SQL contida na transação é executada.

O post Transações – COMMIT e ROLLBACK no SQL Server apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

A cláusula BETWEEN nos permite retornar intervalos de dados especificados em um filtro na cláusula WHERE quando executarmos uma consulta SQL.

Uma aplicação comum da cláusula BETWEEN é o retorno de registros de vendas contidos dentro de um intervalo de datas escolhido pelo usuário. Mas também é possível usar a cláusula BETWEEN para trabalhar com intervalos de hora, por exemplo com o tipo TIME.

Exemplo

Para nossos exemplos vamos criar uma tabela chamada tblAgenda, que conterá os campos ID, Compromisso e Hora, com os tipos SMALLINT, VARCHAR e TIME, respectivamente. Logo após, vamos inserir alguns registros de atividades em nossa agenda:

CREATE TABLE tblAgenda (
  ID SMALLINT PRIMARY KEY IDENTITY,
  Compromisso VARCHAR(60) NOT NULL,
  Hora TIME
);

INSERT INTO tblAgenda (Compromisso, Hora)
VALUES
('Acordar','05:00'),
('Academia','06:00'),
('Ir ao Trabalho','07:30'),
('Almoço com Cliente','12:40'),
('Reunião com Chefia','15:30'),
('Fim do Expediente','17:00'),
('Consulta com Dentista','17:30'),
('Cinema','19:00'),
('Jantar em Casa','21:15'),
('Assistir Netflix','22:00'),
('Hora de Dormir','23:30');

Vejamos os dados cadastrados na tabela de agenda:

SELECT * FROM tblAgenda;

Vamos agora realizar algumas consultas usando a cláusula BETWEEN para filtrar os dados de acordo com critérios de horário. Por exemplo, vamos retornar todos os dados dos compromissos agendados no intervalo entre 07:00 da manhã e 17:00, inclusive:

SELECT *
FROM tblAgenda
WHERE Hora BETWEEN '07:00' AND '17:00';

Outro exemplo: vamos verificar quais compromissos ainda temos no restante do dia. Para isso vamos passar o horário atual (são 15:28 agora aqui no escritório!) para a cláusula BETWEEN com a função GETDATE():

SELECT *
FROM tblAgenda
WHERE Hora BETWEEN CONVERT(time, GETDATE()) AND '23:59';

BETWEEN com tipo DATETIME

E se o tipo for DATETIME em vez de TIME? Já vimos como trabalhar com a cláusula BETWEEN e datas com DATETIME anteriormente. Mas, e se precisarmos incluir também a hora no filtro de intervalos?  Neste caso teríamos a informação de data armazenada juntamente com o horário no dado deste tipo.

Suponhamos que me vez de usar o tipo TIME tivéssemos empregado o tipo DATETIME na nossa tabela de agenda, e que, desta forma, tivéssemos fornecido não apenas os horários dos compromissos, mas também suas respectivas datas.

Vamos apagar a tabela de agenda recriá-la com o tipo DATETIME no campo Hora, inserindo registros com data e hora dos compromissos:

DROP TABLE tblAgenda;

CREATE TABLE tblAgenda (
ID SMALLINT PRIMARY KEY IDENTITY,
Compromisso VARCHAR(60) NOT NULL,
Hora DATETIME
);

INSERT INTO tblAgenda (Compromisso, Hora)
VALUES
('Acordar','20200130 05:00'),
('Academia','20200130 06:00'),
('Ir ao Trabalho','20200130 07:30'),
('Almoço com Cliente','20200130 12:40'),
('Reunião com Chefia','20200130 15:30'),
('Fim do Expediente','20200130 17:00'),
('Consulta com Dentista','20200130 17:30'),
('Cinema','20200130 19:00'),
('Jantar em Casa','20200130 21:15'),
('Assistir Netflix','20200130 22:00'),
('Hora de Dormir','20200130 23:30'),
('Acordar','20200202 05:00'),
('Ir ao Trabalho','20200202 07:30'),
('Almoço com Cliente','20200202 12:30'),
('Reunião com Chefia','20200202 16:30'),
('Fim do Expediente','20200202 17:00'),
('Compras no Shopping','20200202 18:15'),
('Cinema','20200202 19:00'),
('Jantar no Restaurante','20200202 21:30'),
('Hora de Dormir','20200202 23:30');

Verificando os registros inseridos:

SELECT * FROM tblAgenda;

Vamos agora consultar os compromissos em um intervalo, digamos de 30/01/2020 às 20:00 até 02/02/2020 às 15:00, usando a seguinte sintaxe:

SELECT * FROM tblAgenda
WHERE Hora BETWEEN '20200130 22:00' AND '20200202 15:00';

Resultado:

É isso aí! Vimos nesta lição como trabalhar com data e hora como filtros da cláusula BETWEEN em consultas SQL.

O post Cláusula BETWEEN e tipos de Hora no SQL Server apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Às vezes é muito útil podermos visualizar a numeração das linhas em um script SQL quando trabalhamos no Microsoft no SQL Server Management Studio, por exemplo para encontrar erros específicos e tentar corrigi-los.

Por padrão, a numeração de linhas nos scripts não é exibida, mas podemos ativar esse recurso de forma bem simples e rápida. É isso o que faremos com os procedimentos mostrados a seguir.

Procedimentos

A figura a seguir mostra um script carregado no Microsoft SQL Server Management Studio, sem a numeração das linhas:

Vamos ativar a numeração de linhas para facilitar nosso trabalho no script. Para começar, clique no menu Ferramentas e logo após no item Opções…:

Na caixa de diálogo aberta clique para expandir, no painel do lado esquerdo, o item Editor de Texto. Logo após, expanda também o sub-item Transact-SQL e então clique na opção Geral.
No painel exibido do lado direito marque a opção “Números de Linha“, e clique em OK para ativar a numeração de linhas nos scripts e então fechar a caixa de diálogo:

Agora podemos ver que uma nova coluna foi acrescentada e é exibida à esquerda na janela do script, contendo a numeração das linhas:

É isso aí! Numeração de linhas ativada com sucesso no SSMS!

O post Mostrar numeração de linhas no SQL Server Management Studio apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.