IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Composants VCL Delphi Discussion :

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


Sujet :

Composants VCL Delphi

  1. #1
    Membre habitué
    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    160
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 160
    Points : 167
    Points
    167
    Par défaut [D7][StringGrid] Très gros fichiers à parser (comment faire un streaming?)
    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.

  2. #2
    Futur Membre du Club
    Profil pro
    Inscrit en
    Octobre 2006
    Messages
    7
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2006
    Messages : 7
    Points : 5
    Points
    5
    Par défaut avec un tableau dynamic c pas possible ?

  3. #3
    Membre habitué
    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    160
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 160
    Points : 167
    Points
    167
    Par défaut
    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.

  4. #4
    Modérateur
    Avatar de Rayek
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Mars 2005
    Messages
    5 235
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Haute Savoie (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mars 2005
    Messages : 5 235
    Points : 8 504
    Points
    8 504
    Par défaut
    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.

  5. #5
    Expert éminent
    Avatar de qi130
    Homme Profil pro
    Expert Processus IT
    Inscrit en
    Mars 2003
    Messages
    3 925
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 63
    Localisation : France

    Informations professionnelles :
    Activité : Expert Processus IT
    Secteur : Finance

    Informations forums :
    Inscription : Mars 2003
    Messages : 3 925
    Points : 6 040
    Points
    6 040
    Par défaut
    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.

  6. #6
    Expert éminent sénior
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    13 723
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 13 723
    Points : 25 622
    Points
    25 622
    Par défaut
    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 ...

  7. #7
    Expert éminent sénior
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    13 723
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 13 723
    Points : 25 622
    Points
    25 622
    Par défaut
    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.

  8. #8
    Expert éminent sénior
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    13 723
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 13 723
    Points : 25 622
    Points
    25 622
    Par défaut
    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

  9. #9
    Expert éminent sénior
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    13 723
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 13 723
    Points : 25 622
    Points
    25 622
    Par défaut
    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

  10. #10
    Membre habitué
    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    160
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 160
    Points : 167
    Points
    167
    Par défaut
    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

  11. #11
    Membre à l'essai
    Profil pro
    Inscrit en
    Décembre 2006
    Messages
    8
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2006
    Messages : 8
    Points : 11
    Points
    11
    Par défaut
    Merci ShaiLeTroll pour le partage de competence !!
    Cela servira un jour ou l'autre !
    Jérôme

  12. #12
    Membre éclairé
    Profil pro
    Inscrit en
    Octobre 2002
    Messages
    707
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2002
    Messages : 707
    Points : 777
    Points
    777
    Par défaut
    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 !?

  13. #13
    Expert éminent sénior
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    13 723
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 13 723
    Points : 25 622
    Points
    25 622
    Par défaut
    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 !

    Citation Envoyé par darkvadr Voir le message
    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é !

  14. #14
    Membre éclairé
    Profil pro
    Inscrit en
    Octobre 2002
    Messages
    707
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2002
    Messages : 707
    Points : 777
    Points
    777
    Par défaut
    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 ?

  15. #15
    Membre chevronné Avatar de philnext
    Profil pro
    Inscrit en
    Octobre 2002
    Messages
    1 552
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2002
    Messages : 1 552
    Points : 1 780
    Points
    1 780
    Par défaut
    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

  16. #16
    Expert éminent sénior
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    13 723
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 13 723
    Points : 25 622
    Points
    25 622
    Par défaut
    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 !

  17. #17
    Membre éclairé
    Profil pro
    Inscrit en
    Octobre 2002
    Messages
    707
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2002
    Messages : 707
    Points : 777
    Points
    777
    Par défaut
    Citation Envoyé par philnext Voir le message
    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

Discussions similaires

  1. [HTML] Parcours d'une table HTML pour creer un fichier CSV : comment faire ?
    Par Thomus38 dans le forum Balisage (X)HTML et validation W3C
    Réponses: 1
    Dernier message: 28/06/2007, 13h19
  2. Crée un flux Fichier->out , comment faire ?
    Par kedare dans le forum Servlets/JSP
    Réponses: 3
    Dernier message: 27/03/2007, 12h41
  3. Fichier caché : comment faire
    Par izeba dans le forum Sécurité
    Réponses: 6
    Dernier message: 09/11/2006, 21h18
  4. Transformer un très gros fichier XML avec XSL
    Par wozzz dans le forum Format d'échange (XML, JSON...)
    Réponses: 3
    Dernier message: 30/05/2006, 11h57
  5. Je suis un gros boulet ou comment faire de la 2D avec DX
    Par Freakazoid dans le forum DirectX
    Réponses: 4
    Dernier message: 19/06/2004, 16h55

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo