Discussion :

[delta07]

Bonjours à tous

J'ai un gros fichiers XML ( 20 go environ) contenant notamment des balises <product> </product>, mais il y a plus de 100k de ces produits.
Je voudrais trouver le moyen le plus rapide pour faire plusieurs petits fichiers contennant par exemple 100 ou 1000 de ces balises.

J'ai essayé avec Talend, la mémoire explose...

J'ai trouvé un script python qui n'utilise pas beaucoup de mémoire mais le fait en 3h.

J'ai également trouvé un script transcrivant ce python en C, je gagne environ 40 min.

Mais il me faut absolument trouver une solution pour spliter correctement ce gros XML.
Je suis en train de voir avec perl, mais je ne suis pas bon du tout.

Vous avez des idées ?
Merci

[delta07]

Pour me répondre un peu à moi-même et aux prochains qui passeraient par là, voici un script ruby qui fait le job en une 15aine de minutes.

Code Ruby :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
require 'xml'
 
XML_FILE = './exported_0.xml'
 
# A special file class that we'll write its output in
# successive files with the same number of items in it
# (except for the last one which size may vary)
class SplitFile
  def initialize(template_name, items_per_file)
    @template_name = template_name
    @items_per_file = items_per_file
    @item_count = 0
    @file_index = 0
    @fh = open()
  end
 
  def write(content)
    @fh.write(content)
    @fh.write("\n")
    @item_count += 1
    if @item_count == @items_per_file
      self.close()
      self.open()
    end
  end
 
  def open
    exit if @file_index == 3
    @file_index += 1
    @fh = File.open(self.batch_name(), 'w')
  end
 
  def close
    @fh.close
    @item_count = 0
  end
 
  def batch_name
    @template_name % @file_index
  end
end
 
# XML Processor to split the Product records into
# smaller XML chunks
class XMLSplitProcessor
 
  def initialize(xml_sourcefile, split_filename_template)
    @split_filename_template = split_filename_template
    @file_handle = SplitFile.new(split_filename_template, 1000)
    @reader = XML::Reader.file(xml_sourcefile)
  end
 
  def run
    while @reader.read do
      self.process_node()
    end
  end
 
  def process_node
    if @reader.name == 'Product' && reader.node_type == XML::Reader::TYPE_ELEMENT
      @file_handle.write(@reader.read_outer_xml)
      @reader.next
    end
  end
 
end
 
# Main
XMLSplitProcessor.new(XML_FILE, "batch_%s.xml").run

[thelvin]

Bien joué !

J'ai pu constater ce matin qu'un programme Java à base de StAX ou de SAX en lecture/écriture bien écrit, faisait le job en une quinzaine de minutes.
Mais, tu as trouvé avant que je ne fasse un rapport.

[delta07]

Well done !

Si tu as les même performances en Java, je suis preneur, ça m’éviterai de devoir installer ruby sur le serveur cible le moment venu