SQL - Guia Rápido

SQL é uma linguagem para operar bancos de dados; inclui criação de banco de dados, exclusão, busca de linhas, modificação de linhas, etc. SQL é umANSI (American National Standards Institute) linguagem padrão, mas existem muitas versões diferentes da linguagem SQL.

O que é SQL?

SQL é Structured Query Language, que é uma linguagem de computador para armazenar, manipular e recuperar dados armazenados em um banco de dados relacional.

SQL é a linguagem padrão para o Relational Database System. Todos os sistemas de gerenciamento de banco de dados relacional (RDMS) como MySQL, MS Access, Oracle, Sybase, Informix, Postgres e SQL Server usam SQL como linguagem de banco de dados padrão.

Além disso, eles estão usando dialetos diferentes, como -

MS SQL Server usando T-SQL,
Oracle usando PL / SQL,
A versão MS Access do SQL é chamada de JET SQL (formato nativo) etc.

Por que SQL?

SQL é amplamente popular porque oferece as seguintes vantagens -

Permite que os usuários acessem dados nos sistemas de gerenciamento de banco de dados relacional.
Permite que os usuários descrevam os dados.
Permite que os usuários definam os dados em um banco de dados e manipulem esses dados.
Permite incorporar em outras linguagens usando módulos SQL, bibliotecas e pré-compiladores.
Permite que os usuários criem e eliminem bancos de dados e tabelas.
Permite aos usuários criar visão, procedimento armazenado, funções em um banco de dados.
Permite que os usuários definam permissões em tabelas, procedimentos e visualizações.

Uma breve história do SQL

1970- Dr. Edgar F. "Ted" Codd, da IBM, é conhecido como o pai dos bancos de dados relacionais. Ele descreveu um modelo relacional para bancos de dados.
1974 - Apareceu a Structured Query Language.
1978 - A IBM trabalhou para desenvolver as idéias de Codd e lançou um produto chamado System / R.
1986- A IBM desenvolveu o primeiro protótipo de banco de dados relacional e padronizado por ANSI. O primeiro banco de dados relacional foi lançado pela Relational Software, que mais tarde veio a ser conhecida como Oracle.

Processo SQL

Quando você está executando um comando SQL para qualquer RDBMS, o sistema determina a melhor maneira de realizar sua solicitação e o mecanismo SQL descobre como interpretar a tarefa.

Existem vários componentes incluídos neste processo.

Esses componentes são -

Consultar despachante
Mecanismos de Otimização
Motor de consulta clássico
SQL Query Engine, etc.

Um mecanismo de consulta clássico lida com todas as consultas não SQL, mas um mecanismo de consulta SQL não lida com arquivos lógicos.

A seguir está um diagrama simples que mostra a arquitetura SQL -

Comandos SQL

Os comandos SQL padrão para interagir com bancos de dados relacionais são CREATE, SELECT, INSERT, UPDATE, DELETE e DROP. Esses comandos podem ser classificados nos seguintes grupos com base em sua natureza -

DDL - linguagem de definição de dados

Sr. Não.	Comando e Descrição
1	CREATE Cria uma nova tabela, uma visão de uma tabela ou outro objeto no banco de dados.
2	ALTER Modifica um objeto de banco de dados existente, como uma tabela.
3	DROP Exclui uma tabela inteira, uma visão de uma tabela ou outros objetos no banco de dados.

DML - linguagem de manipulação de dados

Sr. Não.	Comando e Descrição
1	SELECT Recupera certos registros de uma ou mais tabelas.
2	INSERT Cria um registro.
3	UPDATE Modifica registros.
4	DELETE Exclui registros.

DCL - Linguagem de Controle de Dados

Sr. Não.	Comando e Descrição
1	GRANT Dá um privilégio ao usuário.
2	REVOKE Recupera os privilégios concedidos pelo usuário.

O que é RDBMS?

RDBMS significa Relacional Database Mcompromisso Ssistema. O RDBMS é a base do SQL e de todos os sistemas de banco de dados modernos como MS SQL Server, IBM DB2, Oracle, MySQL e Microsoft Access.

Um sistema de gerenciamento de banco de dados relacional (RDBMS) é um sistema de gerenciamento de banco de dados (DBMS) que se baseia no modelo relacional introduzido por EF Codd.

O que é uma mesa?

Os dados em um RDBMS são armazenados em objetos de banco de dados que são chamados de tables. Esta tabela é basicamente uma coleção de entradas de dados relacionadas e consiste em várias colunas e linhas.

Lembre-se de que uma tabela é a forma mais comum e simples de armazenamento de dados em um banco de dados relacional. O programa a seguir é um exemplo de uma tabela CLIENTES -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

O que é um campo?

Cada tabela é dividida em entidades menores chamadas campos. Os campos da tabela CLIENTES consistem em ID, NOME, IDADE, ENDEREÇO e SALÁRIO.

Um campo é uma coluna em uma tabela projetada para manter informações específicas sobre cada registro na tabela.

O que é um registro ou uma linha?

Um registro também é chamado de linha de dados para cada entrada individual existente em uma tabela. Por exemplo, existem 7 registros na tabela CUSTOMERS acima. A seguir está uma única linha de dados ou registro na tabela CLIENTES -

+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Um registro é uma entidade horizontal em uma tabela.

O que é uma coluna?

Uma coluna é uma entidade vertical em uma tabela que contém todas as informações associadas a um campo específico em uma tabela.

Por exemplo, uma coluna na tabela CUSTOMERS é ADDRESS, que representa a descrição do local e seria como mostrado abaixo -

+-----------+
| ADDRESS   |
+-----------+
| Ahmedabad |
| Delhi     |
| Kota      |
| Mumbai    |
| Bhopal    |
| MP        |
| Indore    |
+----+------+

O que é um valor NULL?

Um valor NULL em uma tabela é um valor em um campo que parece estar em branco, o que significa que um campo com um valor NULL é um campo sem valor.

É muito importante entender que um valor NULL é diferente de um valor zero ou de um campo que contém espaços. Um campo com valor NULL é aquele que foi deixado em branco durante a criação de um registro.

Restrições SQL

As restrições são as regras aplicadas às colunas de dados de uma tabela. Eles são usados para limitar o tipo de dados que podem entrar em uma tabela. Isso garante a precisão e confiabilidade dos dados no banco de dados.

As restrições podem ser no nível da coluna ou no nível da tabela. As restrições de nível de coluna são aplicadas apenas a uma coluna, enquanto as restrições de nível de tabela são aplicadas a toda a tabela.

A seguir estão algumas das restrições mais comumente usadas disponíveis em SQL -

Restrição NOT NULL - Garante que uma coluna não pode ter um valor NULL.
Restrição DEFAULT - fornece um valor padrão para uma coluna quando nenhum é especificado.
Restrição UNIQUE - Garante que todos os valores em uma coluna sejam diferentes.
Chave PRIMÁRIA - Identifica exclusivamente cada linha / registro em uma tabela de banco de dados.
Chave FOREIGN - Identifica exclusivamente uma linha / registro em qualquer outra tabela do banco de dados.
Restrição CHECK - A restrição CHECK garante que todos os valores em uma coluna satisfaçam certas condições.
INDEX - Usado para criar e recuperar dados do banco de dados muito rapidamente.

Integridade de dados

As seguintes categorias de integridade de dados existem com cada RDBMS -

Entity Integrity − Não há linhas duplicadas em uma tabela.
Domain Integrity − Impõe entradas válidas para uma determinada coluna, restringindo o tipo, o formato ou o intervalo de valores.
Referential integrity − As linhas não podem ser excluídas, que são usadas por outros registros.
User-Defined Integrity − Aplica algumas regras de negócios específicas que não se enquadram na entidade, domínio ou integridade referencial.

Normalização de banco de dados

A normalização do banco de dados é o processo de organização eficiente dos dados em um banco de dados. Existem duas razões para este processo de normalização -

Eliminar dados redundantes, por exemplo, armazenar os mesmos dados em mais de uma tabela.
Garantir que as dependências de dados façam sentido.

Ambos os motivos são objetivos valiosos, pois reduzem a quantidade de espaço que um banco de dados consome e garantem que os dados sejam armazenados de forma lógica. A normalização consiste em uma série de diretrizes que ajudam a orientá-lo na criação de uma boa estrutura de banco de dados.

As diretrizes de normalização são divididas em formas normais; pense em um formulário como o formato ou a maneira como uma estrutura de banco de dados é apresentada. O objetivo dos formulários normais é organizar a estrutura do banco de dados, de modo que ela esteja de acordo com as regras da primeira forma normal, depois da segunda forma normal e, finalmente, da terceira forma normal.

É sua escolha ir mais longe e ir para a quarta forma normal, quinta forma normal e assim por diante, mas em geral, a terceira forma normal é mais do que suficiente.

Primeira forma normal (1NF)
Segunda forma normal (2NF)
Terceira forma normal (3NF)

Existem muitos RDBMS populares disponíveis para trabalhar. Este tutorial fornece uma breve visão geral de alguns dos RDBMSs mais populares. Isso ajudaria você a comparar seus recursos básicos.

MySQL

MySQL é um banco de dados SQL de código aberto, desenvolvido por uma empresa sueca - MySQL AB. MySQL é pronunciado como "my ess-que-ell", em contraste com SQL, pronunciado "sequel".

O MySQL oferece suporte a muitas plataformas diferentes, incluindo Microsoft Windows, as principais distribuições de Linux, UNIX e Mac OS X.

O MySQL tem versões gratuitas e pagas, dependendo de seu uso (não comercial / comercial) e recursos. O MySQL vem com um servidor de banco de dados SQL muito rápido, multi-threaded, multiusuário e robusto.

História

Desenvolvimento do MySQL por Michael Widenius & David Axmark começando em 1994.
Liberação interna pela primeira vez em 23 ^rd Maio de 1995.
Versão do Windows foi lançado em 8 ^th Janeiro de 1998 para Windows 95 e NT.
Versão 3.23: beta de junho de 2000, lançamento de produção em janeiro de 2001.
Versão 4.0: beta de agosto de 2002, lançamento de produção em março de 2003 (sindicatos).
Versão 4.1: beta de junho de 2004, lançamento de produção em outubro de 2004.
Versão 5.0: beta de março de 2005, lançamento de produção em outubro de 2005.
Sun Microsystems adquiriu a MySQL AB em 26 ^th Fevereiro de 2008.
Versão 5.1: versão de produção 27 ^th novembro de 2008.

Características

Alta performance.
Alta disponibilidade.
Escalabilidade e flexibilidade Execute qualquer coisa.
Suporte transacional robusto.
Pontos fortes da Web e do data warehouse.
Proteção forte de dados.
Desenvolvimento abrangente de aplicativos.
Facilidade de gerenciamento.
Liberdade de código aberto e suporte 24 horas por dia, 7 dias por semana.
Menor custo total de propriedade.

MS SQL Server

MS SQL Server é um sistema de gerenciamento de banco de dados relacional desenvolvido pela Microsoft Inc. Suas principais linguagens de consulta são -

T-SQL
ANSI SQL

História

1987 - Sybase lança o SQL Server para UNIX.
1988 - Microsoft, Sybase e Aston-Tate portam SQL Server para OS / 2.
1989 - Microsoft, Sybase e Aston-Tate lançam SQL Server 1.0 para OS / 2.
1990 - o SQL Server 1.1 é lançado com suporte para clientes Windows 3.0.
Aston-Tate sai do desenvolvimento do SQL Server.
2000 - A Microsoft lança o SQL Server 2000.
2001 - Microsoft lança XML para SQL Server Web Release 1 (download).
2002 - A Microsoft lança o SQLXML 2.0 (renomeado de XML para SQL Server).
2002 - A Microsoft lança o SQLXML 3.0.
2005 - A Microsoft lança o SQL Server 2005 em 7 de novembro de 2005.

Características

Alta performance
Alta disponibilidade
Espelhamento de banco de dados
Instantâneos de banco de dados
Integração CLR
Agente de Serviços
Gatilhos DDL
Funções de classificação
Níveis de isolamento baseados em versão de linha
Integração XML
TRY...CATCH
Database Mail

ORÁCULO

É um sistema de gerenciamento de banco de dados multiusuário muito grande. Oracle é um sistema de gerenciamento de banco de dados relacional desenvolvido pela 'Oracle Corporation'.

A Oracle trabalha para gerenciar de forma eficiente seus recursos, um banco de dados de informações entre os múltiplos clientes solicitando e enviando dados na rede.

É uma excelente escolha de servidor de banco de dados para computação cliente / servidor. A Oracle oferece suporte a todos os principais sistemas operacionais para clientes e servidores, incluindo MSDOS, NetWare, UnixWare, OS / 2 e a maioria dos tipos de UNIX.

História

A Oracle começou em 1977 e comemorando seus 32 anos maravilhosos no setor (de 1977 a 2009).

1977 - Larry Ellison, Bob Miner e Ed Oates fundaram Laboratórios de Desenvolvimento de Software para realizar o trabalho de desenvolvimento.
1979 - A versão 2.0 do Oracle foi lançada e tornou-se o primeiro banco de dados relacional comercial e o primeiro banco de dados SQL. A empresa mudou seu nome para Relational Software Inc. (RSI).
1981 - RSI começa a desenvolver ferramentas para Oracle.
1982 - RSI foi renomeado para Oracle Corporation.
1983 - a Oracle lançou a versão 3.0, reescrita em linguagem C e executada em várias plataformas.
1984 - o Oracle versão 4.0 foi lançado. Ele continha recursos como controle de simultaneidade - consistência de leitura de várias versões, etc.
1985 - o Oracle versão 4.0 foi lançado. Ele continha recursos como controle de simultaneidade - consistência de leitura de várias versões, etc.
2007 - a Oracle lançou o Oracle11g. A nova versão focada em melhor particionamento, fácil migração, etc.

Características

Concurrency
Consistência de leitura
Mecanismos de bloqueio
Banco de dados quiesce
Portability
Banco de dados de autogerenciamento
SQL*Plus
ASM
Scheduler
Gerente de Recursos
Armazenamento de dados
Vistas materializadas
Índices de bitmap
Compressão de mesa
Execução Paralela
SQL analítico
Mineração de dados
Partitioning

ACESSO MS

Este é um dos produtos mais populares da Microsoft. O Microsoft Access é um software de gerenciamento de banco de dados de nível básico. O banco de dados MS Access não é apenas barato, mas também um banco de dados poderoso para projetos de pequena escala.

O MS Access usa o mecanismo de banco de dados Jet, que utiliza um dialeto de linguagem SQL específico (às vezes chamado de Jet SQL).

O MS Access vem com a edição profissional do pacote MS Office. O MS Access possui interface gráfica intuitiva e fácil de usar.

1992 - o Access versão 1.0 foi lançado.
1993 - Access 1.1 lançado para melhorar a compatibilidade com a inclusão da linguagem de programação Access Basic.
A transição mais significativa foi do Access 97 para o Access 2000.
2007 - Access 2007, um novo formato de banco de dados foi introduzido ACCDB que oferece suporte a tipos de dados complexos, como campos de vários valores e anexos.

Características

Os usuários podem criar tabelas, consultas, formulários e relatórios e conectá-los com macros.
Opção de importar e exportar os dados para vários formatos incluindo Excel, Outlook, ASCII, dBase, Paradox, FoxPro, SQL Server, Oracle, ODBC, etc.
Há também o formato Jet Database (MDB ou ACCDB no Access 2007), que pode conter o aplicativo e os dados em um arquivo. Isso torna muito conveniente distribuir o aplicativo inteiro para outro usuário, que pode executá-lo em ambientes desconectados.
O Microsoft Access oferece consultas parametrizadas. Essas consultas e tabelas de acesso podem ser referenciadas a partir de outros programas como VB6 e .NET por meio de DAO ou ADO.
As edições de desktop do Microsoft SQL Server podem ser usadas com o Access como uma alternativa ao Jet Database Engine.
O Microsoft Access é um banco de dados baseado em servidor de arquivos. Ao contrário dos sistemas de gerenciamento de banco de dados relacional cliente-servidor (RDBMS), o Microsoft Access não implementa gatilhos de banco de dados, procedimentos armazenados ou registro de transações.

SQL - Sintaxe

O SQL é seguido por um conjunto exclusivo de regras e diretrizes denominado Sintaxe. Este tutorial fornece um início rápido com SQL, listando toda a sintaxe SQL básica.

Todas as instruções SQL começam com qualquer uma das palavras-chave como SELECT, INSERT, UPDATE, DELETE, ALTER, DROP, CREATE, USE, SHOW e todas as instruções terminam com um ponto e vírgula (;).

O ponto mais importante a ser observado aqui é que o SQL não faz distinção entre maiúsculas e minúsculas, o que significa que SELECT e select têm o mesmo significado nas instruções SQL. Visto que o MySQL faz diferença nos nomes das tabelas. Portanto, se você estiver trabalhando com MySQL, será necessário fornecer nomes de tabelas conforme existem no banco de dados.

Várias sintaxes em SQL

Todos os exemplos fornecidos neste tutorial foram testados com um servidor MySQL.

Instrução SQL SELECT

SELECT column1, column2....columnN
FROM   table_name;

Cláusula SQL DISTINCT

SELECT DISTINCT column1, column2....columnN
FROM   table_name;

Cláusula SQL WHERE

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION;

Cláusula SQL AND / OR

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION-1 {AND|OR} CONDITION-2;

Cláusula SQL IN

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name IN (val-1, val-2,...val-N);

Cláusula SQL BETWEEN

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name BETWEEN val-1 AND val-2;

Cláusula SQL LIKE

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name LIKE { PATTERN };

Cláusula SQL ORDER BY

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION
ORDER BY column_name {ASC|DESC};

Cláusula SQL GROUP BY

SELECT SUM(column_name)
FROM   table_name
WHERE  CONDITION
GROUP BY column_name;

Cláusula SQL COUNT

SELECT COUNT(column_name)
FROM   table_name
WHERE  CONDITION;

Cláusula SQL HAVING

SELECT SUM(column_name)
FROM   table_name
WHERE  CONDITION
GROUP BY column_name
HAVING (arithematic function condition);

Instrução SQL CREATE TABLE

CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);

Instrução SQL DROP TABLE

DROP TABLE table_name;

Instrução SQL CREATE INDEX

CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);

Instrução SQL DROP INDEX

ALTER TABLE table_name
DROP INDEX index_name;

Instrução SQL DESC

DESC table_name;

Instrução SQL TRUNCATE TABLE

TRUNCATE TABLE table_name;

Instrução SQL ALTER TABLE

ALTER TABLE table_name {ADD|DROP|MODIFY} column_name {data_ype};

Instrução SQL ALTER TABLE (Renomear)

ALTER TABLE table_name RENAME TO new_table_name;

Instrução SQL INSERT INTO

INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);

Instrução SQL UPDATE

UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE  CONDITION ];

Instrução SQL DELETE

DELETE FROM table_name
WHERE  {CONDITION};

Instrução SQL CREATE DATABASE

CREATE DATABASE database_name;

Instrução SQL DROP DATABASE

DROP DATABASE database_name;

Instrução SQL USE

USE database_name;

Instrução SQL COMMIT

COMMIT;

Instrução SQL ROLLBACK

ROLLBACK;

SQL - Tipos de dados

Tipo de dados SQL é um atributo que especifica o tipo de dados de qualquer objeto. Cada coluna, variável e expressão possui um tipo de dados relacionado em SQL. Você pode usar esses tipos de dados ao criar suas tabelas. Você pode escolher um tipo de dados para uma coluna da tabela com base em seus requisitos.

O SQL Server oferece seis categorias de tipos de dados para seu uso, listados abaixo -

Tipos de dados numéricos exatos

TIPO DE DADOS	DE	PARA
bigint	-9.223.372.036.854.775.808	9.223.372.036.854.775.807
int	-2.147.483.648	2.147.483.647
smallint	-32.768	32.767
tinyint	0	255
mordeu	0	1
decimal	-10 ^ 38 +1	10 ^ 38 -1
numérico	-10 ^ 38 +1	10 ^ 38 -1
dinheiro	-922.337.203.685.477.5808	+922.337.203.685.477.5807
dinheirinho	-214.748,3648	+214.748.3647

Tipos de dados numéricos aproximados

TIPO DE DADOS	DE	PARA
flutuador	-1,79E + 308	1,79E + 308
real	-3,40E + 38	3,40E + 38

Tipos de dados de data e hora

TIPO DE DADOS	DE	PARA
data hora	1º de janeiro de 1753	31 de dezembro de 9999
smalldatetime	1º de janeiro de 1900	6 de junho de 2079
encontro	Armazena uma data como 30 de junho de 1991
Tempo	Armazena uma hora do dia como 12h30

Note - Aqui, datetime tem precisão de 3,33 milissegundos, enquanto smalldatetime tem precisão de 1 minuto.

Tipos de dados de strings de caracteres

Sr. Não.	TIPO DE DADOS e descrição
1	char Comprimento máximo de 8.000 caracteres (caracteres não Unicode de comprimento fixo)
2	varchar Máximo de 8.000 caracteres (dados não Unicode de comprimento variável).
3	varchar(max) Comprimento máximo de 2E + 31 caracteres, dados não Unicode de comprimento variável (somente SQL Server 2005).
4	text Dados não Unicode de comprimento variável com comprimento máximo de 2.147.483.647 caracteres.

Tipos de dados de strings de caracteres Unicode

Sr. Não.	TIPO DE DADOS e descrição
1	nchar Comprimento máximo de 4.000 caracteres. (Unicode de comprimento fixo)
2	nvarchar Comprimento máximo de 4.000 caracteres. (Unicode de comprimento variável)
3	nvarchar(max) Comprimento máximo de 2E + 31 caracteres (somente SQL Server 2005). (Unicode de comprimento variável)
4	ntext Comprimento máximo de 1.073.741.823 caracteres. (Unicode de comprimento variável)

Tipos de dados binários

Sr. Não.	TIPO DE DADOS e descrição
1	binary Comprimento máximo de 8.000 bytes (dados binários de comprimento fixo)
2	varbinary Comprimento máximo de 8.000 bytes. (Dados binários de comprimento variável)
3	varbinary(max) Comprimento máximo de 2E + 31 bytes (somente SQL Server 2005). (Dados binários de comprimento variável)
4	image Comprimento máximo de 2.147.483.647 bytes. (Dados binários de comprimento variável)

Tipos de dados diversos

Sr. Não.	TIPO DE DADOS e descrição
1	sql_variant Armazena valores de vários tipos de dados com suporte do SQL Server, exceto text, ntext e timestamp.
2	timestamp Armazena um número exclusivo em todo o banco de dados que é atualizado toda vez que uma linha é atualizada
3	uniqueidentifier Armazena um identificador globalmente exclusivo (GUID)
4	xml Armazena dados XML. Você pode armazenar instâncias xml em uma coluna ou variável (somente SQL Server 2005).
5	cursor Referência a um objeto cursor
6	table Armazena um conjunto de resultados para processamento posterior

SQL - Operadores

O que é um operador em SQL?

Um operador é uma palavra reservada ou um caractere usado principalmente na cláusula WHERE de uma instrução SQL para realizar operação (ões), como comparações e operações aritméticas. Esses operadores são usados para especificar condições em uma instrução SQL e servir como conjunções para várias condições em uma instrução.

Operadores aritméticos
Operadores de comparação
Operadores lógicos
Operadores costumavam negar condições

Operadores aritméticos SQL

Presumir 'variable a' detém 10 e 'variable b' contém 20, então -

Mostrar exemplos

Operador	Descrição	Exemplo
+ (Adição)	Adiciona valores em qualquer lado do operador.	a + b dará 30
- (Subtração)	Subtrai o operando direito do operando esquerdo.	a - b dará -10
* (Multiplicação)	Multiplica os valores em ambos os lados do operador.	a * b dará 200
/ (Divisão)	Divide operando esquerdo pelo operando direito.	b / a dará 2
% (Módulo)	Divide o operando esquerdo pelo operando direito e retorna o resto.	b% a dará 0

Operadores de comparação SQL

Presumir 'variable a' detém 10 e 'variable b' contém 20, então -

Mostrar exemplos

Operador	Descrição	Exemplo
=	Verifica se os valores dos dois operandos são iguais ou não, se sim a condição torna-se verdadeira.	(a = b) não é verdade.
! =	Verifica se os valores de dois operandos são iguais ou não; se os valores não são iguais, a condição se torna verdadeira.	(a! = b) é verdade.
<>	Verifica se os valores de dois operandos são iguais ou não; se os valores não são iguais, a condição se torna verdadeira.	(a <> b) é verdadeiro.
>	Verifica se o valor do operando esquerdo é maior que o valor do operando direito, se sim, a condição torna-se verdadeira.	(a> b) não é verdade.
<	Verifica se o valor do operando esquerdo é menor que o valor do operando direito; se sim, a condição torna-se verdadeira.	(a <b) é verdade.
> =	Verifica se o valor do operando esquerdo é maior ou igual ao valor do operando direito, se sim a condição torna-se verdadeira.	(a> = b) não é verdade.
<=	Verifica se o valor do operando esquerdo é menor ou igual ao valor do operando direito, se sim a condição torna-se verdadeira.	(a <= b) é verdadeiro.
! <	Verifica se o valor do operando esquerdo não é menor que o valor do operando direito; se sim, a condição torna-se verdadeira.	(a! <b) é falso.
!>	Verifica se o valor do operando esquerdo não é maior que o valor do operando direito, se sim a condição torna-se verdadeira.	(a!> b) é verdade.

Operadores lógicos SQL

Aqui está uma lista de todos os operadores lógicos disponíveis no SQL.

Mostrar exemplos

Sr. Não.	Operador e descrição
1	ALL O operador ALL é usado para comparar um valor a todos os valores em outro conjunto de valores.
2	AND O operador AND permite a existência de várias condições na cláusula WHERE de uma instrução SQL.
3	ANY O operador ANY é usado para comparar um valor a qualquer valor aplicável na lista de acordo com a condição.
4	BETWEEN O operador BETWEEN é usado para pesquisar valores que estão dentro de um conjunto de valores, dados o valor mínimo e o valor máximo.
5	EXISTS O operador EXISTS é usado para pesquisar a presença de uma linha em uma tabela especificada que atenda a um determinado critério.
6	IN O operador IN é usado para comparar um valor a uma lista de valores literais que foram especificados.
7	LIKE O operador LIKE é usado para comparar um valor a valores semelhantes usando operadores curinga.
8	NOT O operador NOT inverte o significado do operador lógico com o qual é usado. Ex: NÃO EXISTE, NÃO ENTRE, NÃO ENTRE, etc.This is a negate operator.
9	OR O operador OR é usado para combinar várias condições na cláusula WHERE de uma instrução SQL.
10	IS NULL O operador NULL é usado para comparar um valor com um valor NULL.
11	UNIQUE O operador UNIQUE pesquisa cada linha de uma tabela especificada em busca de exclusividade (sem duplicatas).

SQL - Expressões

Uma expressão é uma combinação de um ou mais valores, operadores e funções SQL que avaliam um valor. Essas EXPRESSÕES SQL são como fórmulas e são escritas em linguagem de consulta. Você também pode usá-los para consultar o banco de dados em busca de um conjunto específico de dados.

Sintaxe

Considere a sintaxe básica da instrução SELECT da seguinte maneira -

SELECT column1, column2, columnN 
FROM table_name 
WHERE [CONDITION|EXPRESSION];

Existem diferentes tipos de expressões SQL, que são mencionados abaixo -

Boolean
Numeric
Date

Vamos agora discutir cada um deles em detalhes.

Expressões Booleanas

As expressões booleanas SQL buscam os dados com base na correspondência de um único valor. A seguir está a sintaxe -

SELECT column1, column2, columnN 
FROM table_name 
WHERE SINGLE VALUE MATCHING EXPRESSION;

Considere a tabela CLIENTES com os seguintes registros -

SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+
7 rows in set (0.00 sec)

A tabela a seguir é um exemplo simples que mostra o uso de várias expressões booleanas SQL -

SQL> SELECT * FROM CUSTOMERS WHERE SALARY = 10000;
+----+-------+-----+---------+----------+
| ID | NAME  | AGE | ADDRESS | SALARY   |
+----+-------+-----+---------+----------+
|  7 | Muffy |  24 | Indore  | 10000.00 |
+----+-------+-----+---------+----------+
1 row in set (0.00 sec)

Expressão Numérica

Essas expressões são usadas para realizar qualquer operação matemática em qualquer consulta. A seguir está a sintaxe -

SELECT numerical_expression as  OPERATION_NAME
[FROM table_name
WHERE CONDITION] ;

Aqui, a numerical_expression é usada para uma expressão matemática ou qualquer fórmula. A seguir está um exemplo simples que mostra o uso de Expressões Numéricas SQL -

SQL> SELECT (15 + 6) AS ADDITION
+----------+
| ADDITION |
+----------+
|       21 |
+----------+
1 row in set (0.00 sec)

Existem várias funções integradas, como avg (), sum (), count (), etc., para realizar o que é conhecido como cálculos de dados agregados em uma tabela ou coluna específica da tabela.

SQL> SELECT COUNT(*) AS "RECORDS" FROM CUSTOMERS; 
+---------+
| RECORDS |
+---------+
|       7 |
+---------+
1 row in set (0.00 sec)

Expressões de data

As expressões de data retornam os valores atuais de data e hora do sistema -

SQL>  SELECT CURRENT_TIMESTAMP;
+---------------------+
| Current_Timestamp   |
+---------------------+
| 2009-11-12 06:40:23 |
+---------------------+
1 row in set (0.00 sec)

Outra expressão de data é mostrada abaixo -

SQL>  SELECT  GETDATE();;
+-------------------------+
| GETDATE                 |
+-------------------------+
| 2009-10-22 12:07:18.140 |
+-------------------------+
1 row in set (0.00 sec)

SQL - CREATE Database

O SQL CREATE DATABASE instrução é usada para criar um novo banco de dados SQL.

Sintaxe

A sintaxe básica desta instrução CREATE DATABASE é a seguinte -

CREATE DATABASE DatabaseName;

Sempre o nome do banco de dados deve ser exclusivo no RDBMS.

Exemplo

Se você deseja criar um novo banco de dados <testDB>, então a instrução CREATE DATABASE seria como mostrado abaixo -

SQL> CREATE DATABASE testDB;

Certifique-se de ter privilégios de administrador antes de criar qualquer banco de dados. Depois que um banco de dados é criado, você pode verificá-lo na lista de bancos de dados da seguinte forma -

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
| testDB             |
+--------------------+
7 rows in set (0.00 sec)

SQL - banco de dados DROP ou DELETE

O SQL DROP DATABASE instrução é usada para descartar um banco de dados existente no esquema SQL.

Sintaxe

A sintaxe básica da instrução DROP DATABASE é a seguinte -

DROP DATABASE DatabaseName;

Sempre o nome do banco de dados deve ser exclusivo no RDBMS.

Exemplo

Se você deseja excluir um banco de dados existente <testDB>, então a instrução DROP DATABASE seria como mostrado abaixo -

SQL> DROP DATABASE testDB;

NOTE - Tenha cuidado antes de usar esta operação porque a exclusão de um banco de dados existente resultaria na perda de todas as informações armazenadas no banco de dados.

Certifique-se de ter o privilégio de administrador antes de eliminar qualquer banco de dados. Depois que um banco de dados é eliminado, você pode verificá-lo na lista de bancos de dados conforme mostrado abaixo -

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
+--------------------+
6 rows in set (0.00 sec)

SQL - banco de dados SELECT, instrução USE

Quando você tem vários bancos de dados em seu Esquema SQL, antes de iniciar sua operação, você precisa selecionar um banco de dados onde todas as operações seriam realizadas.

O SQL USE instrução é usada para selecionar qualquer banco de dados existente no esquema SQL.

Sintaxe

A sintaxe básica da instrução USE é mostrada abaixo -

USE DatabaseName;

Sempre o nome do banco de dados deve ser exclusivo no RDBMS.

Exemplo

Você pode verificar os bancos de dados disponíveis conforme mostrado abaixo -

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
+--------------------+
6 rows in set (0.00 sec)

Agora, se você deseja trabalhar com o banco de dados AMROOD, pode executar o seguinte comando SQL e começar a trabalhar com o banco de dados AMROOD.

SQL> USE AMROOD;

SQL - Tabela CREATE

Criar uma tabela básica envolve nomear a tabela e definir suas colunas e o tipo de dados de cada coluna.

O SQL CREATE TABLE instrução é usada para criar uma nova tabela.

Sintaxe

A sintaxe básica da instrução CREATE TABLE é a seguinte -

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
   PRIMARY KEY( one or more columns )
);

CREATE TABLE é a palavra-chave que diz ao sistema de banco de dados o que você deseja fazer. Neste caso, você deseja criar uma nova tabela. O nome ou identificador exclusivo da tabela segue a instrução CREATE TABLE.

Em seguida, entre colchetes, vem a lista que define cada coluna na tabela e que tipo de tipo de dados é. A sintaxe fica mais clara com o exemplo a seguir.

Uma cópia de uma tabela existente pode ser criada usando uma combinação da instrução CREATE TABLE e da instrução SELECT. Você pode verificar os detalhes completos em Criar tabela usando outra tabela.

Exemplo

O bloco de código a seguir é um exemplo, que cria uma tabela CUSTOMERS com um ID como chave primária e NOT NULL são as restrições que mostram que esses campos não podem ser NULL durante a criação de registros nesta tabela -

SQL> CREATE TABLE CUSTOMERS(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25) ,
   SALARY   DECIMAL (18, 2),       
   PRIMARY KEY (ID)
);

Você pode verificar se sua tabela foi criada com sucesso olhando a mensagem exibida pelo servidor SQL, caso contrário, você pode usar o DESC comando da seguinte forma -

SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field   | Type          | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID      | int(11)       | NO   | PRI |         |       |
| NAME    | varchar(20)   | NO   |     |         |       |
| AGE     | int(11)       | NO   |     |         |       |
| ADDRESS | char(25)      | YES  |     | NULL    |       |
| SALARY  | decimal(18,2) | YES  |     | NULL    |       |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)

Agora, você tem a tabela CLIENTES disponível em seu banco de dados, que pode ser usada para armazenar as informações necessárias relacionadas aos clientes.

SQL - Tabela DROP ou DELETE

O SQL DROP TABLE instrução é usada para remover uma definição de tabela e todos os dados, índices, gatilhos, restrições e especificações de permissão para essa tabela.

NOTE - Você deve ter muito cuidado ao usar este comando porque uma vez que uma tabela é excluída, todas as informações disponíveis nessa tabela também serão perdidas para sempre.

Sintaxe

A sintaxe básica desta instrução DROP TABLE é a seguinte -

DROP TABLE table_name;

Exemplo

Vamos primeiro verificar a tabela CLIENTES e, em seguida, vamos excluí-la do banco de dados como mostrado abaixo -

SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field   | Type          | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID      | int(11)       | NO   | PRI |         |       |
| NAME    | varchar(20)   | NO   |     |         |       |
| AGE     | int(11)       | NO   |     |         |       |
| ADDRESS | char(25)      | YES  |     | NULL    |       |
| SALARY  | decimal(18,2) | YES  |     | NULL    |       |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)

Isso significa que a tabela CUSTOMERS está disponível no banco de dados, portanto, vamos eliminá-la conforme mostrado abaixo.

SQL> DROP TABLE CUSTOMERS;
Query OK, 0 rows affected (0.01 sec)

Agora, se você tentar o comando DESC, obterá o seguinte erro -

SQL> DESC CUSTOMERS;
ERROR 1146 (42S02): Table 'TEST.CUSTOMERS' doesn't exist

Aqui, TEST é o nome do banco de dados que estamos usando para nossos exemplos.

SQL - INSERT Query

O SQL INSERT INTO A instrução é usada para adicionar novas linhas de dados a uma tabela no banco de dados.

Sintaxe

Existem duas sintaxes básicas da instrução INSERT INTO que são mostradas abaixo.

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)  
VALUES (value1, value2, value3,...valueN);

Aqui, coluna1, coluna2, coluna3, ... colunaN são os nomes das colunas na tabela na qual você deseja inserir os dados.

Você pode não precisar especificar o (s) nome (s) da (s) coluna (s) na consulta SQL se estiver adicionando valores para todas as colunas da tabela. Mas certifique-se de que a ordem dos valores está na mesma ordem das colunas da tabela.

o SQL INSERT INTO a sintaxe será a seguinte -

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

Exemplo

As instruções a seguir criariam seis registros na tabela CUSTOMERS.

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Khilan', 25, 'Delhi', 1500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'kaushik', 23, 'Kota', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Chaitali', 25, 'Mumbai', 6500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'Hardik', 27, 'Bhopal', 8500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Komal', 22, 'MP', 4500.00 );

Você pode criar um registro na tabela CLIENTES usando a segunda sintaxe conforme mostrado abaixo.

INSERT INTO CUSTOMERS 
VALUES (7, 'Muffy', 24, 'Indore', 10000.00 );

Todas as instruções acima produziriam os seguintes registros na tabela CLIENTES, conforme mostrado abaixo.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Preencher uma tabela usando outra tabela

Você pode preencher os dados em uma tabela por meio da instrução select sobre outra tabela; desde que a outra tabela tenha um conjunto de campos, que são necessários para preencher a primeira tabela.

Aqui está a sintaxe -

INSERT INTO first_table_name [(column1, column2, ... columnN)] 
   SELECT column1, column2, ...columnN 
   FROM second_table_name
   [WHERE condition];

SQL - consulta SELECT

O SQL SELECTinstrução é usada para buscar os dados de uma tabela de banco de dados que retorna esses dados na forma de uma tabela de resultados. Essas tabelas de resultados são chamadas de conjuntos de resultados.

Sintaxe

A sintaxe básica da instrução SELECT é a seguinte -

SELECT column1, column2, columnN FROM table_name;

Aqui, coluna1, coluna2 ... são os campos de uma tabela cujos valores você deseja buscar. Se você deseja buscar todos os campos disponíveis no campo, você pode usar a seguinte sintaxe.

SELECT * FROM table_name;

Exemplo

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

O código a seguir é um exemplo, que buscaria os campos ID, Nome e Salário dos clientes disponíveis na tabela CLIENTES.

SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS;

Isso produziria o seguinte resultado -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  1 | Ramesh   |  2000.00 |
|  2 | Khilan   |  1500.00 |
|  3 | kaushik  |  2000.00 |
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

Se você deseja buscar todos os campos da tabela CLIENTES, deve usar a seguinte consulta.

SQL> SELECT * FROM CUSTOMERS;

Isso produziria o resultado mostrado abaixo.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

SQL - Cláusula WHERE

O SQL WHEREA cláusula é usada para especificar uma condição ao buscar os dados de uma única tabela ou unindo-se a várias tabelas. Se a condição fornecida for satisfeita, apenas ele retornará um valor específico da tabela. Você deve usar a cláusula WHERE para filtrar os registros e buscar apenas os registros necessários.

A cláusula WHERE não é usada apenas na instrução SELECT, mas também na instrução UPDATE, DELETE, etc., que examinaremos nos capítulos subsequentes.

Sintaxe

A sintaxe básica da instrução SELECT com a cláusula WHERE é mostrada a seguir.

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition]

Você pode especificar uma condição usando a comparação ou operadores lógicos como>, <, =,LIKE, NOT, etc. Os exemplos a seguir tornariam esse conceito claro.

Exemplo

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

O código a seguir é um exemplo que buscaria os campos ID, Nome e Salário da tabela CLIENTES, onde o salário é maior que 2.000 -

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000;

Isso produziria o seguinte resultado -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

A consulta a seguir é um exemplo, que buscaria os campos ID, Nome e Salário da tabela CLIENTES para um cliente com o nome Hardik.

Aqui, é importante observar que todas as strings devem ser fornecidas entre aspas simples (''). Considerando que, os valores numéricos devem ser fornecidos sem qualquer aspas, como no exemplo acima.

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE NAME = 'Hardik';

Isso produziria o seguinte resultado -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  5 | Hardik   |  8500.00 |
+----+----------+----------+

SQL - Operadores Conjuntivos AND e OR

O SQL AND E ORoperadores são usados para combinar várias condições para restringir os dados em uma instrução SQL. Esses dois operadores são chamados de operadores conjuntivos.

Esses operadores fornecem um meio de fazer várias comparações com diferentes operadores na mesma instrução SQL.

O operador AND

o AND operador permite a existência de várias condições na cláusula WHERE de uma instrução SQL.

Sintaxe

A sintaxe básica do operador AND com uma cláusula WHERE é a seguinte -

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

Você pode combinar um número N de condições usando o operador AND. Para que uma ação seja executada pela instrução SQL, seja uma transação ou uma consulta, todas as condições separadas por AND devem ser TRUE.

Exemplo

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

A seguir está um exemplo, que buscaria os campos ID, Nome e Salário da tabela CLIENTES, onde o salário é maior que 2.000 e a idade é menor que 25 anos -

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000 AND age < 25;

Isso produziria o seguinte resultado -

+----+-------+----------+
| ID | NAME  | SALARY   |
+----+-------+----------+
|  6 | Komal |  4500.00 |
|  7 | Muffy | 10000.00 |
+----+-------+----------+

O operador OR

O operador OR é usado para combinar várias condições na cláusula WHERE de uma instrução SQL.

Sintaxe

A sintaxe básica do operador OR com uma cláusula WHERE é a seguinte -

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]

Você pode combinar N número de condições usando o operador OR. Para que uma ação seja realizada pela instrução SQL, seja uma transação ou consulta, a única qualquer uma das condições separadas por OR deve ser TRUE.

Exemplo

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

O bloco de código a seguir tem uma consulta, que buscaria os campos ID, Nome e Salário da tabela CLIENTES, onde o salário é maior que 2.000 OU a idade é menor que 25 anos.

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000 OR age < 25;

Isso produziria o seguinte resultado -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  3 | kaushik  |  2000.00 |
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

SQL - UPDATE Query

O SQL UPDATEA consulta é usada para modificar os registros existentes em uma tabela. Você pode usar a cláusula WHERE com a consulta UPDATE para atualizar as linhas selecionadas, caso contrário, todas as linhas seriam afetadas.

Sintaxe

A sintaxe básica da consulta UPDATE com uma cláusula WHERE é a seguinte -

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

Você pode combinar um número N de condições usando os operadores AND ou OR.

Exemplo

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

A consulta a seguir atualizará o ENDEREÇO para um cliente cujo número de ID é 6 na tabela.

SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune'
WHERE ID = 6;

Agora, a tabela CUSTOMERS teria os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | Pune      |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Se você deseja modificar todos os valores das colunas ADDRESS e SALARY na tabela CUSTOMERS, não é necessário usar a cláusula WHERE, pois a consulta UPDATE seria suficiente, conforme mostrado no bloco de código a seguir.

SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune', SALARY = 1000.00;

Agora, a tabela CUSTOMERS teria os seguintes registros -

+----+----------+-----+---------+---------+
| ID | NAME     | AGE | ADDRESS | SALARY  |
+----+----------+-----+---------+---------+
|  1 | Ramesh   |  32 | Pune    | 1000.00 |
|  2 | Khilan   |  25 | Pune    | 1000.00 |
|  3 | kaushik  |  23 | Pune    | 1000.00 |
|  4 | Chaitali |  25 | Pune    | 1000.00 |
|  5 | Hardik   |  27 | Pune    | 1000.00 |
|  6 | Komal    |  22 | Pune    | 1000.00 |
|  7 | Muffy    |  24 | Pune    | 1000.00 |
+----+----------+-----+---------+---------+

SQL - Consulta DELETE

A consulta SQL DELETE é usada para excluir os registros existentes de uma tabela.

Você pode usar a cláusula WHERE com uma consulta DELETE para excluir as linhas selecionadas, caso contrário, todos os registros seriam excluídos.

Sintaxe

A sintaxe básica da consulta DELETE com a cláusula WHERE é a seguinte -

DELETE FROM table_name
WHERE [condition];

Você pode combinar um número N de condições usando os operadores AND ou OR.

Exemplo

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

O código a seguir contém uma consulta, que EXCLUIRÁ um cliente, cujo ID é 6.

SQL> DELETE FROM CUSTOMERS
WHERE ID = 6;

Agora, a tabela CUSTOMERS teria os seguintes registros.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Se você deseja DELETE todos os registros da tabela CUSTOMERS, você não precisa usar a cláusula WHERE e a consulta DELETE seria a seguinte -

SQL> DELETE FROM CUSTOMERS;

Agora, a tabela CUSTOMERS não teria nenhum registro.

SQL - cláusula LIKE

O SQL LIKEcláusula é usada para comparar um valor a valores semelhantes usando operadores curinga. Existem dois curingas usados em conjunto com o operador LIKE.

O sinal de porcentagem (%)
O sublinhado (_)

O sinal de porcentagem representa zero, um ou vários caracteres. O sublinhado representa um único número ou caractere. Esses símbolos podem ser usados em combinações.

Sintaxe

A sintaxe básica de% e _ é a seguinte -

SELECT FROM table_name
WHERE column LIKE 'XXXX%'

or 

SELECT FROM table_name
WHERE column LIKE '%XXXX%'

or

SELECT FROM table_name
WHERE column LIKE 'XXXX_'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX_'

Você pode combinar um número N de condições usando os operadores AND ou OR. Aqui, XXXX pode ser qualquer valor numérico ou string.

Exemplo

A tabela a seguir tem alguns exemplos que mostram a parte WHERE com cláusulas LIKE diferentes com os operadores '%' e '_' -

Sr. Não.	Declaração e descrição
1	WHERE SALARY LIKE '200%' Encontra todos os valores que começam com 200.
2	WHERE SALARY LIKE '%200%' Encontra qualquer valor que tenha 200 em qualquer posição.
3	WHERE SALARY LIKE '_00%' Encontra qualquer valor que tenha 00 na segunda e na terceira posições.
4	WHERE SALARY LIKE '2_%_%' Encontra qualquer valor que comece com 2 e tenha pelo menos 3 caracteres de comprimento.
5	WHERE SALARY LIKE '%2' Encontra qualquer valor que termine com 2.
6	WHERE SALARY LIKE '_2%3' Encontra qualquer valor que tenha 2 na segunda posição e termine com 3.
7	WHERE SALARY LIKE '2___3' Encontra qualquer valor em um número de cinco dígitos que começa com 2 e termina com 3.

Tomemos um exemplo real, considere a tabela CLIENTES com os registros conforme mostrado abaixo.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

A seguir está um exemplo, que exibiria todos os registros da tabela CUSTOMERS, onde o SALÁRIO começa com 200.

SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

Isso produziria o seguinte resultado -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
+----+----------+-----+-----------+----------+

SQL - cláusula TOP, LIMIT ou ROWNUM

O SQL TOP A cláusula é usada para buscar um número TOP N ou registros de X por cento de uma tabela.

Note- Todos os bancos de dados não suportam a cláusula TOP. Por exemplo, o MySQL suporta oLIMIT cláusula para buscar um número limitado de registros enquanto o Oracle usa o ROWNUM comando para buscar um número limitado de registros.

Sintaxe

A sintaxe básica da cláusula TOP com uma instrução SELECT seria a seguinte.

SELECT TOP number|percent column_name(s)
FROM table_name
WHERE [condition]

Exemplo

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

A consulta a seguir é um exemplo no servidor SQL, que buscaria os 3 principais registros da tabela CUSTOMERS.

SQL> SELECT TOP 3 * FROM CUSTOMERS;

Isso produziria o seguinte resultado -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

Se você estiver usando o servidor MySQL, aqui está um exemplo equivalente -

SQL> SELECT * FROM CUSTOMERS
LIMIT 3;

Isso produziria o seguinte resultado -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

Se você estiver usando um servidor Oracle, o bloco de código a seguir terá um exemplo equivalente.

SQL> SELECT * FROM CUSTOMERS
WHERE ROWNUM <= 3;

Isso produziria o seguinte resultado -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

SQL - cláusula ORDER BY

O SQL ORDER BYcláusula é usada para classificar os dados em ordem crescente ou decrescente, com base em uma ou mais colunas. Alguns bancos de dados classificam os resultados da consulta em ordem crescente por padrão.

Sintaxe

A sintaxe básica da cláusula ORDER BY é a seguinte -

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

Você pode usar mais de uma coluna na cláusula ORDER BY. Certifique-se de que qualquer coluna que você está usando para classificar essa coluna deve estar na lista de colunas.

Exemplo

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

O bloco de código a seguir tem um exemplo, que classificaria o resultado em ordem crescente por NOME e SALÁRIO -

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME, SALARY;

Isso produziria o seguinte resultado -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

O bloco de código a seguir tem um exemplo, que classificaria o resultado em ordem decrescente por NAME.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME DESC;

Isso produziria o seguinte resultado -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+----+----------+-----+-----------+----------+

SQL - Grupo por

O SQL GROUP BYcláusula é usada em colaboração com a instrução SELECT para organizar dados idênticos em grupos. Esta cláusula GROUP BY segue a cláusula WHERE em uma instrução SELECT e precede a cláusula ORDER BY.

Sintaxe

A sintaxe básica de uma cláusula GROUP BY é mostrada no bloco de código a seguir. A cláusula GROUP BY deve seguir as condições da cláusula WHERE e deve preceder a cláusula ORDER BY, se uma for usada.

SELECT column1, column2
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2
ORDER BY column1, column2

Exemplo

Considere que a tabela CUSTOMERS tem os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Se você quiser saber o valor total do salário de cada cliente, a consulta GROUP BY seria a seguinte.

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
   GROUP BY NAME;

Isso produziria o seguinte resultado -

+----------+-------------+
| NAME     | SUM(SALARY) |
+----------+-------------+
| Chaitali |     6500.00 |
| Hardik   |     8500.00 |
| kaushik  |     2000.00 |
| Khilan   |     1500.00 |
| Komal    |     4500.00 |
| Muffy    |    10000.00 |
| Ramesh   |     2000.00 |
+----------+-------------+

Agora, vamos olhar para uma tabela onde a tabela CUSTOMERS tem os seguintes registros com nomes duplicados -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Ramesh   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | kaushik  |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Agora, novamente, se você quiser saber o valor total do salário de cada cliente, a consulta GROUP BY seria a seguinte -

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
   GROUP BY NAME;

Isso produziria o seguinte resultado -

+---------+-------------+
| NAME    | SUM(SALARY) |
+---------+-------------+
| Hardik  |     8500.00 |
| kaushik |     8500.00 |
| Komal   |     4500.00 |
| Muffy   |    10000.00 |
| Ramesh  |     3500.00 |
+---------+-------------+

SQL - palavra-chave distinta

O SQL DISTINCT palavra-chave é usada em conjunto com a instrução SELECT para eliminar todos os registros duplicados e buscar apenas registros únicos.

Pode haver uma situação em que você tenha vários registros duplicados em uma tabela. Ao buscar esses registros, faz mais sentido buscar apenas aqueles registros únicos em vez de buscar registros duplicados.

Sintaxe

A sintaxe básica da palavra-chave DISTINCT para eliminar os registros duplicados é a seguinte -

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

Exemplo

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Primeiro, vamos ver como a consulta SELECT a seguir retorna os registros de salário duplicados.

SQL> SELECT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Isso produziria o seguinte resultado, onde o salário (2000) vem duas vezes, o que é um registro duplicado da tabela original.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

Agora, vamos usar a palavra-chave DISTINCT com a consulta SELECT acima e ver o resultado.

SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Isso produziria o seguinte resultado, onde não temos nenhuma entrada duplicada.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

SQL - Resultados de SORTING

Sintaxe

A sintaxe básica da cláusula ORDER BY que seria usada para classificar o resultado em ordem crescente ou decrescente é a seguinte -

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

Você pode usar mais de uma coluna na cláusula ORDER BY. Certifique-se de que qualquer coluna que você está usando para classificar, essa coluna deve estar na lista de colunas.

Exemplo

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

A seguir está um exemplo, que classificaria o resultado em ordem crescente por NOME e SALÁRIO.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME, SALARY;

Isso produziria o seguinte resultado -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

O bloco de código a seguir tem um exemplo, que classificaria o resultado em ordem decrescente por NAME.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME DESC;

Isso produziria o seguinte resultado -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+----+----------+-----+-----------+----------+

Para buscar as linhas com sua própria ordem preferida, a consulta SELECT usada seria a seguinte -

SQL> SELECT * FROM CUSTOMERS
   ORDER BY (CASE ADDRESS
   WHEN 'DELHI' 	 THEN 1
   WHEN 'BHOPAL' 	 THEN 2
   WHEN 'KOTA' 	 THEN 3
   WHEN 'AHMEDABAD' THEN 4
   WHEN 'MP' 	THEN 5
   ELSE 100 END) ASC, ADDRESS DESC;

Isso produziria o seguinte resultado -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Isso classificará os clientes por ADDRESS em seu ownoOrderde preferência primeiro e em uma ordem natural para os endereços restantes. Além disso, os endereços restantes serão classificados em ordem alfabética reversa.

SQL - restrições

As restrições podem estar no nível da coluna ou no nível da tabela. As restrições de nível de coluna são aplicadas apenas a uma coluna, enquanto as restrições de nível de tabela são aplicadas a toda a tabela.

A seguir estão algumas das restrições mais comumente usadas disponíveis em SQL. Essas restrições já foram discutidas no capítulo SQL - Conceitos de RDBMS , mas vale a pena revisá-las neste ponto.

Restrição NOT NULL - Garante que uma coluna não pode ter valor NULL.
Restrição DEFAULT - fornece um valor padrão para uma coluna quando nenhum é especificado.
Restrição UNIQUE - Garante que todos os valores em uma coluna sejam diferentes.
Chave PRIMÁRIA - Identifica exclusivamente cada linha / registro em uma tabela de banco de dados.
Chave FOREIGN - Identifica exclusivamente uma linha / registro em qualquer uma das tabelas de banco de dados fornecidas.
Restrição CHECK - A restrição CHECK garante que todos os valores em uma coluna atendam a certas condições.
INDEX - Usado para criar e recuperar dados do banco de dados muito rapidamente.

As restrições podem ser especificadas quando uma tabela é criada com a instrução CREATE TABLE ou você pode usar a instrução ALTER TABLE para criar restrições, mesmo depois que a tabela é criada.

Eliminando restrições

Qualquer restrição que você definiu pode ser eliminada usando o comando ALTER TABLE com a opção DROP CONSTRAINT.

Por exemplo, para eliminar a restrição de chave primária na tabela EMPLOYEES, você pode usar o seguinte comando.

ALTER TABLE EMPLOYEES DROP CONSTRAINT EMPLOYEES_PK;

Algumas implementações podem fornecer atalhos para eliminar certas restrições. Por exemplo, para eliminar a restrição de chave primária para uma tabela no Oracle, você pode usar o seguinte comando.

ALTER TABLE EMPLOYEES DROP PRIMARY KEY;

Algumas implementações permitem que você desative as restrições. Em vez de eliminar permanentemente uma restrição do banco de dados, você pode desativar temporariamente a restrição e ativá-la posteriormente.

Restrições de integridade

As restrições de integridade são usadas para garantir a precisão e a consistência dos dados em um banco de dados relacional. A integridade dos dados é tratada em um banco de dados relacional por meio do conceito de integridade referencial.

Existem muitos tipos de restrições de integridade que desempenham um papel na Referential Integrity (RI). Essas restrições incluem chave primária, chave estrangeira, restrições exclusivas e outras restrições que são mencionadas acima.

SQL - usando associações

O SQL Joinscláusula é usada para combinar registros de duas ou mais tabelas em um banco de dados. Um JOIN é um meio de combinar campos de duas tabelas usando valores comuns a cada uma.

Considere as duas tabelas a seguir -

Table 1 - Tabela CLIENTES

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - Tabela ORDERS

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Agora, vamos juntar essas duas tabelas em nossa instrução SELECT, conforme mostrado abaixo.

SQL> SELECT ID, NAME, AGE, AMOUNT
   FROM CUSTOMERS, ORDERS
   WHERE  CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Isso produziria o seguinte resultado.

+----+----------+-----+--------+
| ID | NAME     | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |   3000 |
|  3 | kaushik  |  23 |   1500 |
|  2 | Khilan   |  25 |   1560 |
|  4 | Chaitali |  25 |   2060 |
+----+----------+-----+--------+

Aqui, é perceptível que a junção é realizada na cláusula WHERE. Vários operadores podem ser usados para unir tabelas, como =, <,>, <>, <=,> =,! =, BETWEEN, LIKE e NOT; todos eles podem ser usados para unir tabelas. No entanto, o operador mais comum é o símbolo igual a.

Existem diferentes tipos de junções disponíveis no SQL -

INNER JOIN - retorna linhas quando há uma correspondência em ambas as tabelas.
LEFT JOIN - retorna todas as linhas da tabela da esquerda, mesmo se não houver correspondências na tabela da direita.
RIGHT JOIN - retorna todas as linhas da tabela da direita, mesmo se não houver correspondências na tabela da esquerda.
FULL JOIN - retorna linhas quando há uma correspondência em uma das tabelas.
SELF JOIN - é usado para juntar uma tabela a si mesma como se a tabela fosse duas tabelas, renomeando temporariamente pelo menos uma tabela na instrução SQL.
CARTESIAN JOIN - retorna o produto cartesiano dos conjuntos de registros de duas ou mais tabelas unidas.

Vamos agora discutir cada uma dessas junções em detalhes.

SQL - CLÁUSULA SINDICAL

A cláusula / operador SQL UNION é usada para combinar os resultados de duas ou mais instruções SELECT sem retornar nenhuma linha duplicada.

Para usar esta cláusula UNION, cada instrução SELECT deve ter

O mesmo número de colunas selecionadas
O mesmo número de expressões de coluna
O mesmo tipo de dados e
Coloque-os na mesma ordem

Mas eles não precisam ter o mesmo comprimento.

Sintaxe

A sintaxe básica de um UNION cláusula é a seguinte -

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Aqui, a condição fornecida pode ser qualquer expressão com base em seus requisitos.

Exemplo

Considere as duas tabelas a seguir.

Table 1 - A Tabela CLIENTES é a seguinte.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - Tabela ORDERS é a seguinte.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Agora, vamos juntar essas duas tabelas em nossa instrução SELECT da seguinte maneira -

SQL> SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   LEFT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION
   SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   RIGHT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Isso produziria o seguinte resultado -

+------+----------+--------+---------------------+
| ID   | NAME     | AMOUNT | DATE                |
+------+----------+--------+---------------------+
|    1 | Ramesh   |   NULL | NULL                |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
|    5 | Hardik   |   NULL | NULL                |
|    6 | Komal    |   NULL | NULL                |
|    7 | Muffy    |   NULL | NULL                |
+------+----------+--------+---------------------+

A cláusula UNION ALL

O operador UNION ALL é usado para combinar os resultados de duas instruções SELECT incluindo linhas duplicadas.

As mesmas regras que se aplicam à cláusula UNION serão aplicadas ao operador UNION ALL.

Sintaxe

A sintaxe básica do UNION ALL é o seguinte.

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION ALL

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Aqui, a condição fornecida pode ser qualquer expressão com base em seus requisitos.

Exemplo

Considere as duas tabelas a seguir,

Table 1 - A Tabela CLIENTES é a seguinte.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - A tabela ORDERS é a seguinte.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Agora, vamos juntar essas duas tabelas em nossa instrução SELECT da seguinte maneira -

SQL> SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   LEFT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION ALL
   SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   RIGHT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Isso produziria o seguinte resultado -

+------+----------+--------+---------------------+
| ID   | NAME     | AMOUNT | DATE                |
+------+----------+--------+---------------------+
|    1 | Ramesh   |   NULL | NULL                |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
|    5 | Hardik   |   NULL | NULL                |
|    6 | Komal    |   NULL | NULL                |
|    7 | Muffy    |   NULL | NULL                |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

Existem duas outras cláusulas (isto é, operadores), que são como a cláusula UNION.

Cláusula SQL INTERSECT - usada para combinar duas instruções SELECT, mas retorna apenas linhas da primeira instrução SELECT que são idênticas a uma linha na segunda instrução SELECT.
Cláusula SQL EXCEPT - Combina duas instruções SELECT e retorna linhas da primeira instrução SELECT que não são retornadas pela segunda instrução SELECT.

SQL - valores NULL

O SQL NULLé o termo usado para representar um valor ausente. Um valor NULL em uma tabela é um valor em um campo que parece estar em branco.

Um campo com valor NULL é um campo sem valor. É muito importante entender que um valor NULL é diferente de um valor zero ou de um campo que contém espaços.

Sintaxe

A sintaxe básica de NULL ao criar uma mesa.

SQL> CREATE TABLE CUSTOMERS(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25) ,
   SALARY   DECIMAL (18, 2),       
   PRIMARY KEY (ID)
);

Aqui, NOT NULLsignifica que a coluna deve sempre aceitar um valor explícito do tipo de dados fornecido. Existem duas colunas nas quais não usamos NOT NULL, o que significa que essas colunas podem ser NULL.

Um campo com valor NULL é aquele que foi deixado em branco durante a criação do registro.

Exemplo

O valor NULL pode causar problemas ao selecionar dados. No entanto, porque ao comparar um valor desconhecido com qualquer outro valor, o resultado é sempre desconhecido e não é incluído nos resultados. Você deve usar oIS NULL ou IS NOT NULL operadores para verificar um valor NULL.

Considere a seguinte tabela de CLIENTES com os registros mostrados abaixo.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |          |
|  7 | Muffy    |  24 | Indore    |          |
+----+----------+-----+-----------+----------+

Agora, a seguir está o uso do IS NOT NULLoperador.

SQL> SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM CUSTOMERS
   WHERE SALARY IS NOT NULL;

Isso produziria o seguinte resultado -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
+----+----------+-----+-----------+----------+

Agora, a seguir está o uso do IS NULL operador.

SQL> SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM CUSTOMERS
   WHERE SALARY IS NULL;

Isso produziria o seguinte resultado -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  6 | Komal    |  22 | MP        |          |
|  7 | Muffy    |  24 | Indore    |          |
+----+----------+-----+-----------+----------+

SQL - Sintaxe de alias

Você pode renomear uma tabela ou coluna temporariamente, dando outro nome conhecido como Alias. O uso de apelidos de tabela é para renomear uma tabela em uma instrução SQL específica. A renomeação é uma mudança temporária e o nome real da tabela não muda no banco de dados. Os aliases de coluna são usados para renomear as colunas de uma tabela para fins de uma consulta SQL específica.

Sintaxe

A sintaxe básica de um table alias é o seguinte.

SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];

A sintaxe básica de um column alias é o seguinte.

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

Exemplo

Considere as duas tabelas a seguir.

Table 1 - A Tabela CLIENTES é a seguinte.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - Tabela ORDERS é a seguinte.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Agora, o seguinte bloco de código mostra o uso de um table alias.

SQL> SELECT C.ID, C.NAME, C.AGE, O.AMOUNT 
   FROM CUSTOMERS AS C, ORDERS AS O
   WHERE  C.ID = O.CUSTOMER_ID;

Isso produziria o seguinte resultado.

+----+----------+-----+--------+
| ID | NAME     | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |   3000 |
|  3 | kaushik  |  23 |   1500 |
|  2 | Khilan   |  25 |   1560 |
|  4 | Chaitali |  25 |   2060 |
+----+----------+-----+--------+

A seguir está o uso de um column alias.

SQL> SELECT  ID AS CUSTOMER_ID, NAME AS CUSTOMER_NAME
   FROM CUSTOMERS
   WHERE SALARY IS NOT NULL;

Isso produziria o seguinte resultado.

+-------------+---------------+
| CUSTOMER_ID | CUSTOMER_NAME |
+-------------+---------------+
|           1 | Ramesh        |
|           2 | Khilan        |
|           3 | kaushik       |
|           4 | Chaitali      |
|           5 | Hardik        |
|           6 | Komal         |
|           7 | Muffy         |
+-------------+---------------+

SQL - índices

Índices são special lookup tablesque o mecanismo de pesquisa de banco de dados pode usar para acelerar a recuperação de dados. Simplificando, um índice é um ponteiro para dados em uma tabela. Um índice em um banco de dados é muito semelhante a um índice no final de um livro.

Por exemplo, se você quiser fazer referência a todas as páginas de um livro que discute um determinado tópico, primeiro consulte o índice, que lista todos os tópicos em ordem alfabética e, em seguida, é referido a um ou mais números de página específicos.

Um índice ajuda a acelerar SELECT consultas e WHERE cláusulas, mas retarda a entrada de dados, com o UPDATE e a INSERTafirmações. Os índices podem ser criados ou eliminados sem efeito nos dados.

Criar um índice envolve o CREATE INDEX instrução, que permite nomear o índice, especificar a tabela e qual coluna ou colunas indexar e indicar se o índice está em ordem crescente ou decrescente.

Os índices também podem ser únicos, como o UNIQUE restrição, na medida em que o índice evita entradas duplicadas na coluna ou combinação de colunas nas quais há um índice.

O comando CREATE INDEX

A sintaxe básica de um CREATE INDEX é o seguinte.

CREATE INDEX index_name ON table_name;

Índices de coluna única

Um índice de coluna única é criado com base em apenas uma coluna da tabela. A sintaxe básica é a seguinte.

CREATE INDEX index_name
ON table_name (column_name);

Índices Únicos

Índices exclusivos são usados não apenas para desempenho, mas também para integridade de dados. Um índice exclusivo não permite que nenhum valor duplicado seja inserido na tabela. A sintaxe básica é a seguinte.

CREATE UNIQUE INDEX index_name
on table_name (column_name);

Índices Compostos

Um índice composto é um índice em duas ou mais colunas de uma tabela. Sua sintaxe básica é a seguinte.

CREATE INDEX index_name
on table_name (column1, column2);

Seja para criar um índice de coluna única ou um índice composto, leve em consideração a (s) coluna (s) que você pode usar com muita frequência na cláusula WHERE de uma consulta como condições de filtro.

Se houver apenas uma coluna usada, um índice de coluna única deve ser a escolha. Se houver duas ou mais colunas que são freqüentemente usadas na cláusula WHERE como filtros, o índice composto seria a melhor escolha.

Índices Implícitos

Índices implícitos são índices criados automaticamente pelo servidor de banco de dados quando um objeto é criado. Os índices são criados automaticamente para restrições de chave primária e restrições exclusivas.

O comando DROP INDEX

Um índice pode ser eliminado usando SQL DROPcomando. Deve-se ter cuidado ao eliminar um índice, pois o desempenho pode diminuir ou melhorar.

A sintaxe básica é a seguinte -

DROP INDEX index_name;

Você pode verificar o capítulo de restrição INDEX para ver alguns exemplos reais de índices.

Quando os índices devem ser evitados?

Embora os índices tenham como objetivo aprimorar o desempenho de um banco de dados, há momentos em que eles devem ser evitados.

As diretrizes a seguir indicam quando o uso de um índice deve ser reconsiderado.

Os índices não devem ser usados em tabelas pequenas.
Tabelas que têm atualizações em lote frequentes e grandes ou operações de inserção.
Os índices não devem ser usados em colunas que contêm um grande número de valores NULL.
As colunas que são frequentemente manipuladas não devem ser indexadas.

SQL - Comando ALTER TABLE

O SQL ALTER TABLEcomando é usado para adicionar, excluir ou modificar colunas em uma tabela existente. Você também deve usar o comando ALTER TABLE para adicionar e eliminar várias restrições em uma tabela existente.

Sintaxe

A sintaxe básica de um comando ALTER TABLE para adicionar um New Column em uma tabela existente é o seguinte.

ALTER TABLE table_name ADD column_name datatype;

A sintaxe básica de um comando ALTER TABLE para DROP COLUMN em uma tabela existente é o seguinte.

ALTER TABLE table_name DROP COLUMN column_name;

A sintaxe básica de um comando ALTER TABLE para alterar o DATA TYPE de uma coluna em uma tabela é o seguinte.

ALTER TABLE table_name MODIFY COLUMN column_name datatype;

A sintaxe básica de um comando ALTER TABLE para adicionar um NOT NULL restrição a uma coluna em uma tabela é a seguinte.

ALTER TABLE table_name MODIFY column_name datatype NOT NULL;

A sintaxe básica de ALTER TABLE para ADD UNIQUE CONSTRAINT a uma mesa é o seguinte.

ALTER TABLE table_name 
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);

A sintaxe básica de um comando ALTER TABLE para ADD CHECK CONSTRAINT a uma mesa é o seguinte.

ALTER TABLE table_name 
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);

A sintaxe básica de um comando ALTER TABLE para ADD PRIMARY KEY restrição a uma tabela é a seguinte.

ALTER TABLE table_name 
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1, column2...);

A sintaxe básica de um comando ALTER TABLE para DROP CONSTRAINT de uma tabela é o seguinte.

ALTER TABLE table_name 
DROP CONSTRAINT MyUniqueConstraint;

Se você estiver usando MySQL, o código é o seguinte -

ALTER TABLE table_name 
DROP INDEX MyUniqueConstraint;

A sintaxe básica de um comando ALTER TABLE para DROP PRIMARY KEY restrição de uma tabela é a seguinte.

ALTER TABLE table_name 
DROP CONSTRAINT MyPrimaryKey;

Se você estiver usando MySQL, o código é o seguinte -

ALTER TABLE table_name 
DROP PRIMARY KEY;

Exemplo

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

A seguir está o exemplo para ADICIONAR um New Column para uma mesa existente -

ALTER TABLE CUSTOMERS ADD SEX char(1);

Agora, a tabela CUSTOMERS foi alterada e o seguinte seria a saída da instrução SELECT.

+----+---------+-----+-----------+----------+------+
| ID | NAME    | AGE | ADDRESS   | SALARY   | SEX  |
+----+---------+-----+-----------+----------+------+
|  1 | Ramesh  |  32 | Ahmedabad |  2000.00 | NULL |
|  2 | Ramesh  |  25 | Delhi     |  1500.00 | NULL |
|  3 | kaushik |  23 | Kota      |  2000.00 | NULL |
|  4 | kaushik |  25 | Mumbai    |  6500.00 | NULL |
|  5 | Hardik  |  27 | Bhopal    |  8500.00 | NULL |
|  6 | Komal   |  22 | MP        |  4500.00 | NULL |
|  7 | Muffy   |  24 | Indore    | 10000.00 | NULL |
+----+---------+-----+-----------+----------+------+

A seguir está o exemplo para DROP a coluna sexo da tabela existente.

ALTER TABLE CUSTOMERS DROP SEX;

Agora, a tabela CUSTOMERS foi alterada e a seguir estaria a saída da instrução SELECT.

+----+---------+-----+-----------+----------+
| ID | NAME    | AGE | ADDRESS   | SALARY   |
+----+---------+-----+-----------+----------+
|  1 | Ramesh  |  32 | Ahmedabad |  2000.00 |
|  2 | Ramesh  |  25 | Delhi     |  1500.00 |
|  3 | kaushik |  23 | Kota      |  2000.00 |
|  4 | kaushik |  25 | Mumbai    |  6500.00 |
|  5 | Hardik  |  27 | Bhopal    |  8500.00 |
|  6 | Komal   |  22 | MP        |  4500.00 |
|  7 | Muffy   |  24 | Indore    | 10000.00 |
+----+---------+-----+-----------+----------+

SQL - Comando TRUNCATE TABLE

O SQL TRUNCATE TABLE comando é usado para excluir dados completos de uma tabela existente.

Você também pode usar o comando DROP TABLE para excluir a tabela completa, mas removeria a estrutura completa da tabela do banco de dados e você precisaria recriar esta tabela mais uma vez se desejar armazenar alguns dados.

Sintaxe

A sintaxe básica de um TRUNCATE TABLE comando é o seguinte.

TRUNCATE TABLE  table_name;

Exemplo

Considere uma tabela CUSTOMERS com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

A seguir está o exemplo de um comando Truncate.

SQL > TRUNCATE TABLE CUSTOMERS;

Agora, a tabela CUSTOMERS está truncada e a saída da instrução SELECT será como mostrado no bloco de código abaixo -

SQL> SELECT * FROM CUSTOMERS;
Empty set (0.00 sec)

SQL - usando visualizações

Uma visão nada mais é do que uma instrução SQL armazenada no banco de dados com um nome associado. Uma visão é, na verdade, uma composição de uma tabela na forma de uma consulta SQL predefinida.

Uma visualização pode conter todas as linhas de uma tabela ou selecionar linhas de uma tabela. Uma visão pode ser criada a partir de uma ou várias tabelas que dependem da consulta SQL escrita para criar uma visão.

Visualizações, que são um tipo de tabelas virtuais, permitem que os usuários façam o seguinte -

Estruture os dados de uma forma que os usuários ou classes de usuários considerem natural ou intuitiva.
Restrinja o acesso aos dados de forma que um usuário possa ver e (às vezes) modificar exatamente o que precisa e nada mais.
Resuma os dados de várias tabelas que podem ser usadas para gerar relatórios.

Criando Vistas

As visualizações do banco de dados são criadas usando o CREATE VIEWdeclaração. As visualizações podem ser criadas a partir de uma única tabela, várias tabelas ou outra visualização.

Para criar uma visualização, um usuário deve ter o privilégio de sistema apropriado de acordo com a implementação específica.

O básico CREATE VIEW a sintaxe é a seguinte -

CREATE VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];

Você pode incluir várias tabelas em sua instrução SELECT de maneira semelhante à usada em uma consulta SQL SELECT normal.

Exemplo

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

A seguir está um exemplo para criar uma visualização da tabela CUSTOMERS. Essa visualização seria usada para ter o nome e idade do cliente da tabela CUSTOMERS.

SQL > CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM  CUSTOMERS;

Agora, você pode consultar CUSTOMERS_VIEW de maneira semelhante à consulta a uma tabela real. A seguir está um exemplo para o mesmo.

SQL > SELECT * FROM CUSTOMERS_VIEW;

Isso produziria o seguinte resultado.

+----------+-----+
| name     | age |
+----------+-----+
| Ramesh   |  32 |
| Khilan   |  25 |
| kaushik  |  23 |
| Chaitali |  25 |
| Hardik   |  27 |
| Komal    |  22 |
| Muffy    |  24 |
+----------+-----+

A OPÇÃO COM CHEQUE

O WITH CHECK OPTION é uma opção de instrução CREATE VIEW. O propósito de WITH CHECK OPTION é garantir que todos os UPDATE e INSERTs satisfaçam a (s) condição (ões) na definição da visão.

Se eles não satisfizerem a (s) condição (ões), o UPDATE ou INSERT retornará um erro.

O bloco de código a seguir tem um exemplo de criação da mesma visualização CUSTOMERS_VIEW com WITH CHECK OPTION.

CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM  CUSTOMERS
WHERE age IS NOT NULL
WITH CHECK OPTION;

A opção WITH CHECK neste caso deve negar a entrada de qualquer valor NULL na coluna AGE da visão, porque a visão é definida por dados que não possuem um valor NULL na coluna AGE.

Atualizando uma visualização

Uma visão pode ser atualizada sob certas condições que são fornecidas abaixo -

A cláusula SELECT não pode conter a palavra-chave DISTINCT.
A cláusula SELECT não pode conter funções de resumo.
A cláusula SELECT não pode conter funções definidas.
A cláusula SELECT não pode conter operadores de conjunto.
A cláusula SELECT não pode conter uma cláusula ORDER BY.
A cláusula FROM não pode conter várias tabelas.
A cláusula WHERE não pode conter subconsultas.
A consulta não pode conter GROUP BY ou HAVING.
As colunas calculadas não podem ser atualizadas.
Todas as colunas NOT NULL da tabela base devem ser incluídas na visualização para que a consulta INSERT funcione.

Portanto, se uma visualização satisfizer todas as regras mencionadas acima, você poderá atualizá-la. O seguinte bloco de código tem um exemplo para atualizar a idade de Ramesh.

SQL > UPDATE CUSTOMERS_VIEW
   SET AGE = 35
   WHERE name = 'Ramesh';

Isso, em última análise, atualizaria a tabela base CUSTOMERS e o mesmo se refletiria na própria visualização. Agora, tente consultar a tabela base e a instrução SELECT produziria o seguinte resultado.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Inserindo Linhas em uma Visualização

Linhas de dados podem ser inseridas em uma visualização. As mesmas regras que se aplicam ao comando UPDATE também se aplicam ao comando INSERT.

Aqui, não podemos inserir linhas em CUSTOMERS_VIEW porque não incluímos todas as colunas NOT NULL nesta visão, caso contrário, você pode inserir linhas em uma visão de uma forma semelhante à de uma tabela.

Excluindo linhas em uma visualização

Linhas de dados podem ser excluídas de uma visualização. As mesmas regras que se aplicam aos comandos UPDATE e INSERT se aplicam ao comando DELETE.

A seguir está um exemplo para excluir um registro com AGE = 22.

SQL > DELETE FROM CUSTOMERS_VIEW
   WHERE age = 22;

Isso, em última análise, excluiria uma linha da tabela base CUSTOMERS e o mesmo se refletiria na própria visualização. Agora, tente consultar a tabela base e a instrução SELECT produziria o seguinte resultado.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Queda de visualizações

Obviamente, onde você tem uma visualização, você precisa encontrar uma maneira de removê-la se ela não for mais necessária. A sintaxe é muito simples e é fornecida a seguir -

DROP VIEW view_name;

A seguir está um exemplo para eliminar CUSTOMERS_VIEW da tabela CUSTOMERS.

DROP VIEW CUSTOMERS_VIEW;

SQL - Cláusula Tendo

o HAVING Clause permite que você especifique as condições que filtram quais resultados de grupo aparecem nos resultados.

A cláusula WHERE coloca condições nas colunas selecionadas, enquanto a cláusula HAVING coloca condições nos grupos criados pela cláusula GROUP BY.

Sintaxe

O bloco de código a seguir mostra a posição da cláusula HAVING em uma consulta.

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

A cláusula HAVING deve seguir a cláusula GROUP BY em uma consulta e também deve preceder a cláusula ORDER BY, se usada. O bloco de código a seguir tem a sintaxe da instrução SELECT incluindo a cláusula HAVING -

SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

Exemplo

Considere a tabela CUSTOMERS com os seguintes registros.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

A seguir está um exemplo, que exibiria um registro para uma contagem de idade semelhante que seria maior ou igual a 2.

SQL > SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
GROUP BY age
HAVING COUNT(age) >= 2;

Isso produziria o seguinte resultado -

+----+--------+-----+---------+---------+
| ID | NAME   | AGE | ADDRESS | SALARY  |
+----+--------+-----+---------+---------+
|  2 | Khilan |  25 | Delhi   | 1500.00 |
+----+--------+-----+---------+---------+

SQL - transações

Uma transação é uma unidade de trabalho executada em um banco de dados. As transações são unidades ou sequências de trabalho realizadas em uma ordem lógica, seja de forma manual por um usuário ou automaticamente por algum tipo de programa de banco de dados.

Uma transação é a propagação de uma ou mais alterações no banco de dados. Por exemplo, se você estiver criando um registro ou atualizando um registro ou excluindo um registro da tabela, então você está executando uma transação nessa tabela. É importante controlar essas transações para garantir a integridade dos dados e tratar os erros do banco de dados.

Praticamente, você agrupará muitas consultas SQL em um grupo e executará todas elas juntas como parte de uma transação.

Propriedades das transações

As transações têm as quatro propriedades padrão a seguir, geralmente referidas pela sigla ACID.

Atomicity- garante que todas as operações dentro da unidade de trabalho sejam concluídas com sucesso. Caso contrário, a transação é abortada no ponto de falha e todas as operações anteriores voltam ao estado anterior.
Consistency - garante que o banco de dados mude de estado corretamente após uma transação confirmada com sucesso.
Isolation - permite que as transações operem de forma independente e transparente entre si.
Durability - garante que o resultado ou efeito de uma transação confirmada persiste em caso de falha do sistema.

Controle de transação

Os comandos a seguir são usados para controlar transações.

COMMIT - para salvar as alterações.
ROLLBACK - para reverter as alterações.
SAVEPOINT - cria pontos dentro dos grupos de transações nas quais ROLLBACK.
SET TRANSACTION - Coloca um nome em uma transação.

Comandos de controle transacional

Comandos de controle transacional são usados apenas com o DML Commandscomo - INSERT, UPDATE e DELETE apenas. Eles não podem ser usados ao criar tabelas ou eliminá-los porque essas operações são confirmadas automaticamente no banco de dados.

O Comando COMMIT

O comando COMMIT é o comando transacional usado para salvar as alterações invocadas por uma transação no banco de dados.

O comando COMMIT é o comando transacional usado para salvar as alterações invocadas por uma transação no banco de dados. O comando COMMIT salva todas as transações no banco de dados desde o último comando COMMIT ou ROLLBACK.

A sintaxe do comando COMMIT é a seguinte.

COMMIT;

Example

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

A seguir está um exemplo que excluiria os registros da tabela que têm idade = 25 e, em seguida, COMMIT as alterações no banco de dados.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE = 25;
SQL> COMMIT;

Portanto, duas linhas da tabela seriam excluídas e a instrução SELECT produziria o seguinte resultado.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

O comando ROLLBACK

O comando ROLLBACK é o comando transacional usado para desfazer transações que ainda não foram salvas no banco de dados. Este comando só pode ser usado para desfazer transações desde que o último comando COMMIT ou ROLLBACK foi emitido.

A sintaxe para um comando ROLLBACK é a seguinte -

ROLLBACK;

Example

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

A seguir está um exemplo, que excluiria os registros da tabela que têm idade = 25 e, em seguida, ROLLBACK as alterações no banco de dados.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE = 25;
SQL> ROLLBACK;

Portanto, a operação de exclusão não afetaria a tabela e a instrução SELECT produziria o seguinte resultado.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

O Comando SAVEPOINT

Um SAVEPOINT é um ponto em uma transação em que você pode reverter a transação para um determinado ponto sem reverter toda a transação.

A sintaxe para um comando SAVEPOINT é mostrada abaixo.

SAVEPOINT SAVEPOINT_NAME;

Este comando serve apenas para a criação de um SAVEPOINT entre todas as instruções transacionais. O comando ROLLBACK é usado para desfazer um grupo de transações.

A sintaxe para reverter para um SAVEPOINT é mostrada a seguir.

ROLLBACK TO SAVEPOINT_NAME;

A seguir está um exemplo onde você planeja excluir os três registros diferentes da tabela CLIENTES. Você deseja criar um SAVEPOINT antes de cada exclusão, de forma que possa ROLLBACK para qualquer SAVEPOINT a qualquer momento para retornar os dados apropriados ao seu estado original.

Example

Considere a tabela CUSTOMERS com os seguintes registros.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

O bloco de código a seguir contém a série de operações.

SQL> SAVEPOINT SP1;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=1;
1 row deleted.
SQL> SAVEPOINT SP2;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=2;
1 row deleted.
SQL> SAVEPOINT SP3;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=3;
1 row deleted.

Agora que as três exclusões ocorreram, vamos supor que você mudou de ideia e decidiu ROLLBACK para o SAVEPOINT que você identificou como SP2. Como o SP2 foi criado após a primeira exclusão, as duas últimas exclusões foram desfeitas -

SQL> ROLLBACK TO SP2;
Rollback complete.

Observe que apenas a primeira exclusão ocorreu desde a reversão para o SP2.

SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+
6 rows selected.

O comando RELEASE SAVEPOINT

O comando RELEASE SAVEPOINT é usado para remover um SAVEPOINT que você criou.

A sintaxe para um comando RELEASE SAVEPOINT é a seguinte.

RELEASE SAVEPOINT SAVEPOINT_NAME;

Uma vez que um SAVEPOINT tenha sido liberado, você não pode mais usar o comando ROLLBACK para desfazer transações executadas desde o último SAVEPOINT.

O comando SET TRANSACTION

O comando SET TRANSACTION pode ser usado para iniciar uma transação do banco de dados. Este comando é usado para especificar características para a transação que se segue. Por exemplo, você pode especificar uma transação para ser somente leitura ou leitura e gravação.

A sintaxe para um comando SET TRANSACTION é a seguinte.

SET TRANSACTION [ READ WRITE | READ ONLY ];

SQL - operadores curinga

Já discutimos sobre o operador SQL LIKE, que é usado para comparar um valor a valores semelhantes usando os operadores curinga.

O SQL oferece suporte a dois operadores curinga em conjunto com o operador LIKE, que são explicados em detalhes na tabela a seguir.

Sr. Não.	Curinga e descrição
1	The percent sign (%) Corresponde a um ou mais caracteres. Note - O MS Access usa o caractere curinga asterisco (*) em vez do caractere curinga de sinal de porcentagem (%).
2	The underscore (_) Corresponde a um personagem. Note - O MS Access usa um ponto de interrogação (?) Em vez do sublinhado (_) para corresponder a qualquer caractere.

O sinal de porcentagem representa zero, um ou vários caracteres. O sublinhado representa um único número ou um caractere. Esses símbolos podem ser usados em combinações.

Sintaxe

A sintaxe básica de um operador '%' e '_' é a seguinte.

SELECT * FROM table_name
WHERE column LIKE 'XXXX%'

or 

SELECT * FROM table_name
WHERE column LIKE '%XXXX%'

or

SELECT * FROM table_name
WHERE column LIKE 'XXXX_'

or

SELECT * FROM table_name
WHERE column LIKE '_XXXX'

or

SELECT * FROM table_name
WHERE column LIKE '_XXXX_'

Você pode combinar um número N de condições usando os operadores AND ou OR. Aqui, XXXX pode ser qualquer valor numérico ou string.

Exemplo

A tabela a seguir contém vários exemplos que mostram a parte WHERE com diferentes cláusulas LIKE com operadores '%' e '_'.

Sr. Não.	Declaração e descrição
1	WHERE SALARY LIKE '200%' Encontra todos os valores que começam com 200.
2	WHERE SALARY LIKE '%200%' Encontra qualquer valor que tenha 200 em qualquer posição.
3	WHERE SALARY LIKE '_00%' Encontra qualquer valor que tenha 00 na segunda e na terceira posições.
4	WHERE SALARY LIKE '2_%_%' Encontra qualquer valor que comece com 2 e tenha pelo menos 3 caracteres de comprimento.
5	WHERE SALARY LIKE '%2' Encontra qualquer valor que termine com 2.
6	WHERE SALARY LIKE '_2%3' Encontra qualquer valor que tenha 2 na segunda posição e termine com 3.
7	WHERE SALARY LIKE '2___3' Encontra qualquer valor em um número de cinco dígitos que começa com 2 e termina com 3.

Tomemos um exemplo real, considere a tabela CLIENTES com os seguintes registros.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

O bloco de código a seguir é um exemplo, que exibiria todos os registros da tabela CUSTOMERS onde SALÁRIO começa com 200.

SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

Isso produziria o seguinte resultado.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
+----+----------+-----+-----------+----------+

SQL - funções de data

A tabela a seguir contém uma lista de todas as funções importantes relacionadas à data e hora disponíveis por meio do SQL. Existem várias outras funções suportadas por seu RDBMS. A lista fornecida é baseada em MySQL RDBMS.

Sr. Não.	Descrição da função
1	ADDDATE () Adiciona datas
2	TEMPO EXTRA() Adiciona tempo
3	CONVERT_TZ () Converte de um fuso horário para outro
4	CURDATE () Retorna a data atual
5	CURRENT_DATE (), CURRENT_DATE Sinônimos para CURDATE ()
6	CURRENT_TIME (), CURRENT_TIME Sinônimos para CURTIME ()
7	CURRENT_TIMESTAMP (), CURRENT_TIMESTAMP Sinônimos para AGORA ()
8	CURTIME () Retorna a hora atual
9	DATE_ADD () Adiciona duas datas
10	FORMATO DE DATA() Formata a data conforme especificado
11	DATE_SUB () Subtrai duas datas
12	ENCONTRO() Extrai a parte da data de uma data ou expressão datetime
13	DATEDIFF () Subtrai duas datas
14	DIA() Sinônimo de DAYOFMONTH ()
15	DAYNAME () Retorna o nome do dia da semana
16	DIA DO MÊS() Retorna o dia do mês (1-31)
17	DIA DA SEMANA() Retorna o índice do dia da semana do argumento
18	DAYOFYEAR () Retorna o dia do ano (1-366)
19	EXTRAIR Extrai parte de uma data
20	FROM_DAYS () Converte um número de dia em uma data
21	FROM_UNIXTIME () Formata a data como um carimbo de data / hora UNIX
22	HORA() Extrai a hora
23	ÚLTIMO DIA Retorna o último dia do mês para o argumento
24	LOCALTIME (), LOCALTIME Sinônimo de AGORA ()
25	LOCALTIMESTAMP, LOCALTIMESTAMP () Sinônimo de AGORA ()
26	MAKEDATE () Cria uma data do ano e dia do ano
27	MAKETIME MAKETIME ()
28	MICROSEGUNDO () Retorna os microssegundos do argumento
29	MINUTO() Retorna o minuto do argumento
30	MÊS() Retorna o mês a partir da data passada
31	MONTHNAME () Retorna o nome do mês
32	AGORA() Retorna a data e hora atuais
33	PERIOD_ADD () Adiciona um período a um ano-mês
34	PERIOD_DIFF () Retorna o número de meses entre os períodos
35	TRIMESTRE() Retorna o trimestre de um argumento de data
36	SEC_TO_TIME () Converte segundos para o formato 'HH: MM: SS'
37	SEGUNDO() Retorna o segundo (0-59)
38	STR_DA_DATA () Converte uma string em uma data
39	SUBDATE () Quando chamado com três argumentos, é um sinônimo para DATE_SUB ()
40	SUBTIME () Subtrai tempos
41	SYSDATE () Retorna a hora em que a função é executada
42	TIME_FORMAT () Formatos como tempo
43	TIME_TO_SEC () Retorna o argumento convertido em segundos
44	TEMPO() Extrai a parte do tempo da expressão passada
45	TIMEDIFF () Subtrai o tempo
46	TIMESTAMP () Com um único argumento, essa função retorna a expressão de data ou data e hora. Com dois argumentos, a soma dos argumentos
47	TIMESTAMPADD () Adiciona um intervalo a uma expressão datetime
48	TIMESTAMPDIFF () Subtrai um intervalo de uma expressão datetime
49	TO_DAYS () Retorna o argumento da data convertido em dias
50	UNIX_TIMESTAMP () Retorna um carimbo de data / hora UNIX
51	UTC_DATE () Retorna a data UTC atual
52	UTC_TIME () Retorna a hora UTC atual
53	UTC_TIMESTAMP () Retorna a data e hora UTC atual
54	SEMANA() Retorna o número da semana
55	WEEKDAY () Retorna o índice do dia da semana
56	WEEKOFYEAR () Retorna a semana do calendário da data (1-53)
57	ANO() Retorna o ano
58	SEMANA ANO () Retorna o ano e a semana

ADDDATE (data, unidade expr INTERVAL), ADDDATE (expr, dias)

Quando chamado com a forma INTERVAL do segundo argumento, ADDDATE () é um sinônimo para DATE_ADD (). A função relacionada SUBDATE () é um sinônimo para DATE_SUB (). Para obter informações sobre o argumento da unidade INTERVAL, consulte a discussão para DATE_ADD ().

mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| ADDDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Quando chamado com a forma de dias do segundo argumento, o MySQL o trata como um número inteiro de dias a ser adicionado a expr.

mysql> SELECT ADDDATE('1998-01-02', 31);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ADDTIME (expr1, expr2)

ADDTIME () adiciona expr2 a expr1 e retorna o resultado. O expr1 é uma expressão de hora ou data e hora, enquanto o expr2 é uma expressão de tempo.

mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59.999999','1 1:1:1.000002') |
+---------------------------------------------------------+
| 1998-01-02 01:01:01.000001                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CONVERT_TZ (dt, from_tz, to_tz)

Isso converte um valor datetime dt do fuso horário fornecido por from_tz para o fuso horário fornecido por to_tz e retorna o valor resultante. Esta função retorna NULL se os argumentos forem inválidos.

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','GMT','MET')           |
+---------------------------------------------------------+
| 2004-01-01 13:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00')     |
+---------------------------------------------------------+
| 2004-01-01 22:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURDATE ()

Retorna a data atual como um valor no formato 'AAAA-MM-DD' ou AAAAMMDD, dependendo se a função é usada em uma string ou em um contexto numérico.

mysql> SELECT CURDATE();
+---------------------------------------------------------+
| CURDATE()                                               |
+---------------------------------------------------------+
| 1997-12-15                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURDATE() + 0;
+---------------------------------------------------------+
| CURDATE() + 0                                           |
+---------------------------------------------------------+
| 19971215                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_DATE e CURRENT_DATE ()

CURRENT_DATE e CURRENT_DATE () são sinônimos para CURDATE ()

CURTIME ()

Retorna a hora atual como um valor no formato 'HH: MM: SS' ou HHMMSS, dependendo se a função é usada em uma string ou em um contexto numérico. O valor é expresso no fuso horário atual.

mysql> SELECT CURTIME();
+---------------------------------------------------------+
| CURTIME()                                               |
+---------------------------------------------------------+
| 23:50:26                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURTIME() + 0;
+---------------------------------------------------------+
| CURTIME() + 0                                           |
+---------------------------------------------------------+
| 235026                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_TIME e CURRENT_TIME ()

CURRENT_TIME e CURRENT_TIME () são sinônimos para CURTIME ().

CURRENT_TIMESTAMP e CURRENT_TIMESTAMP ()

CURRENT_TIMESTAMP e CURRENT_TIMESTAMP () são sinônimos para NOW ().

DATA (expr)

Extrai a parte da data da expressão data ou data e hora expr.

mysql> SELECT DATE('2003-12-31 01:02:03');
+---------------------------------------------------------+
| DATE('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
|  2003-12-31                                             |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATEDIFF (expr1, expr2)

DATEDIFF () retorna expr1. expr2 expresso como um valor em dias de uma data a outra. Expr1 e expr2 são expressões de data ou data e hora. Apenas as partes da data dos valores são usadas no cálculo.

mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
+---------------------------------------------------------+
| DATEDIFF('1997-12-31 23:59:59','1997-12-30')            |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_ADD (data, unidade expr INTERVAL), DATE_SUB (data, unidade expr INTERVAL)

Essas funções realizam aritmética de data. odateé um valor DATETIME ou DATE especificando a data de início. oexpré uma expressão que especifica o valor do intervalo a ser adicionado ou subtraído da data de início. O expr é uma string; pode começar com '-' para intervalos negativos.

UMA unit é uma palavra-chave que indica as unidades em que a expressão deve ser interpretada.

o INTERVAL a palavra-chave e o especificador de unidade não diferenciam maiúsculas de minúsculas.

A tabela a seguir mostra a forma esperada do argumento expr para cada valor de unidade.

valor unitário	ExprFormat esperado
MICROSEGUNDO	MICROSEGUNDOS
SEGUNDO	SEGUNDOS
MINUTO	MINUTOS
HORA	HORAS
DIA	DIAS
SEMANA	SEMANAS
MÊS	MESES
TRIMESTRE	QUARTERS
ANO	ANOS
SECOND_MICROSECOND	'SECONDS.MICROSECONDS'
MINUTE_MICROSECOND	'MINUTES.MICROSECONDS'
MINUTE_SECOND	'MINUTES: SECONDS'
HOUR_MICROSECOND	'HOURS.MICROSECONDS'
HOUR_SECOND	'HOURS: MINUTES: SECONDS'
HOUR_MINUTE	'HOURS: MINUTES'
DAY_MICROSECOND	'DIAS.MICROSECONDS'
DAY_SECOND	'DAYS HOURS: MINUTES: SECONDS'
DAY_MINUTE	'DAYS HOURS: MINUTES'
DAY_HOUR	'DAYS HOURS'
ANO MÊS	'ANOS-MESES'

Os valores QUARTER e WEEKestão disponíveis no MySQL 5.0.0. versão.

mysql> SELECT DATE_ADD('1997-12-31 23:59:59', 
   -> INTERVAL '1:1' MINUTE_SECOND);
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59', INTERVAL...             |
+---------------------------------------------------------+
| 1998-01-01 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);
+---------------------------------------------------------+
| DATE_ADD('1999-01-01', INTERVAL 1 HOUR)                 |
+---------------------------------------------------------+
| 1999-01-01 01:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_FORMAT (data, formato)

Este comando formata o valor da data de acordo com a string de formato.

Os seguintes especificadores podem ser usados na string de formato. O caractere '%' é necessário antes dos caracteres do especificador de formato.

Sr. Não.	Especificador e descrição
1	%a Nome abreviado do dia da semana (dom .. sáb)
2	%b Nome abreviado do mês (Jan..Dez)
3	%c Mês, numérico (0..12)
4	%D Dia do mês com sufixo inglês (0th, 1st, 2nd, 3rd,.)
5	%d Dia do mês, numérico (00..31)
6	%e Dia do mês, numérico (0..31)
7	%f Microssegundos (000000..999999)
8	%H Hora (00..23)
9	%h Hora (01..12)
10	%I Hora (01..12)
11	%i Minutos, numérico (00..59)
12	%j Dia do ano (001..366)
13	%k Hora (0..23)
14	%l Hora (1..12)
15	%M Nome do mês (janeiro .. dezembro)
16	%m Mês, numérico (00..12)
17	%p AM ou PM
18	%r Tempo, 12 horas (hh: mm: ss seguido por AM ou PM)
19	%S Segundos (00..59)
20	%s Segundos (00..59)
21	%T Tempo, 24 horas (hh: mm: ss)
22	%U Semana (00..53), onde domingo é o primeiro dia da semana
23	%u Semana (00..53), onde segunda-feira é o primeiro dia da semana
24	%V Semana (01..53), onde domingo é o primeiro dia da semana; usado com% X
25	%v Semana (01..53), onde segunda-feira é o primeiro dia da semana; usado com% x
26	%W Nome do dia da semana (domingo .. sábado)
27	%w Dia da semana (0 = domingo..6 = sábado)
28	%X Ano para a semana em que domingo é o primeiro dia da semana, numérico, quatro dígitos; usado com% V
29	%x Ano para a semana, onde segunda-feira é o primeiro dia da semana, numérico, quatro dígitos; usado com% v
30	%Y Ano, numérico, quatro dígitos
31	%y Ano, numérico (dois dígitos)
32	%% Um literal.%. personagem
33	%x x, para any.x. não listado acima

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y')          |
+---------------------------------------------------------+
| Saturday October 1997                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00'
   -> '%H %k %I %r %T %S %w');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00.......                 |
+---------------------------------------------------------+
|  22 22 10 10:23:00 PM 22:23:00 00 6                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_SUB (data, unidade expr INTERVAL)

Isso é semelhante à função DATE_ADD ().

DAY (data)

O DAY () é um sinônimo para a função DAYOFMONTH ().

DAYNAME (data)

Retorna o nome do dia da semana para a data.

mysql> SELECT DAYNAME('1998-02-05');
+---------------------------------------------------------+
| DAYNAME('1998-02-05')                                   |
+---------------------------------------------------------+
| Thursday                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFMONTH (data)

Retorna o dia do mês para a data, no intervalo de 0 a 31.

mysql> SELECT DAYOFMONTH('1998-02-03');
+---------------------------------------------------------+
| DAYOFMONTH('1998-02-03')                                |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFWEEK (data)

Retorna o índice do dia da semana para a data (1 = domingo, 2 = segunda-feira,., 7 = sábado). Esses valores de índice correspondem ao padrão ODBC.

mysql> SELECT DAYOFWEEK('1998-02-03');
+---------------------------------------------------------+
|DAYOFWEEK('1998-02-03')                                  |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFYEAR (data)

Retorna o dia do ano para a data, no intervalo de 1 a 366.

mysql> SELECT DAYOFYEAR('1998-02-03');
+---------------------------------------------------------+
| DAYOFYEAR('1998-02-03')                                 |
+---------------------------------------------------------+
| 34                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

EXTRACT (unidade DE data)

A função EXTRACT () usa os mesmos tipos de especificadores de unidade que DATE_ADD () ou DATE_SUB (), mas extrai partes da data em vez de realizar aritmética de data.

mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');
+---------------------------------------------------------+
| EXTRACT(YEAR FROM '1999-07-02')                         |
+---------------------------------------------------------+
| 1999                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');
+---------------------------------------------------------+
| EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03')          |
+---------------------------------------------------------+
| 199907                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

FROM_DAYS (N)

Dado um número de dia N, retorna um valor DATE.

mysql> SELECT FROM_DAYS(729669);
+---------------------------------------------------------+
| FROM_DAYS(729669)                                       |
+---------------------------------------------------------+
| 1997-10-07                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Note- Use FROM_DAYS () com cuidado em datas antigas. Não se destina ao uso com valores anteriores ao advento do calendário gregoriano (1582).

FROM_UNIXTIME (unix_timestamp)

FROM_UNIXTIME (unix_timestamp, formato)

Retorna uma representação do unix_timestampargumento como um valor no formato 'AAAA-MM-DD HH: MM: SS ou AAAAMMDDHHMMSS, dependendo se a função é usada em uma string ou em um contexto numérico. O valor é expresso no fuso horário atual. O argumento unix_timestamp é um valor de carimbo de data / hora interno, que é produzido peloUNIX_TIMESTAMP() função.

Se o formato for fornecido, o resultado é formatado de acordo com a string de formato, que é usada da mesma forma que está listada na entrada para o DATE_FORMAT() função.

mysql> SELECT FROM_UNIXTIME(875996580);
+---------------------------------------------------------+
| FROM_UNIXTIME(875996580)                                |
+---------------------------------------------------------+
| 1997-10-04 22:23:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

HORA (hora)

Retorna a hora para o tempo. O intervalo do valor de retorno é de 0 a 23 para valores de hora do dia. No entanto, o intervalo de valores TIME é, na verdade, muito maior, então HOUR pode retornar valores maiores que 23.

mysql> SELECT HOUR('10:05:03');
+---------------------------------------------------------+
| HOUR('10:05:03')                                        |
+---------------------------------------------------------+
| 10                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LAST_DAY (data)

Obtém um valor de data ou data e hora e retorna o valor correspondente para o último dia do mês. Retorna NULL se o argumento for inválido.

mysql> SELECT LAST_DAY('2003-02-05');
+---------------------------------------------------------+
| LAST_DAY('2003-02-05')                                  |
+---------------------------------------------------------+
| 2003-02-28                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LOCALTIME e LOCALTIME ()

LOCALTIME e LOCALTIME () são sinônimos para NOW ().

LOCALTIMESTAMP e LOCALTIMESTAMP ()

LOCALTIMESTAMP e LOCALTIMESTAMP () são sinônimos para NOW ().

MAKEDATE (ano, dia do ano)

Retorna uma data, dados os valores de ano e dia do ano. O valor dayofyear deve ser maior que 0 ou o resultado será NULL.

mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);
+---------------------------------------------------------+
| MAKEDATE(2001,31), MAKEDATE(2001,32)                    |
+---------------------------------------------------------+
| '2001-01-31', '2001-02-01'                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MAKETIME (hora, minuto, segundo)

Retorna um valor de tempo calculado a partir dos argumentos de hora, minuto e segundo.

mysql> SELECT MAKETIME(12,15,30);
+---------------------------------------------------------+
| MAKETIME(12,15,30)                                      |
+---------------------------------------------------------+
| '12:15:30'                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MICROSEGUNDO (expr)

Retorna os microssegundos da expressão de hora ou data e hora (expr) como um número no intervalo de 0 a 999999.

mysql> SELECT MICROSECOND('12:00:00.123456');
+---------------------------------------------------------+
| MICROSECOND('12:00:00.123456')                          |
+---------------------------------------------------------+
| 123456                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MINUTE (hora)

Retorna o minuto para hora, no intervalo de 0 a 59.

mysql> SELECT MINUTE('98-02-03 10:05:03');
+---------------------------------------------------------+
| MINUTE('98-02-03 10:05:03')                             |
+---------------------------------------------------------+
| 5                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Data do mês)

Retorna o mês da data, no intervalo de 0 a 12.

mysql> SELECT MONTH('1998-02-03')
+---------------------------------------------------------+
| MONTH('1998-02-03')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MONTHNAME (data)

Retorna o nome completo do mês para uma data.

mysql> SELECT MONTHNAME('1998-02-05');
+---------------------------------------------------------+
| MONTHNAME('1998-02-05')                                 |
+---------------------------------------------------------+
| February                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

AGORA()

Retorna a data e a hora atuais como um valor no formato 'AAAA-MM-DD HH: MM: SS' ou AAAAMMDDHHMMSS, dependendo se a função é usada em uma string ou contexto numérico. Este valor é expresso no fuso horário atual.

mysql> SELECT NOW();
+---------------------------------------------------------+
| NOW()                                                   |
+---------------------------------------------------------+
| 1997-12-15 23:50:26                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIOD_ADD (P, N)

Adiciona N meses a um período P (no formato YYMM ou YYYYMM). Retorna um valor no formato AAAAMM. Observe que o argumento de período P não é um valor de data.

mysql> SELECT PERIOD_ADD(9801,2);
+---------------------------------------------------------+
| PERIOD_ADD(9801,2)                                      |
+---------------------------------------------------------+
| 199803                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIOD_DIFF (P1, P2)

Retorna o número de meses entre os períodos P1 e P2. Esses períodos P1 e P2 devem estar no formato YYMM ou YYYYMM. Observe que os argumentos de período P1 e P2 não são valores de data.

mysql> SELECT PERIOD_DIFF(9802,199703);
+---------------------------------------------------------+
| PERIOD_DIFF(9802,199703)                                |
+---------------------------------------------------------+
| 11                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

QUARTER (data)

Retorna o trimestre do ano para a data, no intervalo de 1 a 4.

mysql> SELECT QUARTER('98-04-01');
+---------------------------------------------------------+
| QUARTER('98-04-01')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Segundo tempo)

Retorna o segundo para o tempo, no intervalo de 0 a 59.

mysql> SELECT SECOND('10:05:03');
+---------------------------------------------------------+
| SECOND('10:05:03')                                      |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SEC_TO_TIME (segundos)

Retorna o argumento de segundos, convertido em horas, minutos e segundos, como um valor no formato 'HH: MM: SS' ou HHMMSS, dependendo se a função é usada em uma string ou contexto numérico.

mysql> SELECT SEC_TO_TIME(2378);
+---------------------------------------------------------+
| SEC_TO_TIME(2378)                                       |
+---------------------------------------------------------+
| 00:39:38                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

STR_TO_DATE (str, formato)

Este é o inverso da função DATE_FORMAT (). Leva uma string str e um formato de string de formato. A função STR_TO_DATE () retorna um valor DATETIME se a string de formato contiver partes de data e hora. Caso contrário, ele retorna um valor DATE ou TIME se a string contiver apenas partes de data ou hora.

mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');
+---------------------------------------------------------+
| STR_TO_DATE('04/31/2004', '%m/%d/%Y')                   |
+---------------------------------------------------------+
| 2004-04-31                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBDATE (data, unidade expr INTERVAL) e SUBDATE (expr, dias)

Quando invocado com a forma INTERVAL do segundo argumento, SUBDATE () é um sinônimo para DATE_SUB (). Para obter informações sobre o argumento da unidade INTERVAL, consulte a discussão para DATE_ADD ().

mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_SUB('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| SUBDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBTIME (expr1, expr2)

A função SUBTIME () retorna expr1. expr2 expresso como um valor no mesmo formato que expr1. O valor expr1 é uma expressão de hora ou data e hora, enquanto o valor expr2 é uma expressão de hora.

mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999',
   -> '1 1:1:1.000002');
+---------------------------------------------------------+
| SUBTIME('1997-12-31 23:59:59.999999'...                 |
+---------------------------------------------------------+
| 1997-12-30 22:58:58.999997                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SYSDATE ()

Retorna a data e a hora atuais como um valor no formato 'AAAA-MM-DD HH: MM: SS' ou AAAAMMDDHHMMSS, dependendo se a função é usada em uma string ou em um contexto numérico.

mysql> SELECT SYSDATE();
+---------------------------------------------------------+
| SYSDATE()                                               |
+---------------------------------------------------------+
| 2006-04-12 13:47:44                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME (expr)

Extrai a parte da hora da expressão de hora ou data e hora expr e o retorna como uma string.

mysql> SELECT TIME('2003-12-31 01:02:03');
+---------------------------------------------------------+
| TIME('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
| 01:02:03                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMEDIFF (expr1, expr2)

A função TIMEDIFF () retorna expr1. expr2 expresso como um valor de tempo. Esses valores expr1 e expr2 são expressões de hora ou data e hora, mas ambas devem ser do mesmo tipo.

mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',
   -> '1997-12-30 01:01:01.000002');
+---------------------------------------------------------+
| TIMEDIFF('1997-12-31 23:59:59.000001'.....              |
+---------------------------------------------------------+
|  46:58:57.999999                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMP (expr), TIMESTAMP (expr1, expr2)

Com um único argumento, esta função retorna a data ou expressão datetime expr como um valor datetime. Com dois argumentos, ele adiciona a expressão de tempo expr2 à expressão de data ou data e horaexpr1 e retorna o resultado como um valor de data e hora.

mysql> SELECT TIMESTAMP('2003-12-31');
+---------------------------------------------------------+
| TIMESTAMP('2003-12-31')                                 |
+---------------------------------------------------------+
| 2003-12-31 00:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPADD (unidade, intervalo, datetime_expr)

Esta função adiciona o intervalo da expressão de número inteiro à expressão de data ou data e hora datetime_expr. A unidade para o intervalo é dada pelo argumento da unidade, que deve ser um dos seguintes valores -

FRAC_SECOND
SEGUNDO, MINUTO
HORA, DIA
WEEK
MONTH
QUARTER ou
YEAR

O valor da unidade pode ser especificado usando uma das palavras-chave conforme mostrado ou com um prefixo de SQL_TSI_.

Por exemplo, DAY e SQL_TSI_DAY são legais.

mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
+---------------------------------------------------------+
| TIMESTAMPADD(MINUTE,1,'2003-01-02')                     |
+---------------------------------------------------------+
| 2003-01-02 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPDIFF (unidade, datetime_expr1, datetime_expr2)

Retorna a diferença inteira entre as expressões de data ou data e hora datetime_expr1 e datetime_expr2. A unidade do resultado é fornecida pelo argumento da unidade. Os valores legais para a unidade são iguais aos listados na descrição da função TIMESTAMPADD ().

mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
+---------------------------------------------------------+
| TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01')          |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_FORMAT (hora, formato)

Esta função é usada como a função DATE_FORMAT (), mas a string de formato pode conter especificadores de formato apenas para horas, minutos e segundos.

Se o valor da hora contiver uma parte da hora maior que 23, a%H e%k Os especificadores de formato de hora produzem um valor maior do que o intervalo normal de 0 a 23. Os outros especificadores de formato de hora produzem o módulo de valor de hora 12.

mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
+---------------------------------------------------------+
| TIME_FORMAT('100:00:00', '%H %k %h %I %l')              |
+---------------------------------------------------------+
| 100 100 04 04 4                                         |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_TO_SEC (hora)

Retorna o argumento de tempo convertido em segundos.

mysql> SELECT TIME_TO_SEC('22:23:00');
+---------------------------------------------------------+
| TIME_TO_SEC('22:23:00')                                 |
+---------------------------------------------------------+
| 80580                                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Data de hoje)

Dada uma data, retorna um número de dia (o número de dias desde o ano 0).

mysql> SELECT TO_DAYS(950501);
+---------------------------------------------------------+
| TO_DAYS(950501)                                         |
+---------------------------------------------------------+
| 728779                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UNIX_TIMESTAMP (), UNIX_TIMESTAMP (data)

Se chamada sem nenhum argumento, esta função retorna um timestamp Unix (segundos desde '1970-01-01 00:00:00' UTC) como um inteiro sem sinal. Se UNIX_TIMESTAMP () for chamado com um argumento de data, ele retornará o valor do argumento como segundos desde '1970-01-01 00:00:00' UTC. data pode ser uma string DATE, uma string DATETIME, um TIMESTAMP ou um número no formato AAMMDD ou AAAAMMDD.

mysql> SELECT UNIX_TIMESTAMP();
+---------------------------------------------------------+
| UNIX_TIMESTAMP()                                        |
+---------------------------------------------------------+
| 882226357                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
+---------------------------------------------------------+
| UNIX_TIMESTAMP('1997-10-04 22:23:00')                   |
+---------------------------------------------------------+
| 875996580                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_DATE, UTC_DATE ()

Retorna a data UTC atual como um valor no formato 'AAAA-MM-DD' ou AAAAMMDD, dependendo se a função é usada em uma string ou contexto numérico.

mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
+---------------------------------------------------------+
| UTC_DATE(), UTC_DATE() + 0                              |
+---------------------------------------------------------+
| 2003-08-14, 20030814                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIME, UTC_TIME ()

Retorna a hora UTC atual como um valor no formato 'HH: MM: SS' ou HHMMSS, dependendo se a função é usada em uma string ou contexto numérico.

mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
+---------------------------------------------------------+
| UTC_TIME(), UTC_TIME() + 0                              |
+---------------------------------------------------------+
| 18:07:53, 180753                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIMESTAMP, UTC_TIMESTAMP ()

Retorna a data e hora UTC atual como um valor em 'AAAA-MM-DD HH: MM: SS' ou em um formato AAAAMMDDHHMMSS, dependendo se a função é usada em uma string ou em um contexto numérico.

mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
+---------------------------------------------------------+
| UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0                    |
+---------------------------------------------------------+
| 2003-08-14 18:08:04, 20030814180804                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SEMANA (data [, modo])

Esta função retorna o número da semana para a data. A forma de dois argumentos de WEEK () permite que você especifique se a semana começa em um domingo ou segunda-feira e se o valor de retorno deve estar no intervalo de 0 a 53 ou de 1 a 53. Se o argumento de modo for omitido, o valor da variável de sistema default_week_format é usado

Modo	Primeiro dia da semana	Alcance	A semana 1 é a primeira semana.
0	Domigo	0-53	com um domingo neste ano
1	Segunda-feira	0-53	com mais de 3 dias este ano
2	Domigo	1-53	com um domingo neste ano
3	Segunda-feira	1-53	com mais de 3 dias este ano
4	Domigo	0-53	com mais de 3 dias este ano
5	Segunda-feira	0-53	com uma segunda-feira neste ano
6	Domigo	1-53	com mais de 3 dias este ano
7	Segunda-feira	1-53	com uma segunda-feira neste ano

mysql> SELECT WEEK('1998-02-20');
+---------------------------------------------------------+
| WEEK('1998-02-20')                                      |
+---------------------------------------------------------+
| 7                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WEEKDAY (data)

Retorna o índice do dia da semana para a data (0 = segunda-feira, 1 = terça-feira,. 6 = domingo).

mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
+---------------------------------------------------------+
| WEEKDAY('1998-02-03 22:23:00')                          |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WEEKOFYEAR (data)

Retorna a semana do calendário da data como um número no intervalo de 1 a 53. WEEKOFYEAR () é uma função de compatibilidade equivalente a WEEK (data, 3).

mysql> SELECT WEEKOFYEAR('1998-02-20');
+---------------------------------------------------------+
| WEEKOFYEAR('1998-02-20')                                |
+---------------------------------------------------------+
| 8                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ANO (data)

Retorna o ano para a data, no intervalo de 1000 a 9999, ou 0 para o .zero. encontro.

mysql> SELECT YEAR('98-02-03');
+---------------------------------------------------------+
| YEAR('98-02-03')                                        |
+---------------------------------------------------------+
| 1998                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

YEARWEEK (data), YEARWEEK (data, modo)

Retorna o ano e a semana para uma data. O argumento de modo funciona exatamente como o argumento de modo para a função WEEK (). O ano no resultado pode ser diferente do ano no argumento de data para a primeira e a última semana do ano.

mysql> SELECT YEARWEEK('1987-01-01');
+---------------------------------------------------------+
| YEAR('98-02-03')YEARWEEK('1987-01-01')                  |
+---------------------------------------------------------+
| 198653                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Note - O número da semana é diferente do que a função WEEK () retornaria (0) para os argumentos opcionais 0 ou 1, pois WEEK () retorna a semana no contexto do ano fornecido.

SQL - Tabelas Temporárias

O que são tabelas temporárias?

Existem RDBMS, que suportam tabelas temporárias. Tabelas temporárias são um ótimo recurso que permite que vocêstore and process intermediate results usando os mesmos recursos de seleção, atualização e junção que você pode usar com tabelas típicas do SQL Server.

As tabelas temporárias podem ser muito úteis em alguns casos para manter dados temporários. A coisa mais importante que deve ser conhecida sobre as tabelas temporárias é que elas serão excluídas quando a sessão atual do cliente terminar.

As tabelas temporárias estão disponíveis no MySQL versão 3.23 em diante. Se você usar uma versão anterior do MySQL que 3.23, você não pode usar tabelas temporárias, mas você pode usarheap tables.

Conforme declarado anteriormente, as tabelas temporárias durarão apenas enquanto a sessão estiver ativa. Se você executar o código em um script PHP, a tabela temporária será destruída automaticamente quando a execução do script terminar. Se você estiver conectado ao servidor de banco de dados MySQL por meio do programa cliente MySQL, a tabela temporária existirá até que você feche o cliente ou destrua manualmente a tabela.

Exemplo

Aqui está um exemplo que mostra o uso de uma mesa temporária.

mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SALESSUMMARY
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SALESSUMMARY;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber     |      100.25 |          90.00 |                2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)

Ao emitir um comando SHOW TABLES, sua tabela temporária não será listada na lista. Agora, se você efetuar logout da sessão MySQL e emitir um comando SELECT, não encontrará dados disponíveis no banco de dados. Mesmo sua mesa temporária não existirá.

Eliminando Tabelas Temporárias

Por padrão, todas as tabelas temporárias são excluídas pelo MySQL quando sua conexão com o banco de dados é encerrada. Ainda assim, se você quiser excluí-los no meio, você pode fazer isso emitindo umDROP TABLE comando.

A seguir está um exemplo de descartar uma mesa temporária.

mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SALESSUMMARY
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SALESSUMMARY;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber     |      100.25 |          90.00 |                2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)
mysql> DROP TABLE SALESSUMMARY;
mysql>  SELECT * FROM SALESSUMMARY;
ERROR 1146: Table 'TUTORIALS.SALESSUMMARY' doesn't exist

SQL - Clonar tabelas

Pode haver uma situação em que você precise de uma cópia exata de uma tabela e os comandos CREATE TABLE ... ou SELECT ... não atendam aos seus propósitos porque a cópia deve incluir os mesmos índices, valores padrão e assim por diante.

Se você estiver usando MySQL RDBMS, você pode lidar com esta situação seguindo as etapas abaixo -

Use o comando SHOW CREATE TABLE para obter uma instrução CREATE TABLE que especifica a estrutura da tabela de origem, índices e tudo.
Modifique a instrução para alterar o nome da tabela para aquele da tabela clone e execute a instrução. Desta forma, você terá uma tabela de clones exata.
Opcionalmente, se você também precisar que o conteúdo da tabela seja copiado, emita uma instrução INSERT INTO ou SELECT também.

Exemplo

Experimente o seguinte exemplo para criar uma tabela clone para TUTORIALS_TBL cuja estrutura é a seguinte -

Step 1 - Obtenha a estrutura completa sobre a mesa.

SQL> SHOW CREATE TABLE TUTORIALS_TBL \G; 
*************************** 1. row *************************** 
      Table: TUTORIALS_TBL 
Create Table: CREATE TABLE 'TUTORIALS_TBL' ( 
  'tutorial_id' int(11) NOT NULL auto_increment, 
  'tutorial_title' varchar(100) NOT NULL default '', 
  'tutorial_author' varchar(40) NOT NULL default '', 
  'submission_date' date default NULL, 
  PRIMARY KEY  ('tutorial_id'), 
  UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author') 
) TYPE = MyISAM 
1 row in set (0.00 sec)

Step 2 - Renomeie esta tabela e crie outra.

SQL> CREATE TABLE `CLONE_TBL` ( 
  -> 'tutorial_id' int(11) NOT NULL auto_increment, 
  -> 'tutorial_title' varchar(100) NOT NULL default '', 
  -> 'tutorial_author' varchar(40) NOT NULL default '', 
  -> 'submission_date' date default NULL, 
  -> PRIMARY KEY  (`tutorial_id'), 
  -> UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author') 
-> ) TYPE = MyISAM; 
Query OK, 0 rows affected (1.80 sec)

Step 3- Após executar a etapa 2, você clonará uma tabela em seu banco de dados. Se você deseja copiar dados de uma tabela antiga, pode fazê-lo usando a instrução INSERT INTO ... SELECT.

SQL> INSERT INTO CLONE_TBL (tutorial_id, 
   ->                        tutorial_title, 
   ->                        tutorial_author, 
   ->                        submission_date) 
   -> SELECT tutorial_id,tutorial_title, 
   ->        tutorial_author,submission_date, 
   -> FROM TUTORIALS_TBL; 
Query OK, 3 rows affected (0.07 sec) 
Records: 3  Duplicates: 0  Warnings: 0

Por fim, você terá uma tabela de clones exata que deseja.

SQL - Subconsultas

Uma consulta subconsulta ou interna ou uma consulta aninhada é uma consulta em outra consulta SQL e incorporada na cláusula WHERE.

Uma subconsulta é usada para retornar dados que serão usados na consulta principal como uma condição para restringir ainda mais os dados a serem recuperados.

As subconsultas podem ser usadas com as instruções SELECT, INSERT, UPDATE e DELETE junto com os operadores como =, <,>,> =, <=, IN, BETWEEN, etc.

Existem algumas regras que as subconsultas devem seguir -

As subconsultas devem ser colocadas entre parênteses.
Uma subconsulta pode ter apenas uma coluna na cláusula SELECT, a menos que várias colunas estejam na consulta principal da subconsulta para comparar suas colunas selecionadas.
Um comando ORDER BY não pode ser usado em uma subconsulta, embora a consulta principal possa usar um ORDER BY. O comando GROUP BY pode ser usado para executar a mesma função que ORDER BY em uma subconsulta.
Subconsultas que retornam mais de uma linha só podem ser usadas com vários operadores de valor, como o operador IN.
A lista SELECT não pode incluir nenhuma referência a valores que avaliam para um BLOB, ARRAY, CLOB ou NCLOB.
Uma subconsulta não pode ser imediatamente incluída em uma função definida.
O operador BETWEEN não pode ser usado com uma subconsulta. No entanto, o operador BETWEEN pode ser usado na subconsulta.

Subconsultas com a instrução SELECT

As subconsultas são usadas com mais freqüência com a instrução SELECT. A sintaxe básica é a seguinte -

SELECT column_name [, column_name ]
FROM   table1 [, table2 ]
WHERE  column_name OPERATOR
   (SELECT column_name [, column_name ]
   FROM table1 [, table2 ]
   [WHERE])

Exemplo

Considere a tabela CLIENTES com os seguintes registros -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Agora, vamos verificar a seguinte subconsulta com uma instrução SELECT.

SQL> SELECT * 
   FROM CUSTOMERS 
   WHERE ID IN (SELECT ID 
         FROM CUSTOMERS 
         WHERE SALARY > 4500) ;

Isso produziria o seguinte resultado.

+----+----------+-----+---------+----------+
| ID | NAME     | AGE | ADDRESS | SALARY   |
+----+----------+-----+---------+----------+
|  4 | Chaitali |  25 | Mumbai  |  6500.00 |
|  5 | Hardik   |  27 | Bhopal  |  8500.00 |
|  7 | Muffy    |  24 | Indore  | 10000.00 |
+----+----------+-----+---------+----------+

Subconsultas com a instrução INSERT

As subconsultas também podem ser usadas com instruções INSERT. A instrução INSERT usa os dados retornados da subconsulta para inserir em outra tabela. Os dados selecionados na subconsulta podem ser modificados com qualquer uma das funções de caractere, data ou número.

A sintaxe básica é a seguinte.

INSERT INTO table_name [ (column1 [, column2 ]) ]
   SELECT [ *|column1 [, column2 ]
   FROM table1 [, table2 ]
   [ WHERE VALUE OPERATOR ]

Exemplo

Considere uma tabela CUSTOMERS_BKP com estrutura semelhante à tabela CUSTOMERS. Agora, para copiar a tabela CUSTOMERS completa para a tabela CUSTOMERS_BKP, você pode usar a seguinte sintaxe.

SQL> INSERT INTO CUSTOMERS_BKP
   SELECT * FROM CUSTOMERS 
   WHERE ID IN (SELECT ID 
   FROM CUSTOMERS) ;

Subconsultas com a instrução UPDATE

A subconsulta pode ser usada em conjunto com a instrução UPDATE. Tanto uma coluna quanto várias colunas em uma tabela podem ser atualizadas ao usar uma subconsulta com a instrução UPDATE.

A sintaxe básica é a seguinte.

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Exemplo

Assumindo que temos a tabela CUSTOMERS_BKP disponível, que é o backup da tabela CUSTOMERS. O exemplo a seguir atualiza SALÁRIO em 0,25 vezes na tabela CUSTOMERS para todos os clientes cuja IDADE seja maior ou igual a 27.

SQL> UPDATE CUSTOMERS
   SET SALARY = SALARY * 0.25
   WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
      WHERE AGE >= 27 );

Isso afetaria duas linhas e, finalmente, a tabela CUSTOMERS teria os seguintes registros.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |   125.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  2125.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Subconsultas com a instrução DELETE

A subconsulta pode ser usada em conjunto com a instrução DELETE como com qualquer outra instrução mencionada acima.

A sintaxe básica é a seguinte.

DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Exemplo

Supondo que tenhamos uma tabela CUSTOMERS_BKP disponível, que é um backup da tabela CUSTOMERS. O exemplo a seguir exclui os registros da tabela CUSTOMERS para todos os clientes cuja IDADE seja maior ou igual a 27.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
      WHERE AGE >= 27 );

Isso impactaria duas linhas e, finalmente, a tabela CUSTOMERS teria os seguintes registros.

+----+----------+-----+---------+----------+
| ID | NAME     | AGE | ADDRESS | SALARY   |
+----+----------+-----+---------+----------+
|  2 | Khilan   |  25 | Delhi   |  1500.00 |
|  3 | kaushik  |  23 | Kota    |  2000.00 |
|  4 | Chaitali |  25 | Mumbai  |  6500.00 |
|  6 | Komal    |  22 | MP      |  4500.00 |
|  7 | Muffy    |  24 | Indore  | 10000.00 |
+----+----------+-----+---------+----------+

SQL - usando sequências

Uma sequência é um conjunto de inteiros 1, 2, 3, ... que são gerados em ordem sob demanda. As sequências são frequentemente usadas em bancos de dados porque muitos aplicativos exigem que cada linha de uma tabela contenha um valor exclusivo e as sequências fornecem uma maneira fácil de gerá-los.

Este capítulo descreve como usar sequências no MySQL.

Usando coluna AUTO_INCREMENT

A maneira mais simples no MySQL de usar sequências é definir uma coluna como AUTO_INCREMENT e deixar o resto para o MySQL cuidar.

Exemplo

Experimente o seguinte exemplo. Isso criará uma tabela e depois disso irá inserir algumas linhas nesta tabela onde não é necessário fornecer um ID de registro porque é auto-incrementado pelo MySQL.

mysql> CREATE TABLE INSECT
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);
Query OK, 0 rows affected (0.02 sec)
mysql> INSERT INTO INSECT (id,name,date,origin) VALUES
   -> (NULL,'housefly','2001-09-10','kitchen'),
   -> (NULL,'millipede','2001-09-10','driveway'),
   -> (NULL,'grasshopper','2001-09-10','front yard');
Query OK, 3 rows affected (0.02 sec)
Records: 3  Duplicates: 0  Warnings: 0
mysql> SELECT * FROM INSECT ORDER BY id;
+----+-------------+------------+------------+
| id | name        | date       | origin     |
+----+-------------+------------+------------+
|  1 | housefly    | 2001-09-10 | kitchen    |
|  2 | millipede   | 2001-09-10 | driveway   |
|  3 | grasshopper | 2001-09-10 | front yard |
+----+-------------+------------+------------+
3 rows in set (0.00 sec)

Obtenha os valores AUTO_INCREMENT

O LAST_INSERT_ID () é uma função SQL, então você pode usá-lo de dentro de qualquer cliente que saiba como emitir instruções SQL. Caso contrário, os scripts PERL e PHP fornecem funções exclusivas para recuperar o valor auto-incrementado do último registro.

Exemplo PERL

Use o mysql_insertidatributo para obter o valor AUTO_INCREMENT gerado por uma consulta. Este atributo é acessado por meio de um identificador de banco de dados ou um identificador de instrução, dependendo de como você emite a consulta. O exemplo a seguir faz referência a ele por meio do identificador do banco de dados.

$dbh->do ("INSERT INTO INSECT (name,date,origin) VALUES('moth','2001-09-14','windowsill')"); my $seq = $dbh->{mysql_insertid};

Exemplo de PHP

Depois de emitir uma consulta que gere um valor AUTO_INCREMENT, recupere o valor chamando o mysql_insert_id( ) função.

mysql_query ("INSERT INTO INSECT (name,date,origin)
VALUES('moth','2001-09-14','windowsill')", $conn_id);
$seq = mysql_insert_id ($conn_id);

Renumerando uma sequência existente

Pode haver um caso em que você tenha excluído muitos registros de uma tabela e queira reordenar todos os registros. Isso pode ser feito usando um truque simples, mas você deve ter muito cuidado ao fazer isso e verificar se sua mesa está tendo uma junção com outra mesa ou não.

Se você determinar que o novo sequenciamento de uma coluna AUTO_INCREMENT é inevitável, a maneira de fazer isso é remover a coluna da tabela e adicioná-la novamente.

O exemplo a seguir mostra como renumerar os valores de id na tabela de insetos usando esta técnica.

mysql> ALTER TABLE INSECT DROP id;
mysql> ALTER TABLE insect
   -> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
   -> ADD PRIMARY KEY (id);

Iniciando uma sequência em um valor particular

Por padrão, o MySQL iniciará a sequência de 1, mas você pode especificar qualquer outro número também no momento da criação da tabela.

O bloco de código a seguir tem um exemplo em que o MySQL iniciará a sequência de 100.

mysql> CREATE TABLE INSECT
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT = 100,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);

Como alternativa, você pode criar a tabela e definir o valor da sequência inicial com ALTER TABLE.

mysql> ALTER TABLE t AUTO_INCREMENT = 100;

SQL - Tratamento de duplicatas

Pode haver uma situação em que você tenha vários registros duplicados em uma tabela. Ao buscar esses registros, faz mais sentido buscar apenas registros únicos em vez de buscar registros duplicados.

O SQL DISTINCT A palavra-chave, que já discutimos, é usada em conjunto com a instrução SELECT para eliminar todos os registros duplicados e buscar apenas os registros únicos.

Sintaxe

A sintaxe básica de uma palavra-chave DISTINCT para eliminar registros duplicados é a seguinte.

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

Exemplo

Considere a tabela CUSTOMERS com os seguintes registros.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Primeiro, vamos ver como a seguinte consulta SELECT retorna registros de salários duplicados.

SQL> SELECT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Isso produziria o seguinte resultado, em que o salário de 2000 está chegando duas vezes, o que é um registro duplicado da tabela original.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

Agora, vamos usar a palavra-chave DISTINCT com a consulta SELECT acima e ver o resultado.

SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Isso produziria o seguinte resultado, onde não temos nenhuma entrada duplicada.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

Injeção SQL

Se você pegar a entrada de um usuário por meio de uma página da web e inseri-la em um banco de dados SQL, há uma chance de você ter se deixado vulnerável a um problema de segurança conhecido como SQL Injection. Este capítulo irá ensiná-lo como ajudar a evitar que isso aconteça e ajudá-lo a proteger seus scripts e instruções SQL em seus scripts do lado do servidor, como um script PERL.

A injeção geralmente ocorre quando você pede a entrada de um usuário, como seu nome e, em vez de um nome, eles fornecem uma instrução SQL que você executará inadvertidamente em seu banco de dados. Nunca confie nos dados fornecidos pelo usuário, processe esses dados somente após a validação; como regra, isso é feito porPattern Matching.

No exemplo abaixo, o name é restrito aos caracteres alfanuméricos mais sublinhados e a um comprimento entre 8 e 20 caracteres (modifique essas regras conforme necessário).

if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches)) { $result = mysql_query("SELECT * FROM CUSTOMERS 
      WHERE name = $matches[0]");
} else {
   echo "user name not accepted";
}

Para demonstrar o problema, considere este trecho -

// supposed input
$name = "Qadir'; DELETE FROM CUSTOMERS;";
mysql_query("SELECT * FROM CUSTOMSRS WHERE name='{$name}'");

A chamada de função deve recuperar um registro da tabela CUSTOMERS onde a coluna de nome corresponde ao nome especificado pelo usuário. Sob circunstâncias normais,$nameconteria apenas caracteres alfanuméricos e talvez espaços, como a string ilia. Mas aqui, ao anexar uma consulta inteiramente nova a $ name, a chamada para o banco de dados se transforma em um desastre; a consulta DELETE injetada remove todos os registros da tabela CUSTOMERS.

Felizmente, se você usa MySQL, o mysql_query()função não permite o empilhamento de consultas ou a execução de várias consultas SQL em uma única chamada de função. Se você tentar empilhar consultas, a chamada falhará.

No entanto, outras extensões de banco de dados PHP, como SQLite e PostgreSQL felizmente execute consultas empilhadas, executando todas as consultas fornecidas em uma string e criando um sério problema de segurança.

Prevenção de injeção de SQL

Você pode lidar com todos os caracteres de escape de forma inteligente em linguagens de script como PERL e PHP. A extensão MySQL para PHP fornece a funçãomysql_real_escape_string() para escapar de caracteres de entrada que são especiais para MySQL.

if (get_magic_quotes_gpc()) {
   $name = stripslashes($name); } $name = mysql_real_escape_string($name); mysql_query("SELECT * FROM CUSTOMERS WHERE name='{$name}'");

O dilema LIKE

Para resolver o dilema LIKE, um mecanismo de escape personalizado deve converter os caracteres '%' e '_' fornecidos pelo usuário em literais. Usaraddcslashes(), uma função que permite especificar um intervalo de caracteres para o escape.

$sub = addcslashes(mysql_real_escape_string("%str"), "%_"); // $sub == \%str\_
mysql_query("SELECT * FROM messages 
   WHERE subject LIKE '{$sub}%'");

SQL - ajuste de banco de dados

Leva tempo para se tornar um especialista em banco de dados ou um administrador de banco de dados especialista. Tudo isso vem com muita experiência em vários designs de banco de dados e bons treinamentos.

Mas a lista a seguir pode ser útil para que os iniciantes tenham um bom desempenho de banco de dados -

Use o design de banco de dados 3BNF explicado neste tutorial no capítulo Conceitos de RDBMS.
Evite conversões de número para caractere porque os números e os caracteres se comparam de maneira diferente e levam ao rebaixamento do desempenho.
Ao usar a instrução SELECT, busque apenas as informações necessárias e evite usar * em suas consultas SELECT porque isso carregaria o sistema desnecessariamente.
Crie seus índices cuidadosamente em todas as tabelas onde você tem operações de pesquisa frequentes. Evite indexar nas tabelas onde você tem menos número de operações de pesquisa e mais número de operações de inserção e atualização.
Uma varredura de tabela completa ocorre quando as colunas na cláusula WHERE não têm um índice associado a elas. Você pode evitar uma varredura de tabela completa criando um índice nas colunas que são usadas como condições na cláusula WHERE de uma instrução SQL.
Tenha muito cuidado com os operadores de igualdade com números reais e valores de data / hora. Ambos podem ter pequenas diferenças que não são óbvias a olho nu, mas que tornam uma correspondência exata impossível, evitando que suas consultas retornem linhas.
Use a correspondência de padrões criteriosamente. LIKE COL% é uma condição WHERE válida, reduzindo o conjunto retornado apenas para os registros com dados começando com a string COL. No entanto, COL% Y não reduz ainda mais o conjunto de resultados retornados, pois% Y não pode ser avaliado com eficácia. O esforço para fazer a avaliação é muito grande para ser considerado. Nesse caso, o COL% é usado, mas o% Y é jogado fora. Pelo mesmo motivo, um caractere curinga% COL evita efetivamente que o filtro inteiro seja usado.
Ajuste suas consultas SQL examinando a estrutura das consultas (e subconsultas), a sintaxe SQL, para descobrir se você projetou suas tabelas para suportar a manipulação rápida de dados e escreveu a consulta de maneira ideal, permitindo que seu SGBD manipule os dados com eficiência .
Para consultas que são executadas regularmente, tente usar procedimentos. Um procedimento é um grupo potencialmente grande de instruções SQL. Os procedimentos são compilados pelo mecanismo de banco de dados e, em seguida, executados. Ao contrário de uma instrução SQL, o mecanismo de banco de dados não precisa otimizar o procedimento antes de ser executado.
Evite usar o operador lógico OR em uma consulta, se possível. OU inevitavelmente diminui a velocidade de quase qualquer consulta em uma tabela de tamanho substancial.
Você pode otimizar as cargas de dados em massa descartando os índices. Imagine a tabela de histórico com muitos milhares de linhas. Essa tabela de histórico também provavelmente terá um ou mais índices. Quando você pensa em um índice, normalmente pensa em um acesso mais rápido à tabela, mas no caso de carregamentos em lote, você pode se beneficiar eliminando o (s) índice (s).
Ao executar transações em lote, execute COMMIT após um bom número de criação de registros, em vez de criá-los após cada criação de registro.
Planeje a desfragmentação do banco de dados regularmente, mesmo que isso signifique desenvolver uma rotina semanal.

Ferramentas de ajuste integradas

A Oracle tem muitas ferramentas para gerenciar o desempenho da instrução SQL, mas entre elas duas são muito populares. Essas duas ferramentas são -

Explain plan - a ferramenta identifica o caminho de acesso que será percorrido quando a instrução SQL for executada.
tkprof - mede o desempenho por tempo decorrido durante cada fase do processamento da instrução SQL.

Se você deseja simplesmente medir o tempo decorrido de uma consulta no Oracle, pode usar o comando SQL * Plus SET TIMING ON.

Verifique sua documentação RDBMS para obter mais detalhes sobre as ferramentas mencionadas acima e desfragmentar o banco de dados.