[D7][StringGrid] Très gros fichiers à parser (comment faire un streaming?)

**darkvadr** · 09/07/2007, 22h12

Bonjour, je galère à nouveau sur le Tstringgrid et cette fois je cherche carrement un exemple de code.

Voilà, au jour d'aujourd'hui je "parse" un fichier ligne a ligne avec des delete et des pos etc... Et j'affiche le resultat dans un StringGrid.

Voici le pseudo code

index:=0

Repeat
(...)
ReadLN
Parse
remplit les colonnes de la ligne (index) du stringgrid en fonction de ce qui est parsé
inc(index)
Until EoF

bref ca marche sauf que...
Je traite des fichiers de plusieurs dizaines de megas et que la memoire est vite pleine.
Il m'est impossible de charger l'intégralité du fichier dans le stringgrid car je finit par depasser la capcité maximale de la memoire.

Je cherche donc a produire ceci:

soit nb le nombre de lignes visibles à l'ecran sur l'ecran.
On charge une partie du fichier dans le stringrid...
Quand on deplace l'ascensseur on charge la partie du fichier correspondante à la partie visible et on libere la memoire correspondant à la partie maintenant invisible.

Ou un truc du genre...

Est-ce clair?

Les lignes du fichier que je parse ne sont pas toutes de meme longueur, et je ne génère pas ce fichier (c'est un logiciel dont je n'ai pas la maitrise qui le fait)

(je dis ca pour les setlenght si vous voyez ce que je veux dire)

Mais par contre a chaque fois 1 ligne du fichier correspond à 1 ligne du stringgrid (on remplit ou non l'intégralité des x colonnes).

Bref, je veux faire une stringgrid qui lit en streaming en quelque sorte. Qui marcherait à la winhex (pour ceux qui connaissent) mais avec des strings.

Si vous avez un pt'it (gros?) morceau de code qui fait ca, ca me tirerait une epine du pied.

Je veux bien utiliser un component tierce partie s'il le fait mais a condition (ouai je sais j'en demande beaucoup) qu'il y' ait un exemple pour réaliser ce que je demande.

Il faut vous dire qu'un des fichier généré dépasse les 4 Go...Pour exemple une grille de 20 Mo chargée avec coloration de lignes et coloration syntaxtique prend plus de 100 Mo en memoire (listes chainées?) bref...

Vous voyez le probleme.

Merci d'avance.

**celuina** · 09/07/2007, 23h34

**darkvadr** · 10/07/2007, 08h50

Merci pour ta réponse, mais techniquement on peut déjà considérer un stringgrid comme un array dynamic. En tout cas c'en est une représentation graphique possible.

Je m'explique...Visuellement, c'est une tableau (ca c'est clair) et il peut grossir (en ajoutant des lignes et colonnes) ou maigrir (en en suprimant).

Alors oui je peux faire un array dynamique à 2 dimensions à la place.
Et on travaille juste en memoire.

Mais bon

1) il faudra quand meme que j'affiche dans un Stringgrid (ce qui va faire double emploi non?)

2)Si je n'ai pas une methode de lecture en streaming je suis bloqué par la taille des fichiers... Ce matin par exemple, on va générer un fichier de 80 Go!

oui c'est un G pas un M...

