Fichier CSV, Compteur de lignes

**Hypollite76** · 13/08/2007, 15h31

Bonjour,
y'a t'il une commande afin de savoir combien y'a t'il eu d'enregistrement dans le fichier je pensais faire un boucle, mais bon si il existe fonction?

**Rayek** · 13/08/2007, 16h35

Tu charges ton fichier dans une TStringList et tu lui demande de te retourner
count

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
var
  lst : TStringList;
begin
  lst := TStringList.create;
  try
    lst.loadFromFile('Monfichier.csv');
    Showmessage('Mon fichier a ' + intToStr(lst.count) + ' lignes'); 
  finally
    lst.free;
  end;
end;

**ShaiLeTroll** · 13/08/2007, 19h01

La TStringlist a un seul inconvénient, elle va charger l'intégralité de fichier en mémoire, plus allouer un grand nombre de pointeur ... ce code ci est plus rapide, et encore via un TFileStream et une lecture bufferisée ne comptant que les #10 ou #13#10, cela irait encore plus vite, mais les deux solutions sont équivalentes en consommation mémoire

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
procedure CountLn(const FileName: string): Cardinal;
var
   FLNC: TextFile;
begin
      Result := 0;
      AssignFile(FLNC, FileName);
      Reset(FLNC);
      try
         while not Eof(FLNC) do
         begin
            Inc(Result);
            Readln(FLNC);
         end;
      finally
         CloseFile(FLNC);
      end;
end;

**Hypollite76** · 20/08/2007, 13h30

oui mais moi je laisse ouvert le fichier car je travaille dedant, et je ferme vraiment au dernier moment . Quand je fais ta boucle ca fonctionne, le souci ai que je me retrouve à la fin du fichier, et moi je veux pas le fermer, je veux juste revenir au début, comment faire fermer pui rouvrir le fichier.
Merci d votre aide

**ShaiLeTroll** · 20/08/2007, 17h15

Tu refais un Reset(FLNC), tout simplement pour le lire ... ça sens je dirais la barre de progression durant la lecture d'un fichier non ?

si c'est le cas, tu récupère la taille du fichier par une fonction qui ressemble à ceci

Code :

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

1
2
3
4
5
6
7
8
9
  function GetFileSize(const FileName: string): Integer;
  var
    f: file of Byte;
  begin
    AssignFile(f, Filename);
    Reset(f);
    Result := FileSize(f);
    CloseFile(f);
  end;

ou en directement

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
var
  fichierCSV: Textfile;
  Taille: Int64;
begin
  ...
  // AssignFile et Reset
  ...
    Int64Rec(Taille).Lo := GetFileSize(TTextRec(fichierCSV).Handle, @Int64Rec(Taille).Hi);
    ProgressBar.Position:= 0; 
    ProgressBar.Max:= 1000; 
  ...
   // la boucle
   // la progression
   ProgressBar.Position := Trunc(CumulLength / Taille * 1000); // voir div au lieu / et trunc
end;

ensuite à chaque lecture, tu incrémente un compteur de la taille de la chaine lu (plus 2 pour le CR LF)

ainsi tu peux faire une barre de progression via la taille en octet en en nombre de ligne, ce qui visuellement donnera la même chose ...

**MychaL** · 20/08/2007, 23h23

Bonsoir,

je m'insinue dans ce topic pour poser une petite question.....

je dois etre fatigué car je ne trouve pas par une recherche simple les possibilites maximales des TStringList ou TList.

Combien d elements peuvent etre contenus ?

Pour gerer une liste de fichier, quel est le moyen le plus adequat et assez performant ?

Merci

**ALWEBER** · 21/08/2007, 07h21

Il n'y a pas de limitation à la taille d'un TStringList ou avoisinant hors celle allouée théoriquement à l'affectation d'un processus (4Go). Par expérience comme mentionné ci dessus on travaille avec des pointeurs donc à partir d'un certain niveau le système par en vrille ( swap mémoire et autre). J'ai trié des stringList de 100 000 lignes en 1mn30.
Dans certain cas le mapping du TstringList vers un TmemoryStream donne de bon résultats

**ShaiLeTroll** · 21/08/2007, 12h09

Les limitations de la TStringList et TList sont explicite dans l'unité Classes.pas puisqu'il est à savoir qu'en Delphi aucune variable ne peut excéder 2Go !

Puisque la TStringList et la TList gère en interne un tableau dynamique (pas un tableau pascal mais un zone mémoire géré comme un tableau, c'est ce que l'on utilisait en Delphi3 pour simuler des tableaux dynamiques alors que ceux-ci n'existait pas ...) donc ce tableau ne peut excéder les 2Go, pour la TStringList, le calcul est simple, chaque item du tableau contienne une chaine (pointeur + compteur de référence + longueur) donc 12o et un Tobject (pointeur) donc 4o, en total chaque item occupe dans le tableau 16o, ce qui amène à un maximum de 134 217 728 items, il faut bien sur se rendre compte que ce n'est que le tableau de pointeur, cela ne compte pas le volume occupé par CHAQUE chaine, mais bien sur, la limitation théorique est vide explosé si l'on manipule la TStringList par sa propriété Text qui évidement sera limité aussi à 2Go ... mais sans 3Go de RAM, cela sera tellement lent, qu'il vaut mieux travailler au un TFileStream pour gérer une tel liste ... car les aller-retour mémoire vive-mémoire virtuelle sont plus couteux que la manipulation d'un fichier par sont propres programmes ... voir la classe en exemple qui permet de gérer des fichiers textes de 10Go via un index en fichier qui n'est qu'un tableau sur fichier au lieu d'un tableau mémoire ... (j'ai écrit cette classe pour une demande similaire sur les fichiers sur ce forum)

Pour la TList, on devrait avoir plus d'élement possible, mais c'est la même limite qui a été choisi ...

Maintenant, pour la lecture de fichier, la TStringList n'est a utiliser qu'avec des très petits fichiers (genre fichier ini mais autant prendre le TIniFiles bien sur), personnellement, je n'utilise que les fichiers binaires (BlockRead ou TFileStream) ou fichier texte (ReadLn ou TTextFileReader)

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
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
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
  TTextFileReaderBuildIndexProgress = procedure(Sender: TObject; const Position, Size: Int64; var Aborting: Boolean) of object;
 
  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;
    FOnBuildIndexProgress: TTextFileReaderBuildIndexProgress;
    FDeleteIndexOnFree: Boolean;
    function GetIndexed: Boolean;
    procedure SetIndexed(const Value: Boolean);
    function GetCount: Int64;
    function GetEOF: Boolean;
    function ReadLineFromIndexRec(const IndexRec: TTextFileReaderIndex): string;
    function ReadIndex(const Index: Int64): TTextFileReaderIndex;
    function ReadLineRaw(const Index: Int64; const OffSet: Int64 = 0): string;
    function DoBuildIndexProgress(const Position, Size: Int64): Boolean;
  public
    constructor Create(const AFileName: string);
    destructor Destroy; override;
    procedure BuildLinesIndexes();
    function ReadLine(const Index: Int64): string;
    procedure ReadLines(const IndexBegin, IndexEnd: Int64; Lines: TStrings; DoClear: Boolean = True);
    function ReadString(): string;
    procedure ReadStrings(const ACount: Word; Lines: TStrings; DoClear: Boolean = True);  // Il semble raisonnable de limiter la lecture par TStrings à 65535
    procedure DeleteLine(const Index: Int64); // Opération Lente
    procedure DeleteLines(const IndexBegin, IndexEnd: Int64); // Opération Lente
    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; // pour mettre la valeur à True, il faut que le fichier existe, ou alors que AutoIndexed soit à true
    property AutoIndexed: Boolean read FAutoIndexed write FAutoIndexed; // Si l'on change la propriété Indexed, cela génère le fichier automatiquement
    property Lines[const Index: Int64]: string read ReadLine;
    property OnBuildIndexProgress: TTextFileReaderBuildIndexProgress read FOnBuildIndexProgress write FOnBuildIndexProgress;
    property DeleteIndexOnFree: Boolean read FDeleteIndexOnFree write FDeleteIndexOnFree;
  end;
 
  ETextFileReaderErrorIndex = class(Exception);
  ETextFileReaderError = class(Exception);
 
implementation
 
resourcestring
  SIndexNotExist = 'Le Fichier d''Index n''existe pas !';
  STooMuchRead = 'Le Nombre Maximal de la Lecture par lot doit inférieur ou égale à %d au lieu de %d';
  STooMuchDelete = 'Le Nombre Maximal de la Suppression par lot doit être inférieur ou égale à %d au lieu de %d';
  SNoIndexedDelete = 'La Suppression n''est possible qu''avec un Fichier Indexé';
 
{ 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;
 
  if FDeleteIndexOnFree then
    if FileExists(FIndexName) then
      DeleteFile(FIndexName);
 
  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: packed array[0..REC_BUF_SIZE-1] of TTextFileReaderIndex;
  iBuf, Readed: Integer;
  AByte: Byte;
  LastIsCR: Boolean;
  iRec, MaxRec: 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;
    MaxRec := REC_BUF_SIZE - 1;
    IRSize := REC_BUF_SIZE * SizeOf(IndexRec^);
    ZeroMemory(@IndexesRec, IRSize);
    IndexRec := @IndexesRec[iRec];
    LastIsCR := False;
    // Boucle jusqu'à la fin
    while (FTextFile.Position < FTextSize) do
    begin
      if not DoBuildIndexProgress(FTextFile.Position, FTextSize) then
        Abort;
 
      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 = MaxRec 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 = MaxRec 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(const Index: Int64): string;
begin
  if FIndexed then
    Result := ReadLineFromIndexRec(ReadIndex(Index))
  else
    Result := ReadLineRaw(Index);
end;
 
procedure TTextFileReader.ReadLines(const IndexBegin, IndexEnd: Int64; Lines: TStrings; DoClear: Boolean = True);
var
  Index: Word; // le For Delphi 6 ne gère pas le Int64, et il ne serait pas raisonnable de lire autant
  IndexCount: Int64;
  IndexMax: Int64;
begin
  if Assigned(Lines) then
  begin
    if DoClear then
      Lines.Clear();
 
    if IndexEnd < Count then
      IndexMax := IndexEnd
    else
      IndexMax := Count - 1;
 
    IndexCount := IndexMax - IndexBegin;
    if (0 <= IndexCount) and (IndexCount <= High(Word)) then
    begin
      Lines.Capacity := Lines.Count + IndexCount;
      for Index := 0 to IndexMax - IndexBegin do
        Lines.Add(ReadLine(IndexBegin + Index));
    end else
    begin
      raise ETextFileReaderError.CreateFmt(STooMuchRead, [High(Word), IndexCount]);
    end;
  end;
end;
 
function TTextFileReader.ReadString: string;
begin
  Result := ReadLineRaw(0, FLinearPosition);
end;
 
procedure TTextFileReader.ReadStrings(const ACount: Word; Lines: TStrings; DoClear: Boolean = True);
var
  Index: Word; // le For Delphi 6 ne gère pas le Int64, et il ne serait pas raisonnable de lire autant
begin
  if Assigned(Lines) then
  begin
    if DoClear then
      Lines.Clear();
 
    Lines.Capacity := ACount;
    for Index := 1 to ACount do
      Lines.Add(ReadString());
  end;
end;
 
procedure TTextFileReader.DeleteLine(const Index: Int64);
begin
  if Indexed then
  begin
    // Je n'ai jamais eu le courage de le faire !
  end else
  begin
    ETextFileReaderError.Create(SNoIndexedDelete);
  end;
end;
 
procedure TTextFileReader.DeleteLines(const IndexBegin, IndexEnd: Int64);
var
  Index: Cardinal; // le For Delphi 6 ne gère pas le Int64, mais la suppression de 4 Millards de Lignes cela suffit
  ACount: Int64;
begin
  ACount := IndexEnd - IndexBegin;
  if (0 <= ACount) and (ACount <= High(Word)) then
  begin
    for Index := IndexBegin to IndexEnd do
      DeleteLine(Index);
  end else
  begin
    raise ETextFileReaderError.CreateFmt(STooMuchDelete, [High(Cardinal), ACount]);
  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(const Index: Int64): TTextFileReaderIndex;
begin
  if Indexed and (Index < FIndexCount) then
  begin
    FIndexFile.Seek(Index * FIndexRecSize, soFromBeginning);
    FIndexFile.Read(Result, FIndexRecSize);
  end else
    ZeroMemory(@Result, FIndexRecSize);
end;
 
function TTextFileReader.ReadLineFromIndexRec(const 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(const Index: Int64; const 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: Int64;
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;
 
function TTextFileReader.DoBuildIndexProgress(const Position, Size: Int64): Boolean;
begin
  if Assigned(FOnBuildIndexProgress) then
  begin
    Result := False;
    FOnBuildIndexProgress(Self, Position, Size, Result);
    Result := not Result; // la fonctionne renvoie True si on continue
  end
  else
    Result := True;
end;
 
 
 
end.

Fichier CSV, Compteur de lignes

Langage Delphi

Discussions similaires

Partager

Partager