O Resultset é uma classe da API JAVA que permite percorrermos um DataTable de alguma consulta em um banco de dados.
Ao ser inicializado, o Resultset coloca seu cursor na primeira linha do DataTable, o método next() permite que o ponteiro seja direcionado para a próxima linha caso exista.
Além de conseguirmos carregar dados de uma consulta a alguma tabela de um banco de dados, conseguimos armazenar vários DataTable’s que podem ser por exemplo vários retornos de um procedure. O método getMoreResults() faz com que o ponteiro seja direcionado para a primeira posição do próximo DataTable caso ele exista. Isso possibilita uma única requisição ao banco de dados e obter vários retornos visando performance e centralização de processos.
Um exemplo de uma procedure que retorna os dados de clientes e os dados de fornecedores que estão em tabelas diferentes e sem qualquer ligação, em uma mesma consulta pode ser chamada de RETORNA_CLI_FORN() que tem as consultas das duas tabelas.
Usaremos uma classe para a conexão com banco chamada Conexao:
package multiplosResults;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
/**
*
* @author Adaylon
*/
public class Conexao {
public Connection conPostgree() {
Connection con = null;
String driver = "org.postgresql.Driver";
String user = "postgres";
String senha = "ms6tgs";
String url = "jdbc:postgresql://localhost:5432/VENDAS";
try {
Class.forName(driver);
con = (Connection) DriverManager.getConnection(url, user, senha);
System.out.println("Conexão realizada com sucesso.");
}
catch (ClassNotFoundException ex) {
System.err.println(ex.getMessage());
} catch (SQLException e) {
System.err.println(e.getMessage());
}
return con;
}
}
A classe instancia um driver do banco de dados escolhido e retorna um objeto do tipo Connection.
Criamos uma classe para representar o objeto Cliente com seus atributos encapsulados:
/*
*
*
*/
package multiplosResults;
import java.util.Date;
/**
*
* @author Adaylon
*/
public class Clientes {
private static String nome;
private static String cpf;
private static String tel;
private static Date dataNasc;
/**
* @return the nome
*/
public static String getNome() {
return nome;
}
/**
* @param aNome the nome to set
*/
public static void setNome(String aNome) {
nome = aNome;
}
/**
* @return the cpf
*/
public static String getCpf() {
return cpf;
}
/**
* @param aCpf the cpf to set
*/
public static void setCpf(String aCpf) {
cpf = aCpf;
}
/**
* @return the tel
*/
public static String getTel() {
return tel;
}
/**
* @param aTel the tel to set
*/
public static void setTel(String aTel) {
tel = aTel;
}
/**
* @return the dataNasc
*/
public static Date getDataNasc() {
return dataNasc;
}
/**
* @param aDataNasc the dataNasc to set
*/
public static void setDataNasc(Date aDataNasc)
{
dataNasc = aDataNasc;
}
}
Criamos uma classe para representar o objeto Fornecedor com seus atributos encapsulados:
/*
*
*
*/
package multiplosResults;
/**
*
* @author Adaylon
*/
public class Fornecedores {
private static String nome;
private static String cnpj;
/**
* @return the nome
*/
public static String getNome() {
return nome;
}
/**
* @param aNome the nome to set
*/
public static void setNome(String aNome) {
nome = aNome;
}
/**
* @return the cnpj
*/
public static String getCnpj() {
return cnpj;
}
/**
* @param aCnpj the cnpj to set
*/
public static void setCnpj(String aCnpj) {
cnpj = aCnpj;
}
}
Criamos uma classe com o nome Consultas que executa a procedure RETORNA_CLI_FORN() e carrega os Resultsets:
/*
*
*
*/
package multiplosResults;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author Adaylon
*/
public class Consultas {
private static ArrayList<Clientes> c;
private static ArrayList<Fornecedores> f;
public Consultas() {
try {
ResultSet[] rs = new ResultSet[2];
Connection con = new Conexao().conPostgree();
CallableStatement cs = null;
String sql = "{CALL RETORNA_CLI_FORN()}";
cs = con.prepareCall(sql);
//Execução da query sql e obtendo o resultado da primeira consulta
rs[0] = cs.executeQuery();
c = new ArrayList<Clientes>();
Clientes cl = new Clientes();
while(rs[0].next()){
cl.setNome(rs[0].getString("NOME"));
cl.setCpf(rs[0].getString("CPF"));
cl.setTel(rs[0].getString("TEL"));
cl.setDataNasc(rs[0].getDate("DATA_NASCIMENTO"));
c.add(cl);
}
//Verificação de novos DataTables
if (cs.getMoreResults()) {
//Obtendo o próximo Resultset
rs[1] = cs.getResultSet();
f = new ArrayList<Fornecedores>();
Fornecedores fo = new Fornecedores();
while(rs[1].next()){
fo.setNome(rs[1].getString("NOME"));
fo.setCnpj(rs[1].getString("CNPJ"));
f.add(fo);
}
}
} catch (SQLException ex) {
Logger.getLogger(Consultas.class.getName()).log(Level.SEVERE, null, ex);
}
}
public Iterator retornaClientes() {
Iterator i = c.iterator();
return i;
}
public Iterator retornaFornecedores() {
Iterator i = f.iterator();
return i;
}
}
Na classe Main instanciamos um objeto Consultas que faz a execução da procedure no seu construtor, e após chamarmos os métodos que retornam uma lista de Clientes e uma lista de Fornecedores, fazemos um loop mostrando o resultado das duas consultas que foram retornadas no mesmo bloco de execução.
/*
*
*
*/
package multiplosResults;
import java.util.Iterator;
/**
*
* @author Adaylon
*/
public class Main {
public static void main(String[] args){
Consultas c = new Consultas();
Iterator _ic = null;
Iterator _if = null;
Clientes cl = new Clientes();
Fornecedores fo = new Fornecedores();
_ic = c.retornaClientes();
_if = c.retornaFornecedores();
while(_ic.hasNext()){
cl = (Clientes) _ic.next();
System.out.println(cl.getNome()+" - "+cl.getCpf()+" -"+cl.getTel()+"
- "+cl.getDataNasc());
}
while(_if.hasNext()){
fo = (Fornecedores) _if.next();
System.out.println(fo.getNome()+" - "+fo.getCnpj());
}
}
}
