Pessoal, eu tenho o seguinte problema e gostaria de saaber se vocês podem me ajudar com a seguinte situação.
eu tenho duas tabelas, uma em um banco de dados(Mysql,Oracle,Postgres,etc), com determinadas colunas e outra tabela em outro banco de dados com a mesma tabela criada por mim, porém, eu gostaria de comparar, se as colunas da tabela no banco1 são iguais às colunas da tabela no banco2.
Você precisa acessar o que conhece-se por “catálogo do banco”. É um banco de dados que descreve o banco de dados. No Oracle, por exemplo, existe uma tabela chamada USER_TAB_COLUMNS que contém o nome da tabela, o nome, o tipo de dado e o tamanho de cada campo. A questão é descobrir a tabela equivalente a esta nos outros SGBD’s, o que não é difícil olhando a documentação de cada um.
vc ta se referindo a algo do tipo " desc table" no mysql?
Algo nesse rumo mesmo. Mas indo mais fundo. O “desc table” é um comando que lê o catálogo e já te traz o resultado. Estou falando mais exatamente de você ler as tabelas de catálogos. Aí é até possível montar uma conexão via JDBC mesmo, e executar selects nos bancos e ir fazendo as comparações.
um show create table? mais a intenção realmente é fazer uma conexão via jdbc e executar um select, o problema é como fazer esse select pra retornar pra aplicação as colunas da tabela, pra eu fazer as devidas comparações, só preciso comparar o nome e o tipo.
mas então… o que estou dizendo não é que você precisa criar uma tabela a partir do show table… você só precisa saber em que tabela está guardada a informação mostrada pelo show table… Não conheço a documentação do mysql, mas tenho um palpite muito forte de que isso dá pra descobrir por lá. do mesmo jeito que dá pra descobrir do postgre, etc…
Mais então, a tabela no segundo banco eu vou criar manualmente, a função principal da aplicação é migrar os dados da tabela de entrada, pra tabela de saída. o teste que vou fazer, é só pra evitar constrangimentos futuros… eu vou fazer um select no banco de entrada, e fazer um insert no banco de saída…
estou entendendo seu problema da seguinte forma:
1 - você tem um banco A e o banco B
2 - precisa criar no banco B uma tabela igual à que existe no banco A. Para isso quer ler a estrutura da tabela que está em A para criá-la no banco B.
Se você vai criar a tabela em B manualmente, estará sabendo exatamente o que está fazendo, certo? desculpe… nesse ponto perdi o entendimento do seu problema…
kkkkkk
1 - eu tenho um banco A e o banco B
2 - no banco B eu irei criar uma tabela igual à existente no banco A. Para isso quero ler a estrutura da tabela que está em A para compará-la no banco B.
3- Você deve estar se perguntando, porque eu compararia as colunas, se uma vez que eu to fazendo manualmente no banco B, eu vou ter certeza de que estou preenchendo o nome das colunas corretamente. eu preciso fazer isso, porque quando eu for migrar as informações pro banco B, eu preciso ter certeza de que as colunas estão realmente corretas por que sempre existirá uma falha humana, isso é inevitável…
Tópico movido para o fórum de persistência.
Você tem razão, wilsontads… ainda mais se você tiver que completar o serviço feito por outro… Desculpe minha viajada.
Vamos lá… lendo a documentação do mysql encontrei isso:
http://dev.mysql.com/doc/refman/5.6/en/columns-table.html
Não testei, mas acredito que seja o equivalente à USER_TAB_COLUMNS do Oracle. Volto então pra aquela abordagem de ler estas tabelas e fazer as comparações. Se puder ajudar em algo mais, vai ser bacana.
Mais isso eu faço com um ResultSet?
Estando conectado como um usuário que tenha acesso de leitura a esta tabela… porque não? Em essência é uma tabela como outra qualquer… Lembre do que falamos no começo: o SGBD tem um banco de dados que descreve o banco de dados (chamam isso por aí de metadados)
Não ficou muito claro… eu pensei que o ResultSet só deixava tratar com os dados que estao dentro das tabelas, vc tem uma forma de como eu poderia fazer essa consulta?
Pois é… mas o caso é justamente este… essas tabelas do catálogo do banco são… TABELAS. E as informações que elas guardam são justamente o que você está procurando.
Veja, se você tiver no ORACLE uma tabela chamada clientes, execute isto:
(detalhe: estando logado como usuário que criou a tabela, ok?)
select column_name
, data_type
, data_length
, nullable
from user_tab_columns
where table_name = 'CLIENTES'
Supondo que no MYSQL você tenha uma tabela também chamada clientes, seria isto:
SELECT COLUMN_NAME
, DATA_TYPE
, CHARACTER_MAXIMUM_LENGTH
, IS_NULLABLE
FROM INFORMATION_SCHEMA.COLUMNS
WHERE table_name = 'CLIENTES'
Percebe a similaridade?
OK, estamos aqui ainda restritos ao Oracle e MySQL, e você precisaria verificar a documentação dos outros bancos para conhecer a consulta que precisaria executar, correto? Está me vindo à mente uma outra solução: ResultSetMetaData, que faz parte do JDBC. Pode ser que numa paulada só você já mate todos os coelhos…
Dê uma olhada nisso:
http://download.oracle.com/javase/6/docs/api/java/sql/ResultSetMetaData.html
Caraca, mais olhando bem essa classe do RsMetaData, eu posso ignorar essas particularidades das consultas não é mesmo?
Eu ainda não fiz teste, mais acredito que utilizando dessa forma, também seja possível eu fazer essas consultar apenas com o ResultSet, não é isso?
Eu também acho que dá, tanto de um jeito como de outro. Se tiver mais alguma dúvida ou precisar de ajuda, vai postando aí… continuo acompanhando o tópico
Isso pode ser um rascunho pro que você precisa fazer:
Statement stmt = conexaoOracle.createStatement();
ResultSet listaTabelas = stmt.executeQuery("select table_name from user_tables where table_name in ('UMA_TABELA', 'OUTRA_TABELA','MAIS_UMA_TABELA')");
ResultSet camposTabela = null;
PreparedStatement pstm = conexaoOracle.prepareStatement("select column_name from user_tab_columns where table_name = ?");
String comandoSelect = "select ";
String comandoInsert = "insert into ";
String parametrosInsert = " values(";
while(listaTabelas.next()){
System.out.println("tratando tabela " + listaTabelas.getString(1));
pstm.setString(1,listaTabelas.getString(1));
camposTabela = pstm.executeQuery();
comandoInsert += listaTabelas.getString(1) + " (";
while(camposTabela.next()){
comandoSelect += camposTabela.getString(1) + ", ";
comandoInsert += camposTabela.getString(1) + ", ";
parametrosInsert += "?, ";
}
comandoInsert += parametrosInsert + ")";
comandoSelect += " from " + listaTabelas.getString(1);
comandoSelect = comandoSelect.replace(", ", " ");
comandoInsert = comandoInsert.replace(", ", ") ");
comandoInsert = comandoInsert.replace("?, )", "?)");
}
System.out.println("comando Select: ");
System.out.println(comandoSelect);
System.out.println("--------------------------------------");
System.out.println(comandoInsert);
Eu fiz da seguinte forma…
[code]LinkedList<Campos_tab> listaDeCampos = new LinkedList<Campos_tab>();
Campos_tab campoAtual = new Campos_tab();
String nomeTabela = "Cliente ";
campoAtual.setNome("idade_saida");
campoAtual.setTipo("int");
listaDeCampos.add(campoAtual);
campoAtual = new Campos_tab();
campoAtual.setNome("nome_saida");
campoAtual.setTipo("String");
listaDeCampos.add(campoAtual);
campoAtual = new Campos_tab();
campoAtual.setNome("telefone_saida");
campoAtual.setTipo("String");
listaDeCampos.add(campoAtual);
StringBuffer sBufferSelect = new StringBuffer();
String campos="";
String valores="";
for(int i=0; i < listaDeCampos.size(); i++){
campoAtual = listaDeCampos.get(i);
if(!campos.equals("")){
campos = campos + ", ";
}
campos = campos + campoAtual.getNome();
if(!valores.equals("")){
valores = valores +", ";
}
valores = valores + "?";
}
StringBuffer sBufferInsert = new StringBuffer();
sBufferInsert.append("insert into "+ nomeTabela) ;
sBufferInsert.append("("+ campos + ")");
sBufferInsert.append("values ("+ valores+")") ;
System.out.print( sBufferInsert);
}[/code]
no final, independente do tamanho do meu objeto, eu tenho uma sql +/- com o seguinte resultado…
agora penso como vou fazer os ps.setInt(i,rs.getInt);