File Processing and Exception Handling

// Program 1: save several car records to a sequential file
DECLARE ThisCar : CarRecord
DECLARE NumberOfCars, Count : INTEGER
OUTPUT "How many cars? "
INPUT NumberOfCars
OPENFILE "CarFile.DAT" FOR WRITE
FOR Count ← 1 TO NumberOfCars
    INPUT ThisCar.VehicleID
    INPUT ThisCar.Registration
    INPUT ThisCar.DateOfRegistration
    INPUT ThisCar.EngineSize
    INPUT ThisCar.PurchasePrice
    PUTRECORD "CarFile.DAT", ThisCar
NEXT Count
CLOSEFILE "CarFile.DAT"

// Program 2: read the file and display every record
OPENFILE "CarFile.DAT" FOR READ
WHILE NOT EOF("CarFile.DAT")
    GETRECORD "CarFile.DAT", ThisCar
    OUTPUT ThisCar.VehicleID, " ", ThisCar.Registration, " ",
           ThisCar.EngineSize, " ", ThisCar.PurchasePrice
ENDWHILE
CLOSEFILE "CarFile.DAT"

import pickle

class CarRecord:
    def __init__(self):
        self.VehicleID = ""
        self.Registration = ""
        self.DateOfRegistration = ""
        self.EngineSize = 0
        self.PurchasePrice = 0.00

# ---------- Program 1: save ----------
NumberOfCars = int(input("How many cars? "))
CarFile = open('CarFile.DAT', 'wb')
for Count in range(NumberOfCars):
    ThisCar = CarRecord()
    ThisCar.VehicleID = input("Vehicle ID: ")
    ThisCar.Registration = input("Registration: ")
    ThisCar.DateOfRegistration = input("Date of registration: ")
    ThisCar.EngineSize = int(input("Engine size (cc): "))
    ThisCar.PurchasePrice = float(input("Purchase price: "))
    pickle.dump(ThisCar, CarFile)       # one record after another
CarFile.close()

# ---------- Program 2: display (needs the same CarRecord class) ----------
CarFile = open('CarFile.DAT', 'rb')
while True:
    try:
        ThisCar = pickle.load(CarFile)
    except EOFError:                    # no more records
        break
    print(ThisCar.VehicleID, ThisCar.Registration,
          ThisCar.EngineSize, ThisCar.PurchasePrice)
CarFile.close()

The second program must define the same CarRecord class, because pickle stores the class name and rebuilds objects of that class. Strictly, this file is serial (records are in the order typed). To make it sequential, sort the records by VehicleID before writing them.

// Program 1: save several records to a random-access file
OPENFILE "CarFile.DAT" FOR RANDOM
FOR Count ← 1 TO 3
    INPUT ThisCar.VehicleID
    INPUT ThisCar.Registration
    INPUT ThisCar.DateOfRegistration
    INPUT ThisCar.EngineSize
    INPUT ThisCar.PurchasePrice
    Address ← Hash(ThisCar.VehicleID)
    SEEK "CarFile.DAT", Address
    PUTRECORD "CarFile.DAT", ThisCar
NEXT Count
CLOSEFILE "CarFile.DAT"

// Program 2: find one record using its key
OUTPUT "Vehicle ID to find: "
INPUT SearchID
OPENFILE "CarFile.DAT" FOR RANDOM
Address ← Hash(SearchID)
SEEK "CarFile.DAT", Address
GETRECORD "CarFile.DAT", ThisCar
IF ThisCar.VehicleID = SearchID
    THEN
        OUTPUT ThisCar.Registration, " ", ThisCar.EngineSize, " ", ThisCar.PurchasePrice
    ELSE
        OUTPUT "No record for ", SearchID
ENDIF
CLOSEFILE "CarFile.DAT"

Checking ThisCar.VehicleID = SearchID matters: the slot may be empty, or hold a different car whose key gave the same address. A full answer would then try the next slot, as in Exam question 1 b(iii). For a Python version, use the corrected struct code above inside a loop for the saving program.

import pickle

FileName = input("File to read: ")
try:
    CarFile = open(FileName, 'rb')
except FileNotFoundError:
    print("There is no file called", FileName)
else:                                  # only runs if open() worked
    Count = 0
    while True:
        try:
            ThisCar = pickle.load(CarFile)
        except EOFError:
            break                      # normal end of the file
        except pickle.UnpicklingError:
            print("That is not a file of car records")
            break
        Count = Count + 1
        print(ThisCar.VehicleID, ThisCar.Registration)
    CarFile.close()
    print(Count, "records read")

Test plan: a file that exists (normal data); a filename that does not exist (expect the "no file" message); an empty file (expect "0 records read"); a file that is not pickled records, e.g. a text file (expect the "not a file of car records" message). In the saving program, also catch ValueError when the engine size or price is typed as text.

TYPE CustomerRecord
    DECLARE CustomerID  : INTEGER    // key field: 100001 to 999999
    DECLARE Name        : STRING     // 30 characters
    DECLARE Telephone   : STRING     // 14 characters (a string: may start with 0 or +)
    DECLARE TotalOrders : REAL       // currency value of orders so far
ENDTYPE

DECLARE CustomerData : ARRAY[0:999] OF CustomerRecord

class CustomerRecord:
    def __init__(self):
        self.CustomerID = 0          # 0 means "empty slot"; real IDs are 100001-999999
        self.Name = ""               # up to 30 characters
        self.Telephone = ""          # up to 14 characters
        self.TotalOrders = 0.0       # currency

CustomerData = [CustomerRecord() for i in range(1000)]   # index 0 to 999

Marks for: the record header and end; each of the four fields with a sensible type; the telephone number as a string (it can start with 0 or +, and you never do arithmetic on it); the array with bounds 0 to 999 of the record type.

def Hash(CustomerID):
    Address = CustomerID % 1000
    return Address

def AddRecord(Customer):
    Index = Hash(Customer.CustomerID)
    Start = Index
    while CustomerData[Index].CustomerID != 0:     # slot already in use: collision
        Index = (Index + 1) % 1000                  # try the next slot, wrapping to 0
        if Index == Start:                          # gone all the way round
            print("Hash table is full")
            return
    CustomerData[Index] = Customer

def FindRecord(CustomerID):
    Index = Hash(CustomerID)
    Start = Index
    while CustomerData[Index].CustomerID != CustomerID:
        if CustomerData[Index].CustomerID == 0:     # empty slot: record was never added
            return -1
        Index = (Index + 1) % 1000
        if Index == Start:                          # searched every slot
            return -1
    return Index

The same FindRecord in pseudocode:

FUNCTION FindRecord(CustomerID : INTEGER) RETURNS INTEGER
    DECLARE Index, Start : INTEGER
    Index ← Hash(CustomerID)
    Start ← Index
    WHILE CustomerData[Index].CustomerID <> CustomerID
        IF CustomerData[Index].CustomerID = 0
            THEN
                RETURN -1                     // empty slot: not in the table
        ENDIF
        Index ← (Index + 1) MOD 1000
        IF Index = Start
            THEN
                RETURN -1                     // whole table searched
        ENDIF
    ENDWHILE
    RETURN Index
ENDFUNCTION

Marks for: calling Hash; testing whether the slot is empty; moving to the next slot on a collision; wrapping from 999 back to 0 (MOD 1000); stopping when the table is full; storing the record. For FindRecord: comparing the key in the slot; stopping at an empty slot or after a full loop; returning the index, or a rogue value such as −1 when the record is not found.

import pickle

CustomerFile = open('CustomerData.DAT', 'wb')      # binary file, write mode
for Index in range(1000):                          # every slot, empty ones too,
    pickle.dump(CustomerData[Index], CustomerFile) # so each record goes back to its slot
CustomerFile.close()

OPENFILE "CustomerData.DAT" FOR WRITE
FOR Index ← 0 TO 999
    PUTRECORD "CustomerData.DAT", CustomerData[Index]
NEXT Index
CLOSEFILE "CustomerData.DAT"

Write all 1000 slots, empty ones included, in index order. Then reading them back in order restores every record to the same slot, so FindRecord still works without re-hashing.

• The file must be created first, filled with 1000 empty (dummy) records so that every address exists.
• Every record must be fixed length (30-character name, 14-character phone) so each slot is the same size.
• Open the file FOR RANDOM instead of using the array.
• Hash still gives the slot; the byte address is slot × record size. Use SEEK to move there.
• AddRecord: GETRECORD to see if the slot is empty; if not, move to the next slot (wrap at the end of the file); then PUTRECORD the customer at that address.
• FindRecord: SEEK and GETRECORD from the file, comparing keys and probing as before.
• Part (c) is no longer needed: each record is already saved on disk the moment it is written.
• Close the file when finished, and add exception handling for file errors.

FileOpened = False
while not FileOpened:
    FileName = input("Which file do you want to use? ")
    try:
        DataFile = open(FileName, 'r+b')   # binary read/write, like FOR RANDOM
        FileOpened = True
    except IOError:                        # includes FileNotFoundError
        print("That file does not exist. Please try again.")

DECLARE FileOpened : BOOLEAN
FileOpened ← FALSE
REPEAT
    OUTPUT "Which file do you want to use? "
    INPUT FileName
    TRY
        OPENFILE FileName FOR RANDOM
        FileOpened ← TRUE
    EXCEPT
        OUTPUT "That file does not exist. Please try again."
    ENDTRY
UNTIL FileOpened = TRUE

Marks for: prompt and input; the open statement inside try; an except for the file error; a helpful message; a loop so the user can try again until the file opens.