Olá pessoal estou com um problema na escolha da melhor forma de armazenamento de dados.
Eu tenho um script que importa dados de um arquivo .xls e envia ao banco de dados, porem antes eu preciso fazer uma consulta ao banco e trazer algumas colunas utilizadas na importação. Após gravar essas colunas em alguma estrutura eu devo pesquisar se a linha do xls atual está presente no banco de dados.
Não sei se me entenderam mas o meu caso atual é que eu tenho um arquivo xls com 8000 registros e nestes registros possui uma árvore de níveis entre os elementos dentro dele
ex: 1, 1.1, 1.1.1, 2, 2.1, 2.2.
eu preciso buscar no banco o código(PK) e o codigo atual (exemplo acima) do registro pai e entao sempre que eu for inserir um registro do xls no banco de dados eu preencho o campo codigo pai no registro atual.
Preciso de uma estrutura de busca rapida onde que ao passar o codigo 1.1 ele me retorne o pai dele que é o índice(PK) dele o indice do registro 1.
OBS: do jeito que ta demora muito pra inserir os dados, pois antes da inserção de um registro no banco eu busco a PK dele e insiro junto. Ou seja se eu tenho 8000 registros no xls ele faz 8000 consultas na tabela. Isso esta demorando muito por isso a duvida na escolha de um armazenamento de dados.
Se o arquivo sempre tiver mais ou menos esse tamanho (8000 registros), eu faria tudo em memoria primeiro e depois gravaria no banco, entao ao inves de buscar e gravar no banco para cada linha, eu iria usar alguma estrutura baseada em hash.
Outra coisa eh mais logica, vamos supor que vc tem 200 filhos de 1.1, pq buscar 200x o 1.1 quando vc soh precisa buscar uma vez?! E dependendo de como o xls estiver organizado, vc insere o pai e todos os filhos vaum vir logo a seguir ateh que vc mude de nivel (quando 1.1 passar a ser 1.2, vc nao precisa mais da referencia para 1.1 pois tem certeza que ja processou todos seus filhos)
[quote=luBS]Se o arquivo sempre tiver mais ou menos esse tamanho (8000 registros), eu faria tudo em memoria primeiro e depois gravaria no banco, entao ao inves de buscar e gravar no banco para cada linha, eu iria usar alguma estrutura baseada em hash.
Outra coisa eh mais logica, vamos supor que vc tem 200 filhos de 1.1, pq buscar 200x o 1.1 quando vc soh precisa buscar uma vez?! E dependendo de como o xls estiver organizado, vc insere o pai e todos os filhos vaum vir logo a seguir ateh que vc mude de nivel (quando 1.1 passar a ser 1.2, vc nao precisa mais da referencia para 1.1 pois tem certeza que ja processou todos seus filhos)[/quote]
Está exatamente assim o xls, esta organizado em pais com seus respectivos filhos. Você diz armazenas os registros num HashTable por exemplo e depois percorrer este hash e inserir no banco apos isso?
POrque o que eu tive vendo aqui é que nem todos os dados estão consistentes, alguns faltam pais entao eu estou inserindo o pai antes do filho.
Se sim, eu estava pensando em algo desse tipo, veja se te ajuda (o que esta em list simula algo vindo do seu xls), foda que tah recursivo, ideal que não seja… mas para 8000 objetos nao deve fazer tanta diferença:
static class Node {
private final Node parent;
private final String str;
public Node(Node parent, String str) {
this.str = str;
this.parent = parent;
}
public String toString() {
return str + (parent != null ? " - " + parent : "");
}
}
public static String getStringParent(String s) {
if (s.indexOf(".") > 0) {
return s.substring(0, s.lastIndexOf("."));
}
return null;
}
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("1");
list.add("1.1");
list.add("1.2");
list.add("1.2.1");
list.add("1.3.1");
list.add("2.1.1");
Map<String, Node> nodes = new LinkedHashMap<String, Node>();
for (String s : list) {
insert(nodes, s);
}
for (Entry<String, Node> entry : nodes.entrySet()) {
System.out.println(entry.getValue());
}
}
static Node insert(Map<String, Node> nodes, String s) {
final String parentString = getStringParent(s);
final Node node;
if (parentString == null) {
node = new Node(null, s);
nodes.put(s, node);
} else {
Node parent = nodes.get(parentString);
if (parent == null) {
parent = insert(nodes, parentString);
}
node = new Node(parent, s);
nodes.put(s, node);
}
return node;
}
[quote=luBS]Falta de pai vc quer dizer que dada a entrada:
1
1.1
1.2.1
2.1.2
Esta faltando os pais 1.2, 2 e 2.1?
Se sim, eu estava pensando em algo desse tipo, veja se te ajuda (o que esta em list simula algo vindo do seu xls), foda que tah recursivo, ideal que não seja… mas para 8000 objetos nao deve fazer tanta diferença:
[code]
static class Node {
private final Node parent;
private final String str;
public Node(Node parent, String str) {
this.str = str;
this.parent = parent;
}
public String toString() {
return str + (parent != null ? " - " + parent : "");
}
}
public static String getStringParent(String s) {
if (s.indexOf(".") > 0) {
return s.substring(0, s.lastIndexOf("."));
}
return null;
}
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("1");
list.add("1.1");
list.add("1.2");
list.add("1.2.1");
list.add("1.3.1");
list.add("2.1.1");
Map<String, Node> nodes = new LinkedHashMap<String, Node>();
for (String s : list) {
insert(nodes, s);
}
for (Entry<String, Node> entry : nodes.entrySet()) {
System.out.println(entry.getValue());
}
}
static Node insert(Map<String, Node> nodes, String s) {
final String parentString = getStringParent(s);
final Node node;
if (parentString == null) {
node = new Node(null, s);
nodes.put(s, node);
} else {
Node parent = nodes.get(parentString);
if (parent == null) {
parent = insert(nodes, parentString);
}
node = new Node(parent, s);
nodes.put(s, node);
}
return node;
}
[/code][/quote]
É isso mesmo o que estou fazendo porém estou fazendo no banco de dados, mas entendi a idéia e é essa mesmo, manipular os dados na memoria e depois socar no BD.
Agradeço pelo script testei aqui e é isso mesmo amigo