Partir Archivos

[jorge_mosquera]

Delphi 7 Enterprise

Tengo un archivo plano bastante grande, y necesito partirlo en trozos mas pequeños para hacerlo mas manejable, y poder procesarlos de manera individual.

Intente con un procedimiento que utiliza BLOCKREAD y BLOCKWRITE, pero tengo un problema.

Si el registro es este

1,EPS028,CC,38471049,SALAZAR,CARDONA
2,EPS028,CC,29897965,MARTINEZ,DE
3,EPS028,RC,31600888,GARCIA,OSPINA
4,EPS028,CC,9990036,HERRERA,ROBLEDO

Si por ejemplo quiero partirlo en nuevos archivos de 2 registros cada uno, obtengo

1,EPS028,CC,38471049,SALAZAR,CARDONA
2,EPS028,CC,29897

Es decir, algunos registros quedan incompletos.

El archivo pude traer cualquier cantidad de campos (separados por comas), y generalmente son muy grandes (> 50 MB).

Como puedo hacer para partir una cantidad especifica de registros, pero con la tranquilidad de que estos queden completos?

Muchas gracias

[[seoane]]

Así de pronto, se me ocurre algo como esto:

EDITO: El código corregido se encuentra mas abajo

[[egostar]]

seoane, probe el código y si, me crea los dos archivos, solo que en el primero me hace una copia del original y el segundo me deja un archivo vacio.

Salvo tu mejor opinion, lo que yo haría es hacer un barrido del archivo para saber cuantas lineas tiene (quiero pensar que es una archivo con LFyCR).

Después sí, crear los archivos (2,3,4, los que se deseen) pero partiendolos por lineas y no por bytes.

Saludos

[[seoane]]

Efectivamente egostar, parece que la instrucción FileSize no funciona muy bien con los archivos de texto. Pero todo tiene solución:

Código Delphi [-]
var
  Str: String;
  Source, Dest: TextFile;
  Size: Integer;
  F: File;
begin
  Size:= 0;
  // Abrimos el archivo sin tipo para averiguar su tamaño en bytes
  AssignFile(F,'C:\Origen.txt');
  {$I-}
    Reset(F,1);
  {$I+}
  if IOResult = 0 then
  begin
    Size:= FileSize(F) div 2;
    CloseFile(F);
  end;
  // Ahora abrimos el archivo como texto
  AssignFile(Source,'C:\Origen.txt');
  {$I-}
    Reset(Source);
  {$I+}
  if IOResult = 0 then
  begin
    // Creamos el primer trozo
    AssignFile(Dest,'C:\Trozo1.txt');
    {$I-}
      Rewrite(Dest);
    {$I+}
    if IOResult = 0 then
    begin
      while (not Eof(Source)) and (Size > 0) do
      begin
        Readln(Source,Str);
        Writeln(Dest,Str);
        dec(Size,Length(Str)+2);
      end;
      CloseFile(Dest);
    end;
    // Creamos el segundo trozo
    AssignFile(Dest,'C:\Trozo2.txt');
    {$I-}
      Rewrite(Dest);
    {$I+}
    if IOResult = 0 then
    begin
      while not Eof(Source) do
      begin
        Readln(Source,Str);
        Writeln(Dest,Str);
      end;
      CloseFile(Dest);
    end;
    CloseFile(Source);
  end
end;

[[egostar]]

Hombre, pues quedo de 10.

Hice dos pruebas.

1. Con lineas pares, es decir, 12 lineas

Creo los dos archivos con 6 lineas cada uno, perfecto.

2. Con lineas impares, 11 lineas

Debo reconocer que pense mal, pense que en lineas impares habria un bug y partiria una linea a la mitad, pero no, sorpresa, deja 6 lineas en uno y 5 lineas en el segundo.

Saludos y mis respetos

[[seoane]]

Y para dar mas alternativas. Probemos con TStringList:

Partiendo el archivo por numero de lineas:

Código Delphi [-]
var
  Origen, Destino: TStringList;
  i: integer;
begin
  Origen:= TStringList.Create;
  try
    Destino:= TStringList.Create;
    try
      Origen.LoadFromFile('C:\Origen.txt');
      for i:= 0 to Origen.Count div 2 do
        Destino.Add(Origen[i]);
      Destino.SaveToFile('C:\Trozo1.txt');
      Destino.Clear;
      for i:= (Origen.Count div 2) + 1 to Origen.Count - 1 do
        Destino.Add(Origen[i]);
      Destino.SaveToFile('C:\Trozo2.txt');
    finally
      Destino.Free;
    end;
  finally
    Origen.Free;
  end;
end;

y por tamaño en bytes:

Código Delphi [-]
var
  Origen, Destino: TStringList;
  i, Size: integer;
begin
  Origen:= TStringList.Create;
  try
    Destino:= TStringList.Create;
    try
      Origen.LoadFromFile('C:\Origen.txt');
      Size:= Length(Origen.Text) div 2;
      i:= 0;
      while (i < Origen.Count) and (Size > 0) do
      begin
        Destino.Add(Origen[i]);
        dec(Size,Length(Origen[i])+2);
        inc(i);
      end;
      Destino.SaveToFile('C:\Trozo1.txt');
      Destino.Clear;
      while i < Origen.Count do
      begin
        Destino.Add(Origen[i]);
        inc(i);
      end;
      Destino.SaveToFile('C:\Trozo2.txt');
    finally
      Destino.Free;
    end;
  finally
    Origen.Free;
  end;
end;

Las ventaja de usar TStringList es que el se encarga de corregir los posibles problemas con los retornos de carro. La desventaja es el intenso trabajo sobre la memoria.

[jorge_mosquera]

Amigos, muchas gracias por las ideas que me han dado.
Le verdad SI he partido los archivos utilizando TStringList, y recorriendo el archivo original, y me ha funcionado muy bien, solo que es algo lento.

Definitivamente a nadie se le ocurre como utilizar blockread y blockwrite para este cometido?

gracias

[[basti]]

Trabajar con archivos de texto y blockread, es algo complicado, se me ocurre algo así, pero no sé si el rendimiento será superior al modelo con StringList:

Código Delphi [-]
  const
     MAX_REC_READ = 32000; // por ejemplo


  // copia aproximadamente los bytes de MAX_REC_READ
  // devuelve si no ha podido copiar todos
  function CopyFile(var forg, fdest : file) : boolean;
  var
    bytesLeidos : integer;
    buffer: array[1..MAX_REC_READ] of byte;
    bEOL : byte;

  begin
    Result := true;
    BlockRead(forg, buffer, MAX_REC_READ, bytesLeidos);
    BlockWrite(fdest, buffer, bytesLeidos);
    if bytesLeidos = MAX_REC_READ then // buscamos hasta el final del registro
    begin
       repeat
          BlockRead(forg, bEOL, 1, bytesLeidos);
          BlockWrite(fdest, bEOL, bytesLeidos);
       until eof(forg) or (bEOL = 10) // cambiar por 13 si el final de línea es sólo con #13;

    end
    else Result := false;
  end;

// programa principal
var
  forg, fdest : File;
  i : integer;
begin
  AssignFile(forg, 'origen.txt');
  Reset(forg, 1);
  i := 0;
  AssignFile(fdest, 'destino' + IntToStr(i) + '.txt');
  rewrite(fdest, 1);
  while CopyFile(forg, fdest) do
  begin
    CloseFile(fdest);
    inc(i);
    AssignFile(fdest, 'destino' + IntToStr(i) + '.txt');
    rewrite(fdest, 1);
  end;
  CloseFile(fdest);
  CloseFile(forg);
end.

[[seoane]]

Empezado por jorge_mosquera

Le verdad SI he partido los archivos utilizando TStringList, y recorriendo el archivo original, y me ha funcionado muy bien, solo que es algo lento.

No hubiera estado demás que mencionaras lo que habías intentado tu, así no hubiéramos perdido el tiempo. Incluso, tampoco hubiera sobrado un poco del código que utilizas.

De todas formas:

Código Delphi [-]
function Min(i,j: Integer): Integer;
begin
  if i < j then
    Result:= i
  else
    Result:= j;
end;

procedure Partir(Filename: string);
var
  Source, Dest: File;
  Size, Leidos, Escritos: Integer;
  Buffer: PChar;
begin
  AssignFile(Source,Filename);
  {$I-}
    Reset(Source,1);
  {$I+}
  if IOResult = 0 then
  try
    Size:= FileSize(Source) div 2;
    // Creamos un buffer de 1Mb
    GetMem(Buffer,1024 * 1024);
    try
      // Creamos el primer trozo
      AssignFile(Dest,Filename + '.001');
      {$I-}
        Rewrite(Dest,1);
      {$I+}
      if IOResult = 0 then
      try
        while (not Eof(Source)) and (Size > 0) do
        begin
          BlockRead(Source,Buffer^,Min(1024 * 1024,Size),Leidos);
          BlockWrite(Dest,Buffer^,Leidos,Escritos);
          dec(Size,Escritos);
        end;
        // Ajustamos el final de linea
        Buffer[0]:= #0;
        while (not Eof(Source)) and (Buffer[0] <> #10) do
        begin
          Buffer[0]:= #0;
          BlockRead(Source,Buffer^,1,Leidos);
          BlockWrite(Dest,Buffer^,Leidos,Escritos);
        end;
      finally
        CloseFile(Dest);
      end;
      // Creamos el segundo trozo
      AssignFile(Dest,Filename + '.002');
      {$I-}
        Rewrite(Dest,1);
      {$I+}
      if IOResult = 0 then
      try
        while not Eof(Source) do
        begin
          BlockRead(Source,Buffer^,1024 * 1024,Leidos);
          BlockWrite(Dest,Buffer^,Leidos,Escritos);
        end;
      finally
        CloseFile(Dest);
      end;
    finally
      FreeMem(Buffer);
    end;
  finally
    CloseFile(Source);
  end;
end;

// Por ejemplo
Partir('C:\Origen.txt');

[[egostar]]

Empezado por jorge_mosquera

Definitivamente a nadie se le ocurre como utilizar blockread y blockwrite para este cometido?

Empezado por seoane

No hubiera estado demás que mencionaras lo que habías intentado tu, así no hubiéramos perdido el tiempo. Incluso, tampoco hubiera sobrado un poco del código que utilizas.

De todas formas:

Pues ahi esta, seoane, que puedo decir, te las sabes de todas todas.

Me pregunto porque forzosamente con el Block Read/Write

Saludos.

[jorge_mosquera]

Muchas gracias amigos por darme una luz en la solucion del problema. Lamento no haberme expresado bien desde el principio y no comentarles todo lo que habia intentado previamente.

¿Porque BlockRead y BlockWrite ? Porque por lo que he visto, y leido, es super eficiente, y eso es lo que busco con mis programas.

Reciban un fuerte abrazo desde mi hermosa tierra colombiana.

Gracias