quarta-feira, 19 de fevereiro de 2014

Entendendo o comando Join SLQ

Fala galera! Venho aqui neste post, mostrar à você que não entendei muito dos comandos Joins em sql como eles funcionam, e assim, desmitificar essa parada! Vamos lá.

Joins SQL são usados ​​em uma consulta SQL para recuperar dados de várias tabelas. A SQL JOIN é efetuada sempre que duas ou mais tabelas são unidas em uma instrução SQL. 

Existem 4 tipos diferentes de SQL join:

  • SQL INNER JOIN (ou às vezes chamado de join simples)
  • SQL LEFT OUTER JOIN (ou às vezes chamado LEFT JOIN)
  • SQL RIGHT OUTER JOIN (ou às vezes chamado RIGHT JOIN)
  • SQL FULL OUTER JOIN (ou às vezes chamado FULL JOIN)

Você já deve ter escrito uma instrução SQL que usa um INNER JOIN. É o tipo mais comum de Join. SQL INNER JOINS retornam todas as linhas de várias tabelas onde a condição de junção é satisfeita. 

SQL INNER JOIN SINTAXE  

A sintaxe para o SQL INNER JOIN é:


SELECT columns
FROM table1 
INNER JOIN table2
ON table1.column = table2.column;

ILUSTRAÇÃO VISUAL DE SQL INNER JOIN

Neste diagrama visual, o SQL INNER JOIN retorna a área sombreada:

SQL

O SQL INNER JOIN retornaria os registros onde tabela1 e tabela2 se cruzam.

SQL INNER JOIN EXEMPLOS

Aqui está um exemplo de uma INNER SQL JOIN:


SELECT suppliers.supplier_id, suppliers.supplier_name, orders.order_date
FROM suppliers 
INNER JOIN orders
ON suppliers.supplier_id = orders.supplier_id;
Este SQL INNER JOIN iria retornar todas as linhas dos fornecedores e mesas de encomendas onde há um valor supplier_id correspondente em ambos os fornecedores e mesas de ordens.

Vejamos alguns dados para explicar como o INNER JOINS trabalham:

Nós temos uma tabela chamada Suppliers com dois campos (supplier_id supplier_name). Ele contém os seguintes dados:

supplier_idsupplier_name
10000IBM
10001Hewlett Packard
10002Microsoft
10003NVIDIA

Nós temos uma outra tabela chamada orders com três campos (ORDER_ID, supplier_id e order_date). Ele contém os seguintes dados:

order_idsupplier_idorder_date
500125100002003/05/12
500126100012003/05/13
500127100042003/05/14

Se executar a instrução SQL (que contém um INNER JOIN) abaixo:


SELECT suppliers.supplier_id, suppliers.supplier_name, orders.order_date
FROM suppliers
INNER JOIN orders
ON suppliers.supplier_id = orders.supplier_id;
Nosso conjunto de resultados ficaria assim:

supplier_idnomeorder_date
10000IBM2003/05/12
10001Hewlett Packard2003/05/13

As linhas para Microsoft e NVIDIA da tabela do Suppliers seria omitida, desde 10002 e 10003 não existem do supplier_id em ambas as tabelas. A linha para 500127 (order_id) da tabela de ordens seria omitido, uma vez que o 10004 supplier_id não existe na tabela de fornecedores.

ANTIGO SQL SINTAXE INNER JOIN

Como nota final, vale a pena mencionar que o SQL INNER JOIN acima poderia ser reescrita usando a sintaxe implícita mais velha da seguinte forma (mas ainda recomendo usar o INNER JOIN com palavra-chave):


SELECT suppliers.supplier_id, suppliers.supplier_name, orders.order_date
FROM suppliers, orders
WHERE suppliers.supplier_id = orders.supplier_id;

SQL LEFT OUTER JOIN

Outro tipo de associação é chamada de LEFT OUTER JOIN . Este tipo de JOIN retorna todas as linhas da tabela da esquerda especificadas na condição ON e apenas as linhas da outra tabela onde os campos associados são iguais (se a junção da condição for atendida).

SQL LEFT OUTER JOIN SINTAXE

A sintaxe para o SQL LEFT OUTER JOIN é:


SELECT columns
FROM table1
LEFT [OUTER] JOIN table2
ON table1.column = table2.column;
Em alguns bancos de dados, o LEFT OUTER JOIN com palavras-chave são substituídos por LEFT JOIN.

VISUAL ILUSTRAÇÃO DE SQL LEFT OUTER JOIN

Neste diagrama visual, o SQL LEFT OUTER JOIN retorna a área sombreada:

SQL

O SQL LEFT OUTER JOIN retornaria os todos os registros da tabela 1 e somente os registros da tabela2 que se cruzam com a tabela 1 .

SQL LEFT OUTER JOIN EXEMPLOS

Aqui está um exemplo de um SQL junção externa esquerda:


SELECT suppliers.supplier_id, suppliers.supplier_name, orders.order_date
FROM suppliers
LEFT OUTER JOIN orders
ON suppliers.supplier_id = orders.supplier_id;
Este LEFT OUTER JOIN iria retornar todas as linhas da tabela de Suppliers e apenas as linhas da tabela de pedidos, onde os campos associados são iguais.

Se um valor supplier_id na tabela de Suppliers não existe na tabela de pedidos, todos os campos na tabela de orders será exibido como <null> no conjunto de resultados.
Vejamos alguns dados para explicar como LEFT OUTER JOINS trabalham:

Nós temos uma tabela chamada Suppliers com dois campos (supplier_id e supplier_nome). Ele contém os seguintes dados:

supplier_idsupplier_name
10000IBM
10001Hewlett Packard
10002Microsoft
10003NVIDIA

Temos uma segunda tabela chamada orders com três campos (ORDER_ID, supplier_id e order_date). Ele contém os seguintes dados:

order_idsupplier_idorder_date
500125100002003/05/12
500126100012003/05/13

Se executarmos a instrução SQL (que contém uma associação externa à esquerda):


SELECT suppliers.supplier_id, suppliers.supplier_name, orders.order_date
FROM suppliers
LEFT OUTER JOIN orders
ON suppliers.supplier_id = orders.supplier_id;
Nosso conjunto de resultados ficaria assim:

supplier_idsupplier_nameorder_date
10000IBM2003/05/12
10001Hewlett Packard2003/05/13
10002Microsoft<null>
10003NVIDIA<null>

As linhas para Microsoft e NVIDIA seriam incluída porque um LEFT OUTER JOIN foi usado. No entanto, você vai notar que o campo order_date para esses registros contém um valor <null>.

ANTIGa SINTAXE SQL LEFT OUTER JOIN 

Como nota final, vale a pena mencionar que o LEFT OUTER JOIN acima poderia ser reescrito usando a sintaxe implícita mais velha que utiliza o operador de junção externa (+) da seguinte forma (mas ainda recomendamos o uso do LEFT OUTER JOIN com palavra-chave):


SELECT suppliers.supplier_id, suppliers.supplier_name, orders.order_date
FROM suppliers, orders
WHERE suppliers.supplier_id = orders.supplier_id(+);

SQL RIGHT OUTER JOIN

Outro tipo de associação é chamada de SQL RIGHT OUTER JOIN . Este tipo de JOIN retorna todas as linhas da tabela do lado direito especificados na condição ON e apenas as linhas da outra tabela onde os campos associados são iguais (se a junção da condição for atendida).

RIGHT OUTER JOIN SQL SINTAXE

A sintaxe para o SQL RIGHT OUTER JOIN é:


SELECT columns
FROM table1
RIGHT [OUTER] JOIN table2
ON table1.column = table2.column;
Em alguns bancos de dados, o RIGHT OUTER JOIN com palavras-chave são substituídos por RIGHT JOIN.

VISUAL ILUSTRAÇÃO DE SQL RIGHT OUTER JOIN

Neste diagrama visual, o SQL RIGHT OUTER JOIN retorna a área sombreada:

SQL

O SQL RIGHT OUTER JOIN retornaria os todos os registros da tabela2 e somente os registros da tabela 1 que se cruzam com tabela2 .

SQL RIGHT OUTER JOIN EXEMPLOS

Aqui está um exemplo de um SQL rigth outer join:


SELECT orders.order_id, orders.order_date, suppliers.supplier_name
FROM suppliers
RIGHT OUTER JOIN orders
ON suppliers.supplier_id = orders.supplier_id;
Este RIGHT OUTER JOIN retornaria todas as linhas da tabela de pedidos e apenas as linhas da tabela de suppliers, onde os campos associados são iguais.

Se um valor supplier_id na tabela de pedidos não existe na tabela de suppliers, todos os campos na tabela de suppliers seram apresentado como <null> no conjunto de resultados.

Vejamos alguns dados para explicar como RIGHT OUTER JOINS trabalham:
Nós temos uma tabela chamada suppliers com dois campos (supplier_id e supplier_nome). Ela contém os seguintes dados:

supplier_idsupplier_name
10000Maçã
10001Google

Temos uma segunda tabela chamada orders com três campos (ORDER_ID, supplier_id e order_date). Ela contém os seguintes dados:

order_idsupplier_idorder_date
500125100002013/08/12
500126100012013/08/13
500127100022013/08/14

Se executar a instrução SQL (que contém uma rigth outer join) abaixo:


SELECT orders.order_id, orders.order_date, suppliers.supplier_name
FROM suppliers
RIGHT OUTER JOIN orders
ON suppliers.supplier_id = orders.supplier_id;
Nosso conjunto de resultados ficaria assim:

order_idorder_datesupplier_name
5001252013/08/12Maçã
5001262013/08/13Google
5001272013/08/14<null>

A linha para 500127 (order_id) seriam incluídas porque um RIGHT OUTER JOIN foi usado. No entanto, você vai notar que o campo supplier_name para esse registro contém um valor <null>.

ANTIGO SINTAXE SQL RIGHT OUTER JOIN 

Como nota final, vale a pena mencionar que o RIGHT OUTER JOIN acima poderia ser reescrito usando a sintaxe implícita mais velha que utiliza o operador de junção externa (+) da seguinte forma (mas ainda recomendo usar o RIGHT OUTER JOIN com palavra-chave):


SELECT orders.order_id, orders.order_date, suppliers.supplier_name
FROM suppliers, orders
WHERE suppliers.supplier_id(+) = orders.supplier_id;

SQL FULL OUTER JOIN

Outro tipo de associação é chamado de SQL FULL OUTER JOIN . Este tipo de JOIN retorna todas as linhas da tabela do lado esquerdo e do lado direito da tabela com valores nulos no lugar onde a condição de junção não é satisfeita.

SQL FULL OUTER SINTAXE JOIN

A sintaxe para o SQL FULL OUTER JOIN:


SELECT columns
FROM table1
FULL [OUTER] JOIN table2
ON table1.column = table2.column;
Em alguns bancos de dados, o FULL OUTER JOIN são substituídos por FULL JOIN.

VISUAL ILUSTRAÇÃO DE SQL FULL OUTER JOIN

Neste diagrama visual, o SQL FULL OUTER JOIN retorna a área sombreada:

SQL

O SQL FULL OUTER JOIN retornaria os todos os registros de ambos tabela1 e tabela2 .

SQL FULL OUTER JOIN EXEMPLOS

Aqui está um exemplo de um SQL FULL OUTER JOIN:


SELECT suppliers.supplier_id, suppliers.supplier_name, orders.order_date
FROM suppliers
FULL OUTER JOIN orders
ON suppliers.supplier_id = orders.supplier_id;
Este FULL OUTER JOIN retorna todas as linhas da tabela de suppliers e todas as linhas da tabela de pedidos e sempre que a condição de junção não for atendida, <nulls> seriam estendidas aos campos no conjunto de resultados.

Se um valor supplier_id na tabela de suppliers não existe na tabela de pedidos, todos os campos na tabela de orders seriam exibidos como <null> no conjunto de resultados. Se um valor supplier_id na tabela de pedidos não existe na tabela de suppliers, todos os campos na tabela de suppliers seram apresentados como <null> no conjunto de resultados.

Vejamos alguns dados para explicar como FULL OUTER JOINS:

Nós temos uma tabela chamada fornecedores com dois campos (supplier_id e supplier_nome). Ele contém os seguintes dados:

supplier_idsupplier_name
10000IBM
10001Hewlett Packard
10002Microsoft
10003NVIDIA

Temos uma segunda tabela chamada orders com três campos (ORDER_ID, supplier_id e order_date). Ele contém os seguintes dados:

order_idsupplier_idorder_date
500125100002013/08/12
500126100012013/08/13
500127100042013/08/14

Se executar a instrução SQL (que contém uma full outer join) a seguir:


SELECT suppliers.supplier_id, suppliers.supplier_name, orders.order_date
FROM suppliers
FULL OUTER JOIN orders
ON suppliers.supplier_id = orders.supplier_id;
Nosso conjunto de resultados ficaria assim:

supplier_idsupplier_nameorder_date
10000IBM2013/08/12
10001Hewlett Packard2013/08/13
10002Microsoft<null>
10003NVIDIA<null>
<null><null>2013/08/14

As linhas para Microsoft e NVIDIA seriam incluídas porque um full outer join foi usado. No entanto, você vai notar que o campo order_date para esses registros contém um valor <null>.

A linha para supplier_id 10004 seriam também incluídos porque um  full outer join foi usado. No entanto, você vai notar que o supplier_id e campo supplier_name para esses registros contêm um valor <null>.

Veja agora este diagrama para memorizar de uma vez por todas como estas funções trabalham:


É isso ai galera, espero que tenham gostado! Até a próxima!

De seu amigo Bruno Rafael.

segunda-feira, 17 de fevereiro de 2014

Validando Email em Java Com e Sem expressão Regular



Fala galera! Após um período sumido, volto aqui com uma postagem interessante para vocês. Vamos aprender a validar em nosso sistema um campo de email. Uma das formas é de forma normal, e a outra, com expressão regular. Vamos lá!

Validação de um campo de email, segundo algumas regras definidas que podem ser personalizadas além das definidas nesse código.

Basicamente um email deve possuir as seguintes opções em seu campo.

1- Não possuir espaços.
2- Possuir o @.
3- Possuir algum caracter após o @.
4- Possuir pelo menos um ponto após o @.

Exemplos de email válido:

andre@java.com, andre@java.com.br, andre@java.net

Como já é de conhecimento de todos o email possui duas partes separadas pelo @, nesse caso iremos chamar a primeira de usuário e a segunda de domínio.

Com base nas opções e nas definições acima podemos determinar quais são as opções que devem ser testadas.

O tamanho do texto dentro de Usuário tem que ser maior ou igual a 1( esse valor pode ser alterado), e não pode possuir o @.

O domínio tem que possuir ponto, não pode possuir @ e a posição do primeiro ponto tem que ser maior do que a primeira posição(a primeira posição deve ser uma letra), o ultimo ponto não pode aparecer na ultima posição.

Neste caso apenas iremos trabalhar com o evento focusLost, porque esse é o evento quando o usuário acabar de preencher o email e tentar sair para o próximo campo do formulário.

Quando o email for inválido o sistema irá mostrar uma mensagem para o usuário em um JLabel.
Como já vimos os eventos e quais opções devem ser testadas, precisamos começar a desenvolver o formulário.

Vamos começar: Primeiro precisamos desenhar a interface abaixo:
Onde existe a palavra email, um campo de texto chamado jTextFieldEmail e um jlabel chamado jlabelEmail.
Após desenhar a interface precisamos clicar com o botão direito do mouse sobre o JtextFieldEmail e selecionar a opção eventos Focus e depois focusLost.
Vai abrir no código fonte o método criado, basta colocar esse código:

   if ((jTextFieldemail.getText().contains("@")) && 
(jTextFieldemail.getText().contains(".")) && 
(!jTextFieldemail.getText().contains(" "))) {

String usuario = new String(jTextFieldemail.getText().substring(0, 
jTextFieldemail.getText().lastIndexOf('@')));

            String dominio = new String(jTextFieldemail.getText().substring(jTextFieldemail.getText().lastIndexOf
('@') + 1, jTextFieldemail.getText().length()));

            if ((usuario.length() >=1) && (!usuario.contains("@")) && 
(dominio.contains(".")) && (!dominio.contains("@")) && (dominio.indexOf(".") >= 
1) && (dominio.lastIndexOf(".") < dominio.length() - 1)) {

            jLabelEmail.setText("");

            } else {

                jLabelEmail.setText("E-mail Inválido");

                jTextFieldemail.requestFocus();

            }

        } else {

            jLabelEmail.setText("E-mail Inválido");

            jTextFieldemail.requestFocus();

        }

No primeiro IF fizemos 3 testes, o primeiro verifica se no email já existe o @, o segundo verifica se no email existe o ponto, e o terceiro verifica se no email não existe o espaço.

Se o email informado passar pelos 3 testes acima ele é dividido em duas partes, antes do @ que é chamado de usuário e depois do @ que que chamamos de domínio.

Com essa divisão do email, são realizados os últimos testes, onde:

Usuário: não pode conter @.

Usuário: tamanho da string tem que ser maior ou igual a 1.

Domínio: não pode conter @.

Domínio: tem que conter ponto.

Domínio: a posição do primeiro ponto tem que ser maior ou igual a 1.

Domínio: e o ultimo ponto não pode ser o ultimo caracter.

Caso passe por todos os teste a mensagem que aparece no JLabelEmail é apagada.

Se não passar em algum dos colocamos a mensagem "E-mail Inválido" no jLabelEmail, e devolvemos o focus para o campo do JTextFieldEmail, dessa forma só saindo do campo de email, quando for digitado um email válido.

Esta operação busca garantir que apenas quando um usuário digitar um email válido ele poderá seguir preenchendo os demais campos do formulário, caso contrário ficara aparecendo a mensagem.

Agora vamos à mesma solução, mas desta vez com Expressão Regular:



  1. private void validarEmail(String email) throws PlcException {  
  2.   
  3.      
  4.           Pattern p = Pattern.compile("^[\\w-]+(\\.[\\w-]+)*@([\\w-]+\\.)+[a-zA-Z]{2,3}$");    
  5.           Matcher m = p.matcher(email.trim());   
  6.           if (!m.find())  
  7.               System.out.println("### EMAIL INVÁLIDO");  
  8.   
  9.       } 

10992879873987987 de vezes mais simples!

Então é isso galera! Espero que tenham gostado e até a próxima!

Admin: Bruno

Olá Galera! muito grato por estarem acessando nosso blog. Espero que seja possível transmitir de forma compreensível um pouco de meus conhecimentos em programação, para esta comunidade de desenvolvedores que cresce cada vez mais! Espero que Gostem! Abraço! E meu enorme obrigado à Renato Simões, Átila Soares,Wanderson Quinto, Emerson e a toda galera que sempre ajudou meu sincero obrigado....
Especialmente a Natalia Failache e Rita de Cassia que sempre apoiaram este sonho....

De seu amigo Bruno Rafael.