Donc sauf si y'a quelque chose que je n'ai pas comprit (et dans ce cas il faudrait que tu m'en dises un peu plus), ma question reste entière et entierrement la même.

En tout cas c'est cool d'avoir répondu, merci beaucoup.

**Rayek** · 10/07/2007, 09h24

L'utilisation d'une base de données pourrait te soulager non ?
Tu importes ton fichier dans une ou plusieurs tables et tu le traites avec une DbGrid au lieu d'une StringGrid.

**qi130** · 10/07/2007, 10h21

La solution pronée par Malatar me paraitrait la plus efficace...

La seule contrainte que j'y verrai est la complexité du fichier à parser.

Sinon, à l'aide d'un SGBDR en version embedded (MySQL ou Firebird par ex), il serait possible de jouer avec une clause LIMIT lors de la lecture afin de ramener les occurrences nécessaires pour remplir le grid.

**ShaiLeTroll** · 10/07/2007, 12h05

Utiliser Pos et Delete ... c'est déjà lent, modifie ton code pour utiliser PosEx (à partir de Delphi 7, je crois), sinon, à quoi ressemble une ligne, genre "A;B;C;...", si oui, tu peux voir la fonction Explode que j'ai faite, cela devrait booster ...

Ensuite, tu veux lire des "fenêtres" de ton fichier, c'est possible ... avec ReadLn..., ce n'est pas rapide ... mais cela gère normalement les fichiers de plus de 4Go en Lecture, ce que ne fait pas BlockRead (limité à 2Go), ... sinon tu as aussi le TFileStream, mais il te faudra découper les chaines toi même, de même tu peux utiliser ... FileOpen/FileSeek/FileRead qui encapsule les API Win/Linux ...

Avec un fichier d'un tel volume, on va partir directement sur la Solution du TStream ... va voir ce sujet , cela devrait être une bonne lecture sur les gros fichiers ...

Pour info pour compter le nombre de ligne d'un fichier de plus de 7Go contenant 200 000 000 lignes cela fut fait en plus de 700s avec ReadLn (sans même récupérer les valeurs, juste le parse #13) ... je te laisse imaginer, même avec un TStream cela sera lent ... ton fichier est mis à jour régulièrement, si plusieurs dans la journée, on oublie, mais si c'est une fois, en nocturne, tu pourrais faire un truc interressant, soit tu recopie le fichier ligne par ligne dans une Table MySQL (voir si l'import LOAD DATA INFILE fonction), si tu ne peux pas mettre MySQL, tu peux tout simplement créer un fichier d'index ... on l'a déjà fait pour le sujet que je t'ai mis en lien, ... mais au lieu de stocker l'index en mémoire on l'écrit dans un fichier, ensuite si tu veux la ligne 10000 à 10100 de ton fichier, rien de plus facile, ton fichier d'index à une strucutre fixe, donc tu fais un Seek de 10000 * SizeOf(TStructIndex) ... tu lit les données d'un coup BlockRead(Fichier, ArrayOfStructIndex[0], 100 * SizeOf(TStructIndex)), ensuite tu peux dans ton fichier de données, faire un FileSeek(Fichier, ArrayOfStructIndex[0].OffSetBegin) et lire FileRead(Fichier, BufLine, ArrayOfStructIndex[0].Length) et cela peut se faire pour chaque ligne ...

Si j'ai le temps, j'ai bien envie de pondre, un TTextFileReader avec une méthode BuildLinesIndexes et une option boolean Indexed ... juste pour rigoler ...

**ShaiLeTroll** · 10/07/2007, 19h21

Bon, voilà, un premier jet, juste pour générer le fichier d'index ... faut faire les fonctions de lecture ... je vais voir ça demain ...

Code :

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
unit uTextFileReader;
 
interface
 
uses SysUtils, Classes;
 
type
  TTextFileReader = class(TObject)
  protected
    FFileName: string;
    FIndexName: string;
    FTextFile: TFileStream;
    FIndexFile: TFileStream; // un File of aurait été plus pratique mais limité à 2Go
    FIndexed: Boolean;
    FAutoIndexed: Boolean;
    function GetIndexed: Boolean;
    procedure SetIndexed(const Value: Boolean);
  public
    constructor Create(const AFileName: string);
    destructor Destroy; override;
    procedure BuildLinesIndexes();
    property FileName: string read FFileName;
    property IndexName: string read FIndexName;
    property TextFile: TFileStream read FTextFile;
    property Indexed: Boolean read GetIndexed write SetIndexed;
    property AutoIndexed: Boolean read FAutoIndexed write FAutoIndexed;
  end;
 
  ETextFileReaderErrorIndex = class(Exception);
 
implementation
 
resourcestring
  SIndexNotExist = 'Le Fichier d''Index n''existe pas !';
 
{ TTextFileReader }
 
type
  TTextFileReaderIndex = record
    OffSet: Int64;
    Length: Integer; // une Chaine Delphi ne peut pas dépasser cette taille
  end;
 
{ TTextFileReader - Constructeurs }
 
constructor TTextFileReader.Create(const AFileName: string);
begin
  inherited Create();
 
  FFileName := AFileName;
  FIndexName := FFileName+'.idx';
  FTextFile := TFileStream.Create(FileName, fmOpenRead, fmShareDenyWrite);
  FIndexFile := nil;
 
  Indexed := False;
  AutoIndexed := False;
end;
 
destructor TTextFileReader.Destroy;
begin
  if Assigned(FIndexFile) then
  begin
    FIndexFile.Free();
    FIndexFile := nil;
  end;
 
  if Assigned(FTextFile) then
  begin
    FTextFile.Free();
    FTextFile := nil;
  end;
 
  inherited;
end;
 
{ TTextFileReader - Méthodes Publiques }
 
procedure TTextFileReader.BuildLinesIndexes();
const
  BUF_SIZE = 32768;
  LF: Byte = 10;
  CR: Byte = 13;
var
  Offset, TextSize: Int64;
  TextBuf: array[0..BUF_SIZE-1] of Byte;
  Index: TTextFileReaderIndex;
  iBuf, Readed: Integer;
  AByte: Byte;
  LastIsCR: Boolean;
begin
  FIndexFile := TFileStream.Create(FIndexName, fmCreate, fmShareExclusive);
  try
    // Positionnement au début du Fichier
    Offset := 0;
    FTextFile.Seek(Offset, soFromBeginning);
    // Récupération de la Taille du Fichier
    TextSize := FTextFile.Size;
    // Compteur/Index/Drapeau à Zéro
    Index.OffSet := 0;
    Index.Length := 0;
    LastIsCR := False;
    // Boucle jusqu'à la fin
    while (FTextFile.Position < TextSize) do
    begin
      Readed := FTextFile.Read(TextBuf, BUF_SIZE);
      for iBuf := 0 to Readed - 1 do
      begin
        AByte := TextBuf[iBuf];
        if (AByte = LF) then
        begin
          Index.Length := (FTextFile.Position - Readed + iBuf) - Index.OffSet - 1; // - 1 car on inclu pas le LF
          if LastIsCR then
            Dec(Index.Length);
          FIndexFile.Write(Index, SizeOf(Index));
          Index.OffSet := FTextFile.Position - Readed + iBuf + 1; // + 1 car on inclu pas le LF
        end;
        LastIsCR := (AByte = CR);
      end;
    end;
  finally
    FIndexFile.Free();
    FIndexFile := nil;
  end;
end;
 
{ TTextFileReader - Méthodes d'Accès }
 
function TTextFileReader.GetIndexed: Boolean;
begin
  Result := FIndexed and Assigned(FIndexFile);
end;
 
procedure TTextFileReader.SetIndexed(const Value: Boolean);
begin
  if FIndexed <> Value then
  begin
    if Assigned(FIndexFile) then
    begin
      FIndexFile.Free();
      FIndexFile := nil;
    end;
 
    FIndexed := Value;
    if FIndexed then
    begin
      if not FileExists(FIndexName) then
        if AutoIndexed then
          BuildLinesIndexes()
        else
          raise ETextFileReaderErrorIndex.Create(SIndexNotExist);
 
      FIndexFile := TFileStream.Create(FIndexName, fmOpenRead, fmShareDenyWrite)
    end;
  end;
end;
 
{ TTextFileReader - Méthodes Privées }
 
 
end.

**ShaiLeTroll** · 12/07/2007, 16h06

Bon, voilà une seconde version,
Indexed à False, on peut utiliser ReadLine[s] mais déconseillé car lent, il vaut mieux utiliser ReadString qui ne propose pas de seek (comme un TextFile normal)

mais si on utilise cet objet en mode Indexed ... eh bien, une fois l'index généré c'est instantané pour toutes les autres lectures (d'où un fichier qui est mis à jour la nuit et un process qui lance l'indexation juste après est le cas parfait, par contre un fichier mis à jour trop souvent, cela sera assez infame ...

voici le code

Code :

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
unit uTextFileReader;
 
interface
 
uses Windows, SysUtils, Classes;
 
type
  PTextFileReaderIndex = ^TTextFileReaderIndex;
  TTextFileReaderIndex = packed record
    OffSet: Int64;
    Length: Integer; // une Chaine Delphi ne peut pas dépasser cette taille
  end;
 
type
  TTextFileReader = class(TObject)
  protected
    FFileName: string;
    FIndexName: string;
    FTextFile: TFileStream;
    FIndexFile: TFileStream; // un File of aurait été plus pratique mais limité à 2Go, donc environ 178 millions de lignes, hors un fichier texte de 4Go, peut en contenir bien plus ...
    FIndexed: Boolean;
    FAutoIndexed: Boolean;
    FTextSize: Int64;
    FIndexCount: Int64;
    FIndexRecSize: Byte;
    FLinearPosition: Int64;
    function GetIndexed: Boolean;
    procedure SetIndexed(const Value: Boolean);
    function GetCount: Int64;
    function GetEOF: Boolean;
    function ReadLineFromIndexRec(IndexRec: TTextFileReaderIndex): string;
    function ReadIndex(Index: Cardinal): TTextFileReaderIndex;
    function ReadLineRaw(Index: Cardinal; OffSet: Int64 = 0): string;
  public
    constructor Create(const AFileName: string);
    destructor Destroy; override;
    procedure BuildLinesIndexes();
    function ReadLine(Index: Cardinal): string; // 4 Milliard de Ligne ?
    procedure ReadLines(IndexBegin, IndexEnd: Cardinal; Lines: TStrings; DoClear: Boolean = True);
    function ReadString(): string;
    procedure ReadStrings(ACount: Cardinal; Lines: TStrings; DoClear: Boolean = True);
    property Count: Int64 read GetCount;
    property OEF: Boolean read GetEOF;
    property FileName: string read FFileName;
    property IndexName: string read FIndexName;
    property TextFile: TFileStream read FTextFile;
    property Indexed: Boolean read GetIndexed write SetIndexed;
    property AutoIndexed: Boolean read FAutoIndexed write FAutoIndexed;
  end;
 
  ETextFileReaderErrorIndex = class(Exception);
 
implementation
 
resourcestring
  SIndexNotExist = 'Le Fichier d''Index n''existe pas !';
 
{ TTextFileReader }
 
 
{ TTextFileReader - Constructeurs }
 
constructor TTextFileReader.Create(const AFileName: string);
begin
  inherited Create();
 
  FIndexCount := -1;
  FIndexRecSize := SizeOf(TTextFileReaderIndex);
 
  FFileName := AFileName;
  FIndexName := FFileName+'.idx';
  FTextFile := TFileStream.Create(FileName, fmOpenRead, fmShareDenyWrite);
  FIndexFile := nil;
  FTextSize := FTextFile.Size;
  FLinearPosition := 0;
 
  Indexed := False;
  AutoIndexed := False;
end;
 
destructor TTextFileReader.Destroy;
begin
  if Assigned(FIndexFile) then
  begin
    FIndexFile.Free();
    FIndexFile := nil;
  end;
 
  if Assigned(FTextFile) then
  begin
    FTextFile.Free();
    FTextFile := nil;
  end;
 
  inherited;
end;
 
{ TTextFileReader - Méthodes Publiques }
 
procedure TTextFileReader.BuildLinesIndexes();
const
  BUF_SIZE = 1024;
  REC_BUF_SIZE = 65536;
  LF: Byte = 10;
  CR: Byte = 13;
var
  TextBuf: array[0..BUF_SIZE-1] of Byte;
  IndexRec: PTextFileReaderIndex;
  IndexesRec: array[0..REC_BUF_SIZE-1] of TTextFileReaderIndex;
  iBuf, Readed: Integer;
  AByte: Byte;
  LastIsCR: Boolean;
  iRec: Integer;
  IRSize: Integer;
begin
  FIndexFile := TFileStream.Create(FIndexName, fmCreate, fmShareExclusive);
  try
    // Positionnement au début du Fichier
    FTextFile.Seek(0, soFromBeginning);
    // Compteur/Index/Drapeau à Zéro
    iRec := 0;
    IRSize := REC_BUF_SIZE * SizeOf(IndexRec^);
    ZeroMemory(@IndexesRec, IRSize);
    IndexRec := @IndexesRec[iRec];
    LastIsCR := False;
    // Boucle jusqu'à la fin
    while (FTextFile.Position < FTextSize) do
    begin
      Readed := FTextFile.Read(TextBuf, BUF_SIZE);
      for iBuf := 0 to Readed - 1 do
      begin
        AByte := TextBuf[iBuf];
        if (AByte = LF) then
        begin
          IndexRec^.Length := (FTextFile.Position - Readed + iBuf) - IndexRec^.OffSet;
          if LastIsCR then
            Dec(IndexRec^.Length);
 
          if iRec = REC_BUF_SIZE then
          begin
            FIndexFile.Write(IndexesRec, IRSize);
            iRec := 0;
          end else
            Inc(iRec);
 
          IndexRec := @IndexesRec[iRec];
          IndexRec^.OffSet := FTextFile.Position - Readed + iBuf + 1; // + 1 car on inclu pas le LF
        end;
        LastIsCR := (AByte = CR);
      end;
    end;
    if IndexRec^.OffSet < FTextSize then
    begin
      IndexRec^.Length := FTextFile.Position - IndexRec^.OffSet;
      if iRec = REC_BUF_SIZE then
      begin
        FIndexFile.Write(IndexesRec, IRSize);
        iRec := 0;
      end else
        Inc(iRec);
    end;
 
    if iRec > 0 then
      FIndexFile.Write(IndexesRec, iRec * SizeOf(IndexRec^));
  finally
    FIndexFile.Free();
    FIndexFile := nil;
  end;
end;
 
function TTextFileReader.ReadLine(Index: Cardinal): string;
begin
  if FIndexed then
    Result := ReadLineFromIndexRec(ReadIndex(Index))
  else
    Result := ReadLineRaw(Index);
end;
 
procedure TTextFileReader.ReadLines(IndexBegin, IndexEnd: Cardinal; Lines: TStrings; DoClear: Boolean = True);
var
  Index: Cardinal; // le For Delphi 6 ne gère pas le Int64
begin
  if Assigned(Lines) then
  begin
    if DoClear then
      Lines.Clear();
 
    for Index := IndexBegin to IndexEnd do
      Lines.Add(ReadLine(Index));
  end;
end;
 
function TTextFileReader.ReadString: string;
begin
  Result := ReadLineRaw(0, FLinearPosition);
end;
 
procedure TTextFileReader.ReadStrings(ACount: Cardinal; Lines: TStrings; DoClear: Boolean = True);
var
  Index: Cardinal; // le For Delphi 6 ne gère pas le Int64
begin
  if Assigned(Lines) then
  begin
    if DoClear then
      Lines.Clear();
 
    for Index := 1 to ACount do
      Lines.Add(ReadString());
  end;
end;
 
{ TTextFileReader - Méthodes d'Accès }
 
function TTextFileReader.GetIndexed: Boolean;
begin
  Result := FIndexed and Assigned(FIndexFile);
end;
 
procedure TTextFileReader.SetIndexed(const Value: Boolean);
begin
  if FIndexed <> Value then
  begin
    if Assigned(FIndexFile) then
    begin
      FIndexFile.Free();
      FIndexFile := nil;
    end;
 
    FIndexed := Value;
    if FIndexed then
    begin
      if not FileExists(FIndexName) then
        if AutoIndexed then
          BuildLinesIndexes()
        else
          raise ETextFileReaderErrorIndex.Create(SIndexNotExist);
 
      FIndexFile := TFileStream.Create(FIndexName, fmOpenRead, fmShareDenyWrite);
      FIndexCount := FIndexFile.Size div FIndexRecSize;
    end;
  end;
end;
 
function TTextFileReader.GetCount: Int64;
begin
  Result := FIndexCount;
end;
 
function TTextFileReader.GetEOF: Boolean;
begin
  Result := FLinearPosition >= FTextSize;
end;
 
{ TTextFileReader - Méthodes Privées }
 
function TTextFileReader.ReadIndex(Index: Cardinal): TTextFileReaderIndex;
begin
  if FIndexed and Assigned(FIndexFile) and (Index < FIndexCount) then
  begin
    FIndexFile.Seek(Index * FIndexRecSize, soFromBeginning);
    FIndexFile.Read(Result, FIndexRecSize);
  end else
    ZeroMemory(@Result, FIndexRecSize);
end;
 
function TTextFileReader.ReadLineFromIndexRec(IndexRec: TTextFileReaderIndex): string;
begin
  if (IndexRec.OffSet >= 0) and (IndexRec.Length > 0) and (IndexRec.OffSet + IndexRec.Length <= FTextSize)then
  begin
    SetLength(Result, IndexRec.Length);
    FTextFile.Seek(IndexRec.OffSet, soFromBeginning);
    FTextFile.Read(Result[1], IndexRec.Length);
  end else
    Result := '';
end;
 
function TTextFileReader.ReadLineRaw(Index: Cardinal; OffSet: Int64 = 0): string;
const
  BUF_SIZE = 1024;
  LF: Byte = 10;
  CR: Byte = 13;
var
  TextBuf: array[0..BUF_SIZE-1] of Byte;
  IndexRec: TTextFileReaderIndex;
  iBuf, Readed: Integer;
  AByte: Byte;
  LastIsCR: Boolean;
  LineReaded: Cardinal;
begin
  // Positionnement au début du Fichier ou sur le Curseur de lecture linéaire
  FTextFile.Seek(OffSet, soFromBeginning);
 
  // Compteur/Index/Drapeau à Zéro
  IndexRec.OffSet := OffSet;
  IndexRec.Length := 0;
  LastIsCR := False;
  LineReaded := 0;
  // Boucle jusqu'à la fin
  while (FTextFile.Position < FTextSize) do
  begin
    Readed := FTextFile.Read(TextBuf, BUF_SIZE);
    for iBuf := 0 to Readed - 1 do
    begin
      AByte := TextBuf[iBuf];
      if (AByte = LF) then
      begin
        FLinearPosition := FTextFile.Position - Readed + iBuf;
        IndexRec.Length := FLinearPosition - IndexRec.OffSet;
        Inc(FLinearPosition); // car on inclu pas le LF dans la prochaine ligne
        if LastIsCR then
          Dec(IndexRec.Length);
        if (LineReaded = Index) then
        begin
          Result := ReadLineFromIndexRec(IndexRec);
          Exit;
        end;
        IndexRec.OffSet := FLinearPosition;
        Inc(LineReaded);
      end;
      LastIsCR := (AByte = CR);
    end;
  end;
  if IndexRec.OffSet < FTextSize then
  begin
    IndexRec.Length := FTextFile.Position - IndexRec.OffSet;
    FLinearPosition := FTextFile.Position + 1; // + 1 car on inclu pas le LF
    if (LineReaded = Index) then
    begin
      Result := ReadLineFromIndexRec(IndexRec);
      Exit;
    end;
  end;
  Result := '';
end;
 
end.

et voici comment l'utiliser facilement

Code :

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
procedure TFrmTestFichier.BtnBigTextBuildIndexClick(Sender: TObject);
begin
  with TTextFileReader.Create(EdPathFileBigText.Text) do
  begin
    BuildLinesIndexes();
    Free();
  end;
end;
 
procedure TFrmTestFichier.BtnBigTextReadByIndexClick(Sender: TObject);
begin
  with TTextFileReader.Create(EdPathFileBigText.Text) do
  begin
    Indexed := True;
    ReadLines(0, 10, ListBoxBigText.Items);
    Free();
  end;
end;
 
procedure TFrmTestFichier.BtnBigTextReadRawClick(Sender: TObject);
begin
  with TTextFileReader.Create(EdPathFileBigText.Text) do
  begin
    ReadLines(0, 10, ListBoxBigText.Items);
    Free();
  end;
end;
 
procedure TFrmTestFichier.BtnBigTextReadStringClick(Sender: TObject);
begin
  with TTextFileReader.Create(EdPathFileBigText.Text) do
  begin
    ReadStrings(10, ListBoxBigText.Items);
    Free();
  end;
end;

EDIT, j'ai optimisé deux trois trucs ... bon je me suis fait un fichier qui contient des lignes de la forme '0123456789' sachant que le fichier fait 512Mo (536*870*912o) cela fait je crois si mes calculs sont bon 44 736 512 lignes ... vu que chaque index prenne 12o cela donne un fichier d'index de 536 838 144o mais je n'ai que 536*507*740 dans mon fichier, donc je pense à un bug pour le dernier buffer ...

Cela a mis 180s pour être généré, finalement, cela pourrait être même fait à l'ouverture de l'application, ou par exemple si la date du fichier texte est plus récente que la date du fichier idx ...

EDIT : bien sur, il manquait un ^ et un suite au passage en array de IndexRec au lieu d'écrire un par un les Rec ... mais il y a encore une foirade à la fin du fichier ... grrr

**ShaiLeTroll** · 13/07/2007, 16h58

Bon, j'ai trouvé l'erreur, problème de gestion du buffer de RecIndex, j'ai pris CountRec au lieu de CountRec - 1, erreur bête, bon donc voilà, ce code permet de créer un index pour un fichier texte volumineux, cela peut mettre pour un fichier de 4Go problablement plus de 10 minutes, mais en nocturne personne le verra, surtout que l'accès à une fenêtre d'une centaine de ligne pour alimenter une StringGrid sera instantanné, mais faudra gérer à l'affichage un faux scrolling ... je pense qu'il faut faire une surcharge de la DrawGrid ... ça aussi c'est sympa à faire, c'est comme le fait le DBGrid ... et comme ma machine n'a pas trop été chargé aujourd'hui pour mes 512Mo (sous la forme de 44739242 ligne), cela n'a mais que 150s ... (3Gz, 512Mo de RAM, et cela ne prend que pour le traitement pas plus de 1Mo ... compromis puissance conso correct non ?)

Voir CE SUJET la version corrigée

**darkvadr** · 03/08/2007, 21h27

merci pour tout shai.
Tu assures, malheureusement j'ai finit mon contrat et suis reparti pour de nouvelles aventures (un gros truc en c++ (beuuuuurrrrrkkkk)).

Mais je note tout ca.
Car cette histoire de huge files n'est pas terminée.
Et quand je dis huge je ne ments pas...

Et non il n'y aura pas de nocturne...
Car pour des raisons subtiles (par exemple detection d'un header de jpg), lors du clonage (en commandes ATA en attaquant directement les ports IDE) une alarme peut etre déclenchée...

Bref on aua toujours un opérateur devant.

Et le besoin d'optimisation se fait sentir.

Pour l'instant ca n'urge plus.
Mais ca me passionne tellement.

Il faut aussi que j'implemente un parser NTFS (pour les mft)
et pour la fat
et pour ext2fs ext3fs
allez HFS
et hop pourquoi pas reiserFS

et des fonctions de carving...
et du hashage...

Et tout le barzing

**jeromefer** · 28/04/2012, 06h23

Merci ShaiLeTroll pour le partage de competence !!

Cela servira un jour ou l'autre !
Jérôme

**GoustiFruit** · 28/04/2012, 11h39

Euh une question qui m'interroge... Ca sert à quoi de mettre l'équivalent de 80 Go dans un StringGrid ??? C'est un composant *visuel* donc destiné à être parcouru *visuellement*... mais 80 Go de données à visualiser, qui va s'y coller ??? A mon avis il y a un problème dans la conception du bidule, les données à visualiser devraient se limiter au strict minimum pour qu'un humain puisse s'en occuper; et si c'est pour un traitement machine alors la visualisation ne sert à rien !?

**ShaiLeTroll** · 02/05/2012, 13h10

C'est de l'exhumation de Sujet !
jeromefer le profanateur de sujet enterré !

C'est gentil quand même !

5 ans après, il y en a qui ouvre le débat ! Allez Trollons tous ensemble

Je suis d'accord avec toi GoustiFruit, sinon le sujet évoquait des fichiers de 4Go, et de toute façon, on peut pas dépasser 40Go sur NTFS ?
Donc ton exemple de 80Go n'est-il pas maladroit ?
Et comme on ne peut pas dépasser 2Go pour un process Win32, c'est encore plus hors sujet

Et tu n'as pas lu la question d'origine !

Envoyé par darkvadr

Je cherche donc a produire ceci:

soit nb le nombre de lignes visibles à l'ecran sur l'ecran.
On charge une partie du fichier dans le stringrid...
Quand on deplace l'ascensseur on charge la partie du fichier correspondante à la partie visible et on libere la memoire correspondant à la partie maintenant invisible.

il souhaitait bien mettre en place un système de lecture séquentielle permettant un accès libre dans les 4Go sans devoir charger le fichier mais juste un fragment de la taille du TStringGrid en fait c'est ce que fait le TDBGrid avec un TDataSet, il n'affiche que les lignes utiles !

J'ai pu voir des applications générant des Go de données par jour mais vers des DB Oracle, donc ce genre de chose était déjà géré, d'ailleurs rare l'utilisateur devant consulter directement les données mais plutôt un DataMaining (génération nocturne)

C'était justement l'objectif de ma réponse que j'ai apporté !
le TTextFileReader analyse le fichier texte en créant un fichier d'Index !
Une fois l'index disponible, l'affichage dans la TStringGrid est instantané car on ne va lire que les lignes TopRow à TopRow+RowCount
Avec un peu d'astuce, un petit thread, on peut différer le traitement du fichier d'index en anticipant la demande mais sans obligatoirement lire tous le fichier !

Pour info, j'ai finalement utilisé ce code que j'avais écrit pour le forum dans un projet, il est donc fiable (pour ce que j'ai testé)
Le but était découper rapidement des fichiers SQL (issu de MySQL Administrator ou TMyDump de MyDAC), la version de MyDAC chargeait tout le fichier dans la TStrings SQL du TMyDump en fait cela consommait 3 fois la mémoire, donc plafond à 600Mo mais en pratique les clients pouvaient avoir 2Go pour un fichier, et cela pour une seule table parmis 100 autres ^_^), j'ai ainsi passer la consommation juste à 64K peu importe la taille du fichier
Important, c'était le système de restauration des bases de données intégré depuis la création du logiciel mais il n'avait pas anticipé une telle volumétrie de données !
C'est ballot de faire un Restore et d'avoir un message "Mémoire Insuffisante"

Peu de temps après Devart a sorti une version de TMyDump qui n'avait plus ce problème de consommation mémoire (à base de TFileStream, je crois), je n'ai jamais pu le testé !

**GoustiFruit** · 02/05/2012, 22h30

Arf 5 ans, j'avais pas vu ! Un sujet qui revient tous les quinquennats :-D

Euh, avec le NTFS il me semble qu'on peut atteindre les tera-octets non ?

**philnext** · 03/05/2012, 11h50

Sinon, un peu dans le même esprit mais avec d'autres solutions, je vous conseille, si vous ne connaissez pas, les composants/logiciels d'Arnaud Bouchez qui sont toujours de très bonne qualité.

http://blog.synopse.info/tag/BigTable

**ShaiLeTroll** · 03/05/2012, 12h11

16To maximum ? n'ayant jamais eu de DD de plus de 80 ou 160Go !

Il n'y a pas aussi une histoire de cluster ?

A mes débuts, j'avais tenté d'apprendre le C durant mon alternance (on apprenait que la Java à l'école et Delphi en entreprise) dans la bible du programmeur C\C++, j'ai découvert toutes ces histoires sur les disques, secteurs, pistes ... moi qui n'avait encore fait que du ReadLn ou BlockRead en Delphi, j'étais surpris de la précision de fonction bas niveau du C, je n'ai même pas dépassé la page 200 (sur 1000) de ce bouquin, trop la flemme !

La taille du fichier est limité par le nombre de cluster, donc plus le cluster est grand plus la limite augmente, la FAT ou NTFS, c'est un truc dont je ne me suis jamais vraiment préoccupé, je suis resté sur mes vieilles connaissance de FAT32 de mes débuts !

**GoustiFruit** · 03/05/2012, 15h22

Envoyé par philnext

Sinon, un peu dans le même esprit mais avec d'autres solutions, je vous conseille, si vous ne connaissez pas, les composants/logiciels d'Arnaud Bouchez qui sont toujours de très bonne qualité.

http://blog.synopse.info/tag/BigTable

J'avais failli le citer quand j'ai lu ce thread, et puis je me suis abstenu parce qu'ensuite on aurait pu me demander des détails... et ce que fait Arnaud Bouchez est trop pointu pour moi !

Mais j'adore lire son blog et ses articles techniques, même si je n'en comprends que 5% environ

[D7][StringGrid] Très gros fichiers à parser (comment faire un streaming?)

Composants VCL Delphi

Discussions similaires

Partager

Partager