"Problem: You want to read in an old record from a binary file, change its values, and write back the record.
Solution: After reading the old record, pack up the updated values, seek to the previous address, and write it back."

And here is the accompanying style-challenged snippet, also directly from the Perl Cookbook:

use Fcntl;  # for SEEK_SET and SEEK_CUR
$ADDRESS = $RECSIZE * $RECNO;
seek(FH, $ADDRESS, SEEK_SET)  or die "Seeking: $!";
read(FH, $BUFFER, $RECSIZE) == $RECSIZE
                              or die "Reading: $!";
@FIELDS = unpack ($FORMAT, $BUFFER);
#update fields, then
$BUFFER = pack($FORMAT, @FIELDS);
seek(FH, -$RECSIZE, SEEK_CUR) or die "Seeking: $!";
print FH $BUFFER;
close FH                      or die "Closing: $!";
[download]

Even better answers can be found in the perldocs, perlfaq5 under the topics "How can I manipulate fixed-record-length files?" and "How do I randomly update a binary file?"

Check into those online resources first (rather than just grabbing the Perl Cookbook's snippet); they will give you the best description, and a good understanding of the topic.

Hope this helps...

Dave

"If I had my life to do over again, I'd be a plumber." -- Albert Einstein

Depends upon your definition of a "record". If your file contains fixed length records then is is fairly trivial to use perlfunc:seek and perlfunc:tell to position the file pointer to a specific record and overwrite the data in-place.

However, as most PC based filesystems do not have fixed-length record filetypes built-in as many mainframes do, fixed length records are fairly few and far between in the PC world. Most files therefore variable length "records", which means that you have to scan the file sequentially and remember the start position and length of each record as you go. It also means that you have to re-write every subsequent record unless your update is exactly the same length as the preceeding one.

However, the saving grace is that this has been done before, and being perl, that code is available to you on CPAN. Take a look at Tie::File. If your using a reasonably modern version of perl, this probably came with your distribution. It allows you to treat a file of fixed or variable length records as an array and takes care of all the file pointer shuffling and throws in some intelligent buffering to boot.

fixed length records are fairly few and far between in the PC world.

God I wish. :-(


---
demerphq



First they ignore you, then they laugh at you, then they fight you, then you win.
-- Gandhi

I meant fixed length in the mainframe sense of records addressable (directly and only) by record number.

Fixed length records on PC's are (for the most part) only variable length bits of a stream that all happen (even by design) to be the same length. There is nothing to stop you from positioning the pointer to mid record before reading or writing, and completely corrupting the record structure in the process.

What's the reason for you frowny? Assuming your fixed-length records are delimited with newlines, you can just as easily process them as you would variable length records with the added bonus of being able to index you way directly to a given record. Even if they are not delimited, setting $/ = \80; or whatever the fixed length is, allows you to read them just as easily.

I don't see the problem?

---

Examine what is said, not who speaks.
"Efficiency is intelligent laziness." -David Dunham
"When I'm working on a problem, I never think about beauty. I think only how to solve the problem. But when I have finished, if the solution is not beautiful, I know it is wrong." -Richard Buckminster Fuller
If I understand your problem, I can solve it! Of course, the same can be said for you.

Use seek to go to the place where you want, then print the data you want (which doesn't have to be line-formatted).

To read a record, again use seek then read it with read.

To find out where you are in a file, use tell.

If you want to avoid stdio's buffering, use sysopen, syswrite, sysseek, and sysread.

All of these functions are outlined in the perlfunc manpage, or by running perldoc -f funcname.

Perhaps off-topic, DBD::SQLite is a CPAN module which implements a relational-database-in-a-file. There's a brief discussion of it in www.perl.com.