INNER JOIN e OUTER JOIN
Se você é um DBA ou trabalha com programação e usa muito banco de dados SQL, este tópico não é você, a menos que não conheça as cláusulas INNER JOIN e OUTER JOIN, muito comuns em SGBDs SQL.
Não sabe o que é SGBD? Os Sistemas de Gerenciamento de Banco de Dados são programas que auxiliam na manipulação dos dados armazenados. O MySQL, PostgreSQL, MS SQL Server ou Oracle, que você tem em sua casa ou empresa, são SGBDs.
Para este tutorial você precisa ter, pelo menos, o conhecimento básico de SQL.
Chega de enrolação, vamos ao que interessa!
INNER JOIN
A cláusula INNER JOIN é usada quando se quer recuperar dados em mais de uma tabela através da igualdade de suas foreign keys.
Por exemplo, pense que você quer criar um programa que sirva como agenda telefônica. Você cadastra as pessoas e os contatos telefônicos, como uma pessoa poderá ter nenhum até N números de telefones, você separa em duas entidades como neste modelo:
Olhando rapidamente você percebe que a entidade TELEFONE tem o atributo NUM_PESSOA que é o número de identificação do registro na entidade PESSOA.
Vamos supor que as tabelas estejam preenchidas com os seguintes registros:
+----------------------------+ +---------------------------+ | PESSOA | | CONTATO | +------------+---------------+ +------------+--------------+ | NUM_PESSOA | NOME_PESSOA | | NUM_PESSOA | NUM_TELEFONE | | 1 | José | | 1 | 6589-3666 | | 2 | Arnaldo | | 3 | 9888-6699 | | 3 | Maria | | 3 | 8956-6666 | | 4 | Elverdelando | | 2 | 2888-9877 | +------------+---------------+ +------------+--------------+
Para recuperar os telefones de uma pessoa você deve usar INNER JOIN, implicitamente ou explicitamente. Vou explicar os dois casos.
O método explícito é usar a cláusula explicitamente (duh!), que é formada por INNER JOIN <tabela filha> ON <atributos de identificação>;, no nosso exemplo:
SELECT nome_completo, num_telefone FROM pessoa INNER JOIN telefone ON pessoa.num_pessoa = telefone.num_pessoa.
Estamos dizendo: "me traga o nome e os números dos telefones da pessoa onde o número da pessoa em TELEFONE seja igual ao número da pessoa em PESSOA".
Na forma implícita você não usa a cláusula INNER JOIN, o tratamento de igualdade é feito na cláusula WHERE. Usando o mesmo exemplo:
SELECT nome_completo, num_telefone FROM pessoa, telefone WHERE pessoa.num_pessoa = telefone.num_pessoa.
Em ambos os casos o resultado será:
+---------------------------+ | CONTATO | +------------+--------------+ | NOM_PESSOA | NUM_TELEFONE | | José | 6589-3666 | | Maria | 9888-6699 | | Maria | 8956-6666 | | Arnaldo | 2888-9877 | +------------+--------------+
"Que simples! Hummmm espera um pouco... Onde está o Elverdelando (que nominho, hein?!)."
Lembra que dissemos ao banco "me traga o nome e os números dos telefones da pessoa onde o número da pessoa em TELEFONE seja igual ao número da pessoa em PESSOA"? Então! O Elverdelando não esta na tabela TELEFONE, por isso não foi retornado no resultado.
Quando você precisar retornar os dados, mesmo não estando na tabela filha, usamos o OUTER JOIN.
OUTER JOIN
A clásula OUTER JOIN tem duas variantes, LEFT OUTER JOIN e RIGHT OUTER JOIN, sendo que estas cláusula devem ser declaradas sempre de maneira explícita. Alguns SGBDs facilitam a utilização do OUTER JOIN te polpando de declarar toda a sintaxe, como é o caso do Oracle que utiliza o símbolo (+) na identificação fraca, mas NÃO É ANSI, ou seja, não funcionará em qualquer SGBD.
Para que apareçam todas as pessoas, inclusive as que não têm número de telefone cadastrado usamos LEFT OUTER JOIN ou RIGHT OUTER JOIN.
A sintaxe é parecida com a INNER JOIN, mudando apenas o nome da cláusula: LEFT[RIGHT] OUTER JOIN <tabela filha> ON <atributos de identificação>;
Assim, faremos...
SELECT nome_completo, num_telefone FROM pessoa LEFT OUTER JOIN telefone ON pessoa.num_pessoa = telefone.num_pessoa
ou então
SELECT nome_completo, num_telefone FROM telefone RIGHT OUTER JOIN pessoa ON pessoa.num_pessoa = telefone.num_pessoa
Em ambos os casos o resultado será:
+-----------------------------+ | CONTATO | +--------------+--------------+ | NOM_PESSOA | NUM_TELEFONE | | José | 6589-3666 | | Maria | 9888-6699 | | Maria | 8956-6666 | | Arnaldo | 2888-9877 | | Elverdelando | | +--------------+--------------+
Como você pôde perceber, a única diferença entre o LEFT OUTER JOIN e o RIGHT OUTER JOIN é só a indicação de qual é o lado forte do relacionamento, ou seja, em qual lado da cláusula está a tabela que pode não ter valores na tabela filha. No nosso caso, ambos apontando para a tabela PESSOA.
INNER JOIN é muito usado para consulta em banco de dados, quase que totalmente em seu método implícito. Já as cláusulas OUTER JOIN também são usadas, mas não com tanta frequência, posso dizer que é raro encontra-las por aí.
Espero que este tutorial os ajude! 
Configurando acesso à internet via proxy em aplicações Java
Hoje tive um problema no meu trabalho onde um client, que roda via prompt de comando (Prompt do DOS), não conseguia acessar o servidor hospedado na internet, isso porque a empresa onde trabalho utiliza proxy.
Depois de algumas tentativas acabei achando duas soluções para resolver o problema de acesso: a primeira foi passar como parâmetros Java as configurações do proxy.
$ java -Dhttp.proxyHost=serv -Dhttp.proxyPort=porta -Dhttp.proxyUser=usu -Dhttp.proxyPassword=senha ClasseJava
-Dhttp.proxyHost = IP ou nome do servidor proxy
-Dhttp.proxyPort = Porta do proxy
-Dhttp.proxyUser = Usuário
-Dhttp.proxyPassword = Senha
Desta forma a classe ClasseJava terá acesso à internet através do proxy.
A outra forma foi inserir as configurações na própria classe:
public static void main(String[] args){
...
System.getProperties().put("proxySet", "true");
System.getProperties().put("http.proxyHost", "serv");
System.getProperties().put("http.proxyPort", "porta");
System.getProperties().put("http.proxyUser", "usuario");
System.getProperties().put("http.proxyPassword", "senha");
...
}
proxySet = Define se passará ou não por um servidor proxy
http.proxyHost = IP ou nome do servidor proxy
http.proxyPortt = Porta do proxy
http.proxyUse = Usuário
http.proxyPassword = Senha
Usando um destes recursos você poderá configurar sua aplicação para acessar à internet através de um proxy.
Espero ter ajudado. Até +!
Criando janelas transparentes e com formas usando Java Swing/AWT
O AWT nos oferece uma gama de possibilidades quando falamos sobre manipulação de janelas. Hoje falarei sobre duas destas possibilidades com a classe AWTUtilities.
Deixando a janela transparente
Para deixar uma Window (JFrame, JDialog e etc) transparente, você deve usar o método AWTUtilities.setWindowOpacity. Este método recebe como parâmetro a janela que deve ser alterada e o grau de transparência, que varia entre 0 (zero) e 1, sendo 0 (zero) invisível e 1 totalmente visível.
JFrame window = new JFrame("Minha janela");
//70% de transparência
AWTUtilities.setWindowOpacity(window, .7f);
window.setSize(800,600);
window.setVisible(true);
O resultado será:
Alterando a forma da janela
Para alterar a forma da janela você deve usar o método AWTUtilities.setWindowShape. Este método recebe como parâmetro a janela que deve ser alterada e a forma (java.awt.Shape) que a janela deverá assumir.
A forma mais eficiente de usar este método é através do componentResized(), pois você poderá recalcular o tamanho da janela para não deforma-la ou não perder os componentes de vista.
Aqui deixaremos nossa janela com a forma de um triângulo com 70% de transparência.
final JFrame window = new JFrame("Minha janela");
try {
//Adicionando o ComponentListener responsável pelo componentResized
window.addComponentListener(new ComponentAdapter(){
@Override
//implementando o método componentResized
public void componentResized(ComponentEvent e) {
int[] x = {0,400,800}; //Pontos X do polígono
int[] y = {600,0,600}; //Pontos Y do polígono
//Criaremos um triângulo de 800 x 600
Shape shape = new Polygon(x, y, 3);
AWTUtilities.setWindowShape(window, shape);
//com transparência de 70%
AWTUtilities.setWindowOpacity(window, 0.7f);
}
});
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
window.setUndecorated(true); //removendo barra de título
window.setSize(800,600);
window.setVisible(true);
Repare que invoquei o método setUndecorated( ) passando o valor true, este método é responsável por ocultar a barra de título (aquele com o ícone e os botões de maximizar, minimizar e fechar) que, se estiver visível, o método AWTUtilities.setWindowShape( ) não surtirá efeito.
O resultado:
Espero que tenham gostado e até a próxima!
//Pontos X do polígono
Inserindo arquivos em campos BLOB de uma base de dados
Para inserir um arquivo, seja ele de qualquer formato, é necessário utilizar o método setBinaryStream implementado pelo PreparedStatement.
PreparedStatemente.setBinaryStream(int índice, Inputstream is, int tamanho);
Para o exemplo definimos uma tabela chamada arquivo que contém um campo BLOB chamado ARQ.
//Conexão normal, como qualquer JDBC
Class.forName("oracle.jdbc.driver.OracleDriver");
Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@<IP>:<PORTA>:<SID>","<USUARIO>","<SENHA>");
//Acessando o arquivo a ser enviado e recuperando um InputStream
File arquivo = new File("<CAMINHO_COMPLETO_DO_ARQUIVO>");
FileInputStream fis = new FileInputStream(arquivo);
//Preparando a chamada normalmente
PreparedStatement ps = conn.prepareStatement("INSERT INTO ARQUIVO (arq) VALUES(?)");
//Informando o inputstream e o tamanho do arquivo a ser enviado
ps.setBinaryStream(1, fis, (int)arquivo.length());
ps.execute();
ps.close();
conn.close();
No meu teste utilizei a base de dados Oracle 8i. Como não tenho à disposição uma base MySQL/PostgreSQL/MS SQL Server, deixo vocês encarregados de testar e me enviar os resultados, OK?
[]'s e até a próxima!
Recuperando cursor de uma procedure do Oracle no Java
Percebi que muitas pessoas acabam chegando aqui pesquisando uma forma de recuperar cursores através de procedures do Oracle, para estas pessoas eu coloco à disposição uma maneira de fazê-lo.
Para que o cursor possa ser retornado é preciso declara-lo como REF CURSOR no spec da Package.
--Criando o tipo REF CURSOR que será o cursor type g_cursor is ref cursor;
Em ambos, spec e body, você precisa declarar uma variável out do tipo do REF CURSOR mencionado acima.
procedure PRO_RETORNA_LISTA_CARROS(
i_id in tbl_car.car_id%type,
o_cursor in out g_cursor);
Para devolver o cursor com os resultados (caso haja), é necessário abri-lo no body da procedure, desta forma:
open o_cursor for
select car_id, company, model, color, hp, price
from tbl_car
where car_id = i_id;
A Package completa ficará assim:
create or replace package PAC_CURSOR is
--Criando o tipo REF CURSOR que será o cursor
type g_cursor is ref cursor;
--Procedure que retornará o cursor
procedure PRO_RETORNA_LISTA_CARROS(
i_id in tbl_car.car_id%type,
o_cursor in out g_cursor); -- Nosso cursor
end PAC_CURSOR;
/
create or replace package body PAC_CURSOR is
procedure PRO_RETORNA_LISTA_CARROS(
i_id in tbl_car.car_id%type,
o_cursor in out g_cursor) is
begin
--Abrindo o cursor para retornar os valores
open o_cursor for
select car_id, company, model, color, hp, price
from tbl_car
where car_id = i_id;
end PRO_RETORNA_LISTA_CARROS;
end PAC_CURSOR;
Temos o lado do Oracle pronto, agora precisamos tratar a chamada no Java.
Como o cursor está sendo retornado por uma procedure, usaremos um java.sql.CallableStatement.
CallableStatement cs = conn.prepareCall("{call PAC_CURSOR.PRO_RETORNA_LISTA_CARROS(?,?)}");
O registerOutParameter receberá o tipo oracle.jdbc.OracleTypes.CURSOR e retornará um java.sql.ResultSet. Iteraremos o ResultSet do mesmo modo que iteramos um Iterator.
Cada coluna retornada pelo SELECT será representado como um mapa, usando o getter correpondente. Por exemplo, chamaremos o método getString(<nome coluna>) quando retornar um varchar, getDate(<nome coluna>) quando retornar um date e etc.
O código completo fica assim:
//Chamando o procedure
CallableStatement cs = conn.prepareCall("{call PAC_CURSOR.PRO_RETORNA_LISTA_CARROS(?,?)}");
//Definindo o tipo do retorno, no caso o cursor
cs.registerOutParameter("o_cursor", OracleTypes.CURSOR);
cs.setLong("i_id", id);
cs.execute();//Executando a chamada
//Recuperando o cursor como um Resultset
ResultSet rs = (ResultSet)cs.getObject("o_cursor");
//Iterando as linhas retornadas
while(rs.next()){
//Obtendo o valor das colunas
System.out.println("ID: " + rs.getLong("car_id"));
System.out.println("Marca: " + rs.getString("company"));
System.out.println("Modelo: " + rs.getString("model"));
System.out.println("Cor: " + rs.getString("color"));
System.out.println("HP: " + rs.getString("hp"));
System.out.println("Preco: " + rs.getFloat("price"));
}
No final você conseguirá obter qualquer valor retornado em um SELECT.
Até a próxima!