NOS : Certificate in Computer Applications
| Home | Table of Contents |

Up: Online Course Material

We have so far discussed programs where data is supplied either through READ...DATA statements or through INPUT statements. But it is difficult to handle large volume of data with the help of these statements. Moreover, data stored in one program cannot be shared by other programs. The above limitations can be overcome by placing the data into a separate storage area called a data file.

A date file forms an essential framework of a data processing system. It is a collection of data organised in a specific format and for a specific purpose, which is kept somewhere in external memory. A file can be described as a collection of records where a record consists of number of data values, which are either produced by a computer as per the instructions of a program or given to the computer as a data. A typical data processing system many consist of many files. Many records in a file contain detailed information about some aspect of the system. For example, a "pay file" may contain one record for each employee containing all the particulars such as Employee Code, Name, Address, Basic pay, HRA, DA, CCA, Designation, Sex, etc. Each partition is a data item and is referred to as a field. A number of BASIC Programs can use this file as input.

File handling methods differ widely from system to system. In this lesson, we will discuss the methods that are currently used in most of the IBM compatible systems.

On completion of this lesson, you should be able to:

• understand various types of files
• know how to handle sequential files
• know how to handle random access files
• discuss various examples/ programs relating to these two type of files.

Depending on the way in which the data is stored and accessed, files are categorised as:

• Sequential access files
• Direct (Random) access files

These files may be created on a magnetic tape or disk. Data from these files is read sequentially, item after item, starting at the beginning. Though sequential access file is easy to handle, yet it has a serious disadvantage. In the sequential file we cannot change the existing entry or insert a new entry. To do this, we should copy the entire content to another file making the changes on the way and then copy the correct data back in to the original file. Another disadvantage is that we cannot simply locate or go back to read a particular data item.

Fig. 28.1 and 28.2 show how data is stored on magnetic tapes and disk respectively. A disk consists of a number of concentric circles known as tracks. The data items are stored on these tracks sequentially.

ADD PIC

Consider an inventory file shown in Table 28.1

Table 28.1 Inventory file

ADD PIC

Details of each part are stored in one record. When we complete all the parts, the data file would look like a long column of values as shown below:

AAAA

101

8.00

100

BBBB

102

10.00

200

CCCC

103

12.00

300

Programs are written to read these data values one after another.

Random Access Files

Random access files are created on disks to allow us to read or write from the files in random order. Random access files allow more flexible access than the sequential files. You can read or write any record directly in a random file without searching through all the records that precede it. Thus, reading and writing of data is faster.

Using data files would require the incorporation of statements in your program to perform the following functions:

• Giving a name to the file
• Opening the file
• Writing to or reading from the file
• Closing the file

A file is identified by its file specifications. It is of the form:

Device name: File name

The device name tells the system which device to look for the file and the file name tells which file to look for on that device. The device name should be followed by a colon as indicated. Examples are:

A: MEAN

B: STUDENT. MKS

The device names A and B indicate the disk drive one and two respectively

File names can have a maximum of eight characters. However, the files stored on disks may have a file name extension in the following form.

NAME.EXT

The extension consists of a period and followed by three letters. When you use longer file name, one of the following conditions may occur.

For example,

SURENDERKUMAR becomes SURENDER.KUM.

PROGRAM.PENSION becomes PROGRAM.PEN.

PAYROLLCALUCTION.BAS gives an error.

It is necessary to establish a line of communication between a program and a file that is to be used before data can be read from or written to that file. This is achieved by using the OPEN command as shown below:

OPEN ["Mode", #file number, "file name"]

Mode is a string constant and takes one of the following three forms

• O for sequential output file
• I for sequential input file
• R for random input/output file

It should be noted that the mode is enclosed in quotation marks.

File number is an integer number and can be any number between 1 and 15. It is a unique number associated with the actual physical file. A file number may be a number, variable, or expression.

File name specifies the particular file to be used. This should conform to the specifications of the file when it was created. File names must be enclosed in quotations.

Examples of opening sequential files for input and output operations are:

10 OPEN "I" # 1, " PANKAJ.DTA"

20 OPEN "O", # 3, "TEMP"

These can also be written as

10 OPEN" PANKAJ.DTA" FOR INPUT AS# 1

20 OPEN" TEMP" FOR OUTPUT AS #3

If a file opened for input operation does not exist, a "FILE NOT FOUND" error will be shown on the screen. If a file, which does not exist, is opened, in that case file will be created. It is important to note that opening a file for output destroys the existing data in that file.

A previously opened file can be closed using the CLOSE statement as follows

CLOSE [# file number, #file number, ......]

The file number is the number used in the OPEN statement. For example, the statement.

100 CLOSE #1, # 3

causes the files with file numbers 1 and 3 to be closed. The CLOSE statement is used when you have finished processing data from a file.

A CLOSE statement with no file numbers specified causes all files that have been opened to be closed.

You should also note that execution of END and RUN statements also causes all open sequential files to be automatically closed. However, STOP does not close any files.

We may write data to a sequential file using either of the following two statements.

PRINT [# file number, list of variables]

WRITE [ #file number, list of variables ]

File number refers to the file designator used when the file was opened for output. List of variables specifies the data that is to be written to the file.

The difference between PRINT # and WRITE # Statements is that WRITE # inserts commas between the data items and quotation marks for strings while PRINT # causes data to be written without any delimiters (commas, etc.). For example consider the statement

40 PRINT #1 N $, AMT

In case N $ = " PANKAJ" and AMT = 2000, the

statement would write the following image to the file 1:

PANKAJ 2000

The statement

40 WRITE # 1, N $, AMT

would write the following image to the file 1:

"PANKAJ", 2000

The delimiters are useful when we try to read the data with an INPUT # statement.

Let us take an example for proper understanding the use of "WRITE" and "PRINT" statement.

10 REM *** PROGRAM INVENTI ***

20 REM -- PNM$ PART NAME

30 REM -- PN PART NUMBER

40 REM -- P PRICE

50 REM -- QTY QUANTITY

60 OPEN "O", # 1, "INVENT. DTA"

70 FOR I =1 TO 3

80 INPUT "NAME" ; PNM$

90 INPUT "NUMBER" PN

100 INPUT "PRICE" P

110 INPUT "QUANTITY" ; QTY

120 WRITE # 1, PNM$, PN, P, QTY

130 PRINT

140 NEXT I

150 CLOSE #1

160 END

NAME? AAAA

NUMBER? 101

PRICE? 8

QUANTITY? 100

NAME? BBBB

NUMBER? 102

PRICE? 10

QUANTITY? 200

NAME? CCCC

NUMBER? 103

PRICE? 12

QUANTITY? 300

Data can be read from a sequential file using the INPUT # statement. It takes the form

INPUT [ # file number, list of variables ]

The following INPUT # statement can be used to read data from the file INVENT. DTA:

200 INPUT #1, PNM$, PN, P, QTY

The type of data in the file must match the type specified in the list. Unlike INPUT, no question mark is displayed with INPUT #

The following example will illustrate clearly the use of INPUT # statement.

Write a program to read inventory data stored in the file INVENT. DTA inventory and print the table with the value of each product.

10 REM ** PROGRAM INVENT 2 **

20 OPEN I",#1, "INVENT. DTA"

25 PRINT "PART", "PART", " PRICE", "QUANTITY", " VALUE "

30 PRINT "NAME","NUMBER"

40 PRINT

50 INPUT #1 PNM$, PN, P, QTY

60 LET V= P* QTY

70 PRINT PNM$, PN, P, QTY, V

80 GOTO 50

90 CLOSE

100 END

Input past end in 50

The program in Example 2 reads sequentially, every item in the file. When all the data have been read, line 50 causes an "Input past end" error. This can be avoided by using the EOF function. This function tests for end of file and the control is directed appropriately. The end of the file is indicated by a special character in the file.

The program INVENT2 is modified as follows:

10 REM ** PROGRAM INVENT 2**

20 OPEN "I", #1 "INVENT. DTA"

25 PRINT "PART", "PART","PRICE, "QUANTITY" "VALUE"

30 PRINT "NAME", "NUMBER"

40 PRINT

50 IF EOF (1) THEN 100

60 INPUT #1, PNM$, PN, P, QTY

70 LET V = P*QTY

80 PRINT PNM$, PN, P, QTY, V

90 GOTO 50

100 CLOSE

110 END

The LINE INPUT # statement may be used to read an entire line, ignoring delimiters, from a sequential file and assign to a string variable. It is of the form

LINE INPUT [ #file number, string variable ]

File number is the number under which the file was opened and string variable is used to store a line of string constant.

LINE INPUT # reads all characters in the sequential file up to a carriage return which was inserted by the PRINT # statement. The next LINE INPUT # reads all characters up to the next carriage return. Example 3 illustrates the use of LINE INPUT #statement.

Write a program to input employee addresses from the keyboard, store them in a file named ADDRESS, and read back to produce a list.

10 REM ** PROGRAM EMPLOYEE **

20 REM ** INPUT EMPLOYEE ADDRESS THROUGH KEYBOARD **

30 OPEN "O ", #1 "ADDRESS"

40 FOR I = 1TO 3

50 LINE INPUT "TYPE IN ADDRESS" ADDR$

60 PRINT # 1 ADDR$

70 NEXT I

80 CLOSE 1

85 PRINT

90 OPEN : "I" # 1, "ADDRRESS"

100 FOR I= 1 TO 3

110 LINE INPUT # 1, ADDR$

120 PRINT ADDR$

130 NEXT I

140 CLOSE 1

150 END

TYPE IN ADDRESSES? PANKAJ KUMAR GOEL, PITAMPURA, DELHI -34

TYPE IN ADDRESSES? RAJESH KUMAR, AUDIT OFFICE, GWALIOR

TYPE IN ADDRESSES? DR. SANJU, MEDICAL COLLEGE, JODHPUR

PANKAJ KUMAR GOEL, PITAMPURA, DELHI-34

RAJESH KUMAR, AUDIT OFFICE, GWALIOR

DR. SANJU, MEDICAL COLLEGE, JODHPUR

To add any data to a sequential file that is already residing on a disk, you cannot just open the file and write data to it. You must note that when a sequential file is opened for output, its current contents are lost. In such cases, you should open the file with APPEND. For example, the statements

10 FILE = " A: TEMP"

20 OPEN FILE FOR APPEND AS #1

will open the file named TEMP on the disk in drive A and position the file pointers at the existing data. Now we can add records to the file, which has been numbered as 1.

Following example will illustrate the use a of Append

Write a program to add two more products to the file "INVENT. DTA" created earlier in Example 1.

DDDD       104   20.0   200

EEEE         105   30.0    300

10 FILES = "INVENT. DTA"

20 OPEN FILES FOR APPEND AS #1

30 FOR I=1 TO 2

40 INPUT PNM$, PN, P, QTY

50 WRITE #1, PNM$, PN, P, QTY

60 NEXT I

70 CLOSE # 1

80 REM ** DATA INPUT FROM FILES **

90 OPEN "I", #1, "INVENT. DTA

100 PRINT

110 IF EOF (1) THEN 160

120 INPUT #1, PNM$, PN, P, QTY

130 PRINT PNM$, PN, P, QTY

140 GOTO 110

150 CLOSE # 1

160 END

? DDDD, 104, 20, 200

? EEEE, 105, 30, 300

AAAA 101 8 100

BBBB 102 10 200

CCCC 103 12 300

DDDD 104 20 200

EEEE 105 30 300

Unlike sequential files, random files cannot be created so easily. Random files require more programming steps and skills. However, since random access files effectively retrieve or write individual data items anywhere in the file they are often preferred.

Following are the steps required to create a random file:

• Open the file
• Allocate space in the random buffer for variables that will be written to the file
• Move the data into the random buffer
• Write the data from the buffer to the disk

Step1: Like sequential files, we may open random files using the OPEN Statement

OPEN ["R", #File number,"File name",Record length]

The character R indicates that the file to be opened is a random access file. Record length is a number that specifies the length of records. The length may range from 1 to 32767, The default record length is 128 bytes. For examples,

100 OPEN "R", #2, "PANKAJ',100

200 OPEN "R",#3, "CHAP5",120

These statements can also be written as

100 OPEN "PANKAJ" AS#2LEN =100

200 OPEN "CHAPS," AS #3 LEN = 120

Step2: Space in the random buffer is allocated by the FIELD statement in the form

FIELD [#file number, w₁ AS u_1, w₂ AS u₂...]

File number is the number of the concerned file just opened, w₁ specifies the number of character positions to be allocated to the string variable and so on.

A FIELD statement defines variables that are used to put data into or get data out of a random buffer. For example, the statement

50 FIELD #2, 20 AS A$ 10 AS B$

defines two string variables A$ and B$ and allocates first 20 bytes to the variable A$ and next bytes to B$. Note that FIELD is a declaration statement and does not actually place data into the random buffer.

Unlike sequential files, random files cannot be created so easily. Random files require more programming steps and skills. However, since random access files effectively retrieve or write individual data items anywhere in the life, they are often preferred.

The total number of bytes allocated in a FIELD statement must not exceed the record length specified in the OPEN statement. For instance, the statements

10 OPEN "R",#2 "CHAP1",40

20 FIELD #2,20 AS A$, 5 AS B$, 10 AS C$, 10 AS D$

open a file named CHAP1 as a random file and allocates character positions as follows:

First 20 bytes to A$

Next 5 bytes to B$

Next 10 bytes to C$

Next 10 bytes to D$

Note that the total number of bytes allocated is 45, which is more than 40, the record length as defined in the OPEN statement in line 10. In this case, a "Field overflow" error will appear on the screen.

Step 3: Placing data into the random file buffer is done by the LSET and RSET statements. They take the form:

LSET u$ = x $

RSET u$ = x $

Where u$ is the name of a string variable that is defined in a FIELD statement and x$ is a string variable representing the data to be placed into the field identified by u$ Examples of these statements are:

30 LSET A$ = F1$

40 RSET B$ = F2$

LSET statement left-justifies the string in the field, and RSET statement right justifies the string. Let us suppose F1$ represents CONNECTING-PROD and F2$ represents 5000. If the character positions allocated to A$ is 18 andB$ is 5, then the field represented by A$ and B$ in the random buffer are filled like this:

| ------------------------A$----------------------------------------| --------------- |

Since all the fields in a random buffer are defined as string fields, any number value that is to be placed in a random file buffer must be converted to string value before it is LSET or RSET. This can be done using the following `convert' functions.

MKI$ converts an integer to a 2-byte string.

MKS$ converts a single-precision number to a 4-byte string.

MKD$ converts a double-precision number to an 8-byte string.

LSET A$ MKI$ ( integer variable)

or

RSET A$ MKD$ (double-precision variable)

Where A$ is the string variable defined in the FIELD statement.

For example

LSET A$ - MKI$(RN)

RSET B$- MKS$ (PAY)

Step 4: Moving of data from a random buffer to a random file is done by the PUT statement.

Each time a PUT statement is executed, a record is written to the file.

PUT {# file number, record number]

File number refers to the number under which the file was opened. Record number is the number of the record to be written and expressed as an integer constant or variable. If record number is omitted, the record will have the next available number. For example, the statement

100 PUT #2, 1

will write the information contained in the buffer to the first record of the random file numbered 2. It can also be written as

100 PUT #2,K

where K is an integer variable. The value of K must be defined before using the PUT statement.

Each time a PUT statement is executed, a record is written to the file.

Let us take an example to clarify various statements discussed for creating a random file.

Write a program to open a random and record salary file statement of employees with the following details:

1 Name

2 Basic Pay

3 D.A.

4 H.R.A.

5 C.C.A.

Assume the following data:

10 REM ** CREATION OF RANDOM FILE **

20 OPEN " R",#1,"SALARY" 60

30 FIELD #1,20 AS N$, 10 AS B$ 10 AS D$, 10 AS H$, 10 AS C$

40 INPUT "RECORD NUMBER"; I

50 IF I=0 THEN 150

60 INPUT "NAME "; A$

70 INPUT "BASIC PAY"; P

80 INPUT " DEARNESS ALLOWANCE"; Q

82 INPUT "HOUSE RENT ALLOWANCE"; R

85 INPUT " COMPENSATORY CITY ALLOWANCE"; S

100 LSET N$ = A$

110 LSET B$ = MKS$ (P)

120 LSET D$ = MKS$ (Q)

122 LSET H$= MKS$ (R)

125 LSET C$ = MKS$ (S)

130 PUT # 1, I

140 GOTO 40

150 CLOSE # 1

160 END

Record Number? 1

Name? UPMA

Basic pay? 25000

Dearness Allowance? 5000

House Rent Allowance? 8000

Compensatory city Allowance ? 2000

Record Number? 10

Name? SANJU

Basic pay? 20000

DA? 4000

HRA 7000

CCA? 1500

RECORD NUMBER? 40

Name? Anamika

Basic Day? 15000

DA? 3000

HRA? 6000

CCA? 1000

Record Number 0

Like creation, accessing a random file includes the following points:

• Open the file for random access
• Allocate space in the random buffer for variable using the FIELD statement that will be read from the file.(Remember that if a program performs both the input and output on the same random file, you may use only one OPEN statement and one FIELD statement)
• Bringing data from the file to the buffer for processing
• Access and use data in the program

Step 1: Follow the procedure of step 1 in creating a file. (see Section 5.4.1)

Step 2: Follow the procedure of step 2 in creating a file. (see section 5.4.1)

Step 3: Bringing data from the file to the buffer is done by the GET statement. This is similar to the PUT statement.

GET [#file number, record, number]

Record number is optional and, if it is omitted, the next record (after the last GET ) is read into the buffer. For example,

200 GET #2, 10

will transfer the content of the record number 10 from the file number 2 to the buffer.

Step 4: After a GET statement, the data available in the buffer can be used by the program for further manipulation and printing outputs. Remember that the numeric values are recorded as string values in the buffer and therefore all numeric values must be converted back to numbers for performing any arithmetic operations on them: This is done using following "convert" functions:

CVI converts a two-byte string to an integer.

CVS converts a 4-byte string to a single-precision number.

CVD converrts an 8-byte string to a double-precision number.

These functions are written in the form:

x = CVI (u$)

x = CVS (u$)

x = CVD (u$)

u$ is the name of a string variable containing numeric values in the buffer and x is a numeric variable representing the data to be used in the program.

The following program segment illustrates the use of GET and convert functions:

40 FIELD #2, 10 AS A$, 6 AS B$, 3 AS C$

50 GET #2

55 LET N$ = A$

60 LET M1 = CVS (B$)

70 LET R1 = CVI (C$)

80 PRINT N$, M1, R1

This program uses a random file numbered 2, which has fields as defined in line 40. Line 50 reads a record from the file. Line 60 converts the contents of to a single-precision numeric value and assigns it to the variable MI. Similarly, line 70 converts the contents of to an integer number and assigns the value to the variable R1. Line 80 writes the vales of N, MI and R1 on the screen.

In this case, N$, M1 and R1 may represent student names, marks and class rank. Note the conversion functions do not change the actual data. They only change the way the data is interpreted.

Remember that B$ and C$ were originally numbers which would have been written to the file using the MKS$ and MKI$ functions. Example 6 will help us in understanding the technique of accessing data stored in random life.

Write a program to access the random file "SALARY" that was created in example 5.

You are required to print the data contained in any desired record along with the total salary.

10 REM ** ACCESSING A RANDOM FILE **

20 OPEN "R" # 1, " SALARY", 60

30 FIELD # 1, 20 AS N$, 10 AS B$, 10 AS D$, 10 AS H$, 10 AS C$

40 INPUT "RECORD NUMBER' K

50 IF K=0 THEN 130

60 GET # 1, K

70 LET P = CVS (B$)

75 LET Q =CVS (D$ )

80 LET R =CVS (H$)

85 LET S = CVS (C$)

90 LET T = P+Q+R+S

100 PRINT "Record" K, N$, .P, .Q, .R, .S, .T

110 PRINT

120 GOTO 40

130 CLOSE

140 END

RECORD NUMBER? 40

RECORD 40 ANAMIKA 15000 3000 6000 1000 25000

RECORD NUMBER? 1

RECORD 1 UPMA 25000 5000 8000 2000 40000

RECORD NUMBER? 10

RECORD 10 SANJU 20000 4000 7000 1500 32500

RECORD NUMBER? 0

Top

IN-TEXT QUESTIONS 1

1. Determine whether the following statement to true or false

(a) A file can store a program's output for future use

(b) A file cannot be used by more than one program.

(c) When a file is opened for INPUT, data can be written from the program to the file.

(d) If a sequential file is created and then read in the same program, it must be closed and reopened between these operations.

2. Correct the syntax errors in each statement.

(a) 10 OPEN "FILE 1" AS # 2 FOR OUTPUT

(b) 20 WRITE # 2 A, B, C, D,

(c) 30 KILL FILE 2

3 Following program segment is supposed to create and display (on the screen) in file containing the integers from 1 to 100, but it does not run properly. Correct the errors.

10 OPEN "FILE1" FOR INPUT AS # 1

20 FOR I = 1 TO 100

30 PRINT # 1, I

40 NEXT I

50 FOR I= 1 TO 100

60 INPUT # 1, I

70 PRINT # 2, I

80 NEXT I

90 CLOSE # 1

100 END

4. Write a program in BASIC to create a file called "STUDENT' containing the following data:

(a) Name of the student

(b) Roll Number

(c) Marks in LOTUS

(d) Marks in dBASE

(e) Marks in BASIC

5. Write a program to retrieve data from the "STUDENT' file created in question 4 above and copy the same in a file named "STUDENT"1.

In this lesson, we have discussed about processing of both sequential and random files. Although, now-a-days advance programming languages are used to process files, file handling through BASIC is quite simple and useful. Even today, BASIC files are quite popular in business data processing. It is hoped that the fundamentals and the examples presents in this lesson will be helpful in understanding the various steps involved in file processing and also to develop your own programs.

IN-TEXT QUESTIONS 1

1.

(a) True

(b) False

(c) False

(d) True

2

(a) 10 OPEN "FILE1" FOR OUTPUT AS # 2

(b) 20 WRITE # 2, A, B, C, D

(c) 30 KILL "FILE 2"

3.

CHANGE:

10 OPEN "FILE1" FOR OUTPUT AS # 1

70 PRINT I

INSERT:

45 CLOSE # 1

47 OPEN "FILE1" FOR INPUT AS # 1

4.

10 REM PROGRAM TO CREATE " STUDEN" FILE

20 OPEN "STUDENT" FOR OUTPUT AS # 1

30 PRINT "NAME, ROLLNO, LOTUS-MARKS, DBASE-MARKS, BASIC- MARKS"

40 PRINT "Type AAA, 0,0,0,0 TO MAKE AN END"

50 INPUT N$, R, L, D, B

60 IF N = "AAA" THEN 90

70 WRITE # 1, N$, R, L, D, B

80 GO TO 50

90 CLOSE # A

100 END

5.

10 REM PROGRAM TO COPY "STUDENT" FILE

20 OPEN "STUDENT" FOR INPUT AS # 1

30 OPEN "STUDENT1 FOR OUTPUT AS # 2

40 IF EOF (1) THEN 80

50 INPUT # 1, N$, R, L, D, B

60 WRITE # 2, N$, R, L, D, B

70 GO TO 40

80 CLOSE # 1

90 CLOSE # 2

100 END

Top

28.8 TERMINAL QUESTIONS

1. Find the syntax errors in the following statements:

10 OPEN "FILES" AS #5 FOR OUTPUT

20 PRINT #6 A; ","; B$; ";"; PAY

30 INPUT #2, A: B: C

40 OPEN #2 LEN = 128

50 FIELD #1, A$ AS 10

2. The following program segment is supposed to create and display a file of numbers. Correct the errors in it.

10 OPEN "NUMFL" FOR INPUT AS #1

20 FOR I = 1 TO 10

30 READ N

40 PRINT #3, N

50 NEXT K

60 FOR K = 1 TO 10

70 WRITE #1, N

80 PRINT N

90 NEXT I

100 CLOSE #1

110 DATA 5, 7, 9, 10, 12, 15, 17, 19, 20, 22

120 END

3. Suppose that a file named COMPUTE.DTA exists with 20 records of the form:

Correct the following program so that it displays the fifth record in this file on the screen:

10 OPEN "COMPUTER.DTA" A$ #1 LEN = 24

20 FIELD #1, 4 AS COST $, 20 AS NM$

30 GET #2, 5

40 LET NM$ = N$

50 LET COST$ = COST

60 PRINT #1, NM$, COST

4. Write a program segment that performs the following operations:

(a) Display the number of record of records in EMPLOYEE.DAT.

(b) Delete the fourth record from the file.

(c) Change the pay in the sixth record from Rs. 1500 to Rs. 2500.

5. Assume that a file PAYROLL exists with records with form Employee number (NUM), Name (NM$), Rate of pay (RATE), and a sentinel record of 0, "AAA", 0. Write a program segment that

(a) Renames this file as PAY.

(b) Deletes a record with employee number 50.

(c) Adds the records 135, "SANJU", 12

(d) Change the rate of pay of employee number 140 from 15 to 20.

Top