Random Files

There are three ways a file can be organised. Understanding the difference is essential before the code makes sense.

First you describe the shape of one record using a user-defined TYPE. This is the blueprint — it does not store data yet, it just says what fields a record has and what type each field is.

TYPE Book
    DECLARE Title : STRING
    DECLARE Author : STRING
    DECLARE YearPublished : INTEGER
    DECLARE ISBN : STRING
    DECLARE CopiesAvailable : INTEGER
ENDTYPE

Then you use the five file commands:

Adding follows three steps: build the record in a variable, SEEK to where it should go, then PUTRECORD to write it. There is no read involved — you are writing fresh data in.

DECLARE NewBook : Book

// 1. Build the record in a variable
NewBook.Title <- "Pride and Prejudice"
NewBook.Author <- "Jane Austen"
NewBook.YearPublished <- 1813
NewBook.ISBN <- "9780141199078"
NewBook.CopiesAvailable <- 12

// 2. Open, SEEK to position, PUTRECORD
OPENFILE "LibraryDatabase.dat" FOR RANDOM
SEEK "LibraryDatabase.dat", 5
PUTRECORD "LibraryDatabase.dat", NewBook
CLOSEFILE "LibraryDatabase.dat"

The update cycle: read the slot, change a field in the variable, then write the variable back to the same slot.

DECLARE ExistingBook : Book
OPENFILE "LibraryDatabase.dat" FOR RANDOM

// read the record at position 5
SEEK "LibraryDatabase.dat", 5
GETRECORD "LibraryDatabase.dat", ExistingBook

// change one field
ExistingBook.CopiesAvailable <- 20

// write it back to the SAME slot
SEEK "LibraryDatabase.dat", 5
PUTRECORD "LibraryDatabase.dat", ExistingBook
CLOSEFILE "LibraryDatabase.dat"

To insert a record in the middle of a file, you must first shift all records after that position one slot forward. Start from the last record and work backward to avoid overwriting records you have not moved yet.

DECLARE Pupil : Student
DECLARE Position : INTEGER
OPENFILE "StudentFile.dat" FOR RANDOM

// move records from 20 down to 10, backward, into the next slot
FOR Position <- 20 TO 10 STEP -1
    SEEK "StudentFile.dat", Position
    GETRECORD "StudentFile.dat", Pupil
    SEEK "StudentFile.dat", Position + 1
    PUTRECORD "StudentFile.dat", Pupil
NEXT Position
CLOSEFILE "StudentFile.dat"

To search for a record by name (or any field), loop through positions with SEEK + GETRECORD, compare each record's field, and stop when found. Use a Boolean flag.

DECLARE Customer : Member
DECLARE Position : INTEGER
DECLARE Found : BOOLEAN
DECLARE SearchName : STRING

OUTPUT "Enter the member's name"
INPUT SearchName
Found <- FALSE
Position <- 0
OPENFILE "Members.dat" FOR RANDOM

WHILE Found = FALSE AND Position < 1000 DO
    SEEK "Members.dat", Position
    GETRECORD "Members.dat", Customer
    IF Customer.Name = SearchName THEN
        Found <- TRUE
    ELSE
        Position <- Position + 1
    ENDIF
ENDWHILE
CLOSEFILE "Members.dat"

IF Found THEN
    OUTPUT "Found at position", Position
ELSE
    OUTPUT "Not found"
ENDIF

Python does not have Cambridge pseudocode's PUTRECORD / GETRECORD. Instead, the pickle module lets you serialise any Python object (class instance, dictionary, list) to a binary file and read it back.

import pickle

class Book:
    def __init__(self, title, author, year, isbn, copies):
        self.title = title
        self.author = author
        self.year = year
        self.isbn = isbn
        self.copies = copies

    def __str__(self):
        return f"{self.title} by {self.author} ({self.copies} copies)"

book = Book("To Kill a Mockingbird", "Harper Lee", 1960,
            "9780060935467", 5)

# Write (like PUTRECORD)
with open("book.dat", "wb") as f:
    pickle.dump(book, f)

# Read back (like GETRECORD)
with open("book.dat", "rb") as f:
    loaded = pickle.load(f)

print(loaded)  # To Kill a Mockingbird by Harper Lee (5 copies)

To replicate Cambridge pseudocode's SEEK + fixed record size in Python, use file.seek(position * RECORD_SIZE) to jump to a record, then pickle.dump() / pickle.load() to read or write.

import pickle

RECORD_SIZE = 128  # every record reserves a fixed block

def put_record(filename, position, record):
    with open(filename, "r+b") as f:
        f.seek(position * RECORD_SIZE)  # like SEEK
        pickle.dump(record, f)           # like PUTRECORD

def get_record(filename, position):
    with open(filename, "rb") as f:
        f.seek(position * RECORD_SIZE)  # like SEEK
        return pickle.load(f)           # like GETRECORD

A driving school stores lesson records in a random file Lessons.dat. Each record is of type TLesson:

TYPE TLesson
    DECLARE LessonID : INTEGER
    DECLARE StudentName : STRING
    DECLARE Instructor : STRING
    DECLARE Booked : BOOLEAN
ENDTYPE

Fifteen exam-style random file tasks. Each shows only the question — click Hint for the thought process, or Help for the worked solution.