The syntax of the FIXFORM statement is

FIXFORM [ON ddname] fld-1/form-1 ... fld-n/form-n

or

FIXFORM FROM master [ALIAS]

where:

fld-1 ...

Are the names of the incoming data fields that the FIXFORM statement is reading or redefining. If the name has an embedded blank, enclose it within single quotation marks.

Any field being read by the FIXFORM statement that does not appear in the Master File of the data source being modified must be predefined in a COMPUTE field/format=; statement. This COMPUTE must appear in the MODIFY before the FIXFORM.

The list of fields must fit on one line. If the list is too long to fit on one line, use a FIXFORM statement for each line. For example:

FIXFORM EMP_ID/9 LAST_NAME/15
FIXFORM CURR_SAL/8 ED_HRS/4

The two FIXFORM statements act as one statement and read one record into the buffer.

form-1 ...

Are the formats of the incoming data fields, as described in How to Specify Field Formats With FIXFORM. The formats specify the format type (alphanumeric, integer, floating point, and so on) and the length of the field in bytes.

Note: No length is specified for the text field format that is variable in length. A FIXFORM statement can describe up to 12,288 bytes, exclusive of repeating values.

To specify an alphanumeric format, type the length of the field in bytes. For example, a record contains two alphanumeric fields:

The EMP_ID field, nine bytes long.

The DEPARTMENT field, ten bytes long.

The FIXFORM statement that describes this record is:

FIXFORM EMP_ID/9 DEPARTMENT/10

Note that alphanumeric transaction fields can modify any data source field regardless of internal format. Specifying the formats of binary, packed, and zoned transaction fields is discussed in How to Specify Field Formats With FIXFORM.

Remember that a transaction field can contain numbers and still be alphanumeric. If you display a transaction data source on a system editor, alphanumeric data appears normally; numeric data appears as unprintable hexadecimal characters.

ON ddname

Is an option that specifies the ddname of the transaction data source containing the incoming data. You use this option most often when the request is reading data from two different sources: one source is specified by the DATA statement, the other by the ON ddname option.

Note that if there is more than one FIXFORM statement without the ON ddname option, the request keeps track of the last column of the physical record read by the last FIXFORM statement. If the last column is in the middle of the record, the next FIXFORM statement begins to read from the next column. If the last column is at the end of the record, the next FIXFORM statement begins to read from column 1 of the next record.

To break a FIXFORM statement having the ON ddname option into smaller statements, specify the ON ddname option only in the first statement. All the statements must be together in one block. For example:

FIXFORM ON EMPFILE EMP_ID/9 LAST_NAME/15
FIXFORM FIRST_NAME/10 DEPARTMENT/10
FIXFORM CURR_SAL/8 ED_HRS/4

FROM master

Indicates that the incoming data fields have the same names and formats as the Master File (named master). If you use this option, do not specify the field names and formats in the FIXFORM statement itself. Use this option only if the Master File specifies a single segment SUFFIX=FIX data source. All the fields in the Master File specified by the FROM phrase must also appear in the Master File specified by the MODIFY command, or an error will result.

You use this option most often to load data from a HOLD file. For example:

TABLE FILE EMPLOYEE
PRINT CURR_SAL BY EMP_ID
ON TABLE HOLD
END
MODIFY FILE SALARY
FIXFORM FROM HOLD
DATA ON HOLD
END

The TABLE request stores employee IDs and salaries in a HOLD file. The MODIFY request loads the IDs and salaries into a new FOCUS data source called SALARY. Note that all the fields in the HOLD Master File must also appear in the SALARY Master File.

Text fields are supported with FIXFORM from HOLD; only one text field can be read from a HOLD file and it must be the last field on the HOLD FIXFORM. The representation of missing text depends on whether MISSING=ON in the Master File or the FIXFORM format is C for conditional, or a combination of the two.

When duplicate field names exist in a HOLD file, a MODIFY request that includes FIXFORM FROM HOLD should specify an AS name.

Note: FIXFORM FROM Master File automatically assumes that all fields on the FIXFORM are conditional fields. Because of this a value of blank does not update the database to a value of blank. If blank (or spaces) is a valid value, and the update should take place, you must issue an ACTIVATE RETAIN fieldname fieldname fieldname... or ACTIVATE RETAIN SEG.fieldname.

ALIAS

Indicates that the alias names from the Master File are to be used to build the FIXFORM statements.

Often, an incoming transaction contains filler or data you do not need. To skip over characters or information in the incoming record, type

Xn

where:

n

Is the number of columns you want to skip.

This does not cause the statement to ignore the skipped columns. The statement reads the entire record; it just does not place the skipped data in any transaction field. Later in the request, you can place this data into transaction fields by adding a second FIXFORM statement (see the following section, How to Move Backward Through a Record).

For example, a transaction record consists of two fields: EMP_ID and CURR_SAL. Two "A"s separate the fields:

071382660AA23540.35

You describe this record with this FIXFORM statement:

FIXFORM EMP_ID/9 X2 CURR_SAL/8

The X2 notation prevents the two "A"s from being placed in the transaction fields.

Note: Do not begin any field used in a CRTFORM or FIXFORM statement with Xn, where n is any numeric value. This applies to fields in the Master File and computed fields.

After a FIXFORM statement reads a record into the buffer, it places the data into transaction fields, starting from the beginning of the record and moving toward the end. You can specify that FIXFORM back up a number of columns to process the data more than once. This enables you to place the same data into two fields simultaneously. To do this, use the notation

X-n

where n is the number of columns that the statement is to move backward. For example, the first three digits of employee IDs are a special code that you wish to use later in the request. Each employee ID is nine digits long. You type this FIXFORM statement:

FIXFORM EMP_ID/9 X-9 EMP_CODE/3 X6 CURR_SAL/8

A record in the transaction data source is:

07138266023500.35

The statement interprets the record this way:

EMP_ID/9

X-9

EMP_CODE/3

X6

CURR_SAL/8

Note: Since the EMP_CODE field is not defined in the Master File, you must define the field with the COMPUTE statement before the FIXFORM statement (see Computing Values: The COMPUTE Statement).

You may replace any FIXFORM statement with two smaller statements so that the second statement redefines all or part of the record read by the first statement. For example, you may replace this FIXFORM statement

FIXFORM EMP_ID/9 X-9 EMP_CODE/3 X6 CURR_SAL/8

with these two smaller FIXFORM statements:

FIXFORM EMP_ID/9 CURR_SAL/8
FIXFORM X-17 EMP_CODE/3 X14

The first FIXFORM statement reads one record and divides the record into the EMP_ID field (nine bytes) and the CURR_SAL field (eight bytes).

The second FIXFORM statement moves 17 bytes back to the beginning of the record and declares the first three bytes to be the EMP_CODE field. It then skips over the last 14 bytes.

Note that you cannot place the X-n notation at the end of a FIXFORM statement. The following statement is an error:

FIXFORM EMP_ID/9 CURR_SAL/8 X-17

FIXFORM statements that redefine records in the buffer are especially useful in Case Logic requests (see Case Logic Applications).

This section lists the data formats that may be specified in FIXFORM statements. In addition to alphanumeric format, there are date (DATE), text field (TX), and conditional text field (CTX) formats, and numeric formats of fields in HOLD and SAVB files and of fields generated by user-written programs. The formats are

[A]n[YQMDWV] In[YQMD] F4 D8 Pn[.m][YQMD] DATE /TX /CTX Zn[.m]

where:

[A]n[YQMD]

Specifies an alphanumeric character string n bytes long, where n is an integer.

Date component options (YY, Y, Q, M, D) are included as necessary for a date field.

The V and W options are for AnV fields that were propagated to a HOLD file.

• W indicates that the length of the input field is n+6 bytes. The first six bytes contain the length of the character data within the subsequent n bytes. Use for inputting data from HOLD FORMAT ALPHA files.
• V indicates that the length of the input is n+2 bytes. The first two bytes are binary and contain the length of the character data within the subsequent n bytes. Use for inputting data from binary HOLD files.

In[YQMD]

Specifies a binary integer n bytes long, where n is 1, 2, or 4. Date component options (YY, Y, Q, M, D) are included as necessary for a date field.

F4

Specifies a 4-byte binary floating point number.

D8

Specifies an 8-byte binary double precision number.

Pn[.m][YQMD]

Specifies a packed number n bytes long with m digits after an implied decimal point. n is an integer between 1 and 16 and m is an integer between 0 and 33. Date component options (YY, Y, Q, M, D) are included as necessary for a date field.

DATE

Specifies a date field in 4-byte integer format, to be copied to the data source without date translation or validation. Date format fields can also be read without these restrictions by specifying alphanumeric, integer, or packed format, as described later in this section.

/TX|/CX

Specifies a text field format for transaction and conditional transaction fields. Each FIXFORM statement can include multiple text fields. However, they must appear as the last fields in the statement, they may not be conditional, and, in the data file, each text field must be terminated with the %$ character combination on a line by itself. Note that you do not specify the length when using FIXFORM to read text fields; the length is for display purposes only (see the Describing Data manual).

See Entering Text Data Using TED for general rules.

Note:

• Text fields must be the last fields listed in the FIXFORM statement. If they are being loaded from a HOLD file, they must also be the last fields in the HOLD file.
• If the word END appears on a line by itself, FOCUS interprets it as a quit action, stops the procedure, and discards everything entered up to that point for a particular record.
• To end a transaction and exit MODIFY, first enter the end-of-text character (%$) on a line by itself, then enter END on the next line.
• If data is read from an external data source, the record format must be fixed.
• If a text field is not mentioned in the FIXFORM statement, but it is present in the Master File, the value of the text field is determined based on the setting of the MISSING attribute. That is, if MISSING=ON, the text will be entered as a dot (.). If MISSING=OFF, the text will be entered as a blank.

Zn[.m]

Specifies a zoned decimal number n bytes long with m digits after an implied decimal point. n is an integer between 1 and 16 and m is an integer between 0 and 9.

For example, this FIXFORM statement

FIXFORM EMP_ID/9 HIRE_DATE/I4 CURR_SAL/D8 ED_HRS/P4.2

defines each record as the following:

• The first nine bytes as the character string EMP_ID.
• The next four bytes as the binary integer HIRE_DATE.
• The next eight bytes as the binary double precision number CURR_SAL.
• The next four bytes as the packed number ED_HRS. The last two digits of the number follow an implied decimal point.

The FIXFORM statement specifies the field formats of transaction data sources, not the data source being updated. A transaction field can modify a data source field if the transaction field has one of the following format types (the format type is the type of field, such as alphanumeric or floating point):

• The same format type as the data source field.
• Alphanumeric format.
• Zoned format (if the data source field is packed).

If you specify any other format type for the transaction field (for example, an integer transaction field to modify a floating point data source field), the request may terminate and generate an error message. To read such a transaction value into a data source field, do the following:

1. Before the FIXFORM statement, use the COMPUTE statement to define a name for the incoming data field that is different from the data source field (the COMPUTE statement is discussed in Computations: COMPUTE and VALIDATE). The statement also specifies the field format, showing the format type and the number of digits in the field.
2. In the FIXFORM statement, read the incoming data field using the name you defined in the COMPUTE statement. The field format in the FIXFORM statement shows the field length in bytes in the transaction data source.
3. After the FIXFORM statement, use the COMPUTE statement to set a field with the same name as the data source field equal to the value of the field you defined in step 1.

   Note: If the incoming field is numeric and the data source field is alphanumeric, use the EDIT function to do this. The EDIT function is described in the Creating Reports manual.

The following request reads a floating point field called FLOATSAL into the data source double-precision field CURR_SAL:

MODIFY FILE EMPLOYEE
COMPUTE FLOATSAL/F8=;
FIXFORM EMP_ID/12 FLOATSAL/F4
COMPUTE CURR_SAL = FLOATSAL;
MATCH EMP_ID
  ON NOMATCH REJECT
  ON MATCH UPDATE CURR_SAL
DATA ON FLOAFILE
END

Notice that the FLOATSAL field is defined with a format of F8 in the first COMPUTE statement and a format of F4 in the FIXFORM statement. FLOATSAL is an eight-digit field that takes up four bytes in the transaction data source.

In MODIFY, by default, FIXFORM FROM mastername treats all transaction data as conditional, meaning that space-filled fields are considered not present, and as such cannot be updated or used in updates.

The SET FIXFRMINPUT command enables you to specify how to handle FIXFORM input fields as either conditional (field/format C) or non-conditional fields. Thus, spaces in a transaction field can be used for updating database fields.

SET FIXFRMINPUT = {COND|NONCOND}

SET ASNAMES = ON
DEFINE FILE EMPDATA                                                    
LN1/A15 = IF PIN EQ '000000040' THEN '' ELSE LN;               
END                                                                    
TABLE FILE EMPDATA 
PRINT PIN LN1 AS LN                              
IF PIN FROM '000000010' TO '000000100'                                 
ON TABLE HOLD AS TRANS                                                 
END

SET FIXFRMINPUT = COND                               
-? SET FIXFRMINPUT &FIXF
 
MODIFY FILE EMPDATA                                  
 FIXFORM FROM TRANS                                   
 MATCH PIN                                            
  ON MATCH UPDATE LN                                  
  ON NOMATCH REJECT                                   
 DATA ON TRANS
END                                                  
 

TABLE FILE EMPDATA 
HEADING                                              
" "                  
"VALUE OF FIXFRMINPUT IS &FIXF "                  
" "                  
PRINT PIN LN                      
 IF PIN FROM '000000010' TO '000000100'               
END

 VALUE OF FIXFRMINPUT IS COND 
                                 
PIN        LASTNAME              
---        --------              
000000010  VALINO                
000000020  BELLA                 
000000030  CASSANOVA             
000000040  ADAMS                 
000000050  ADDAMS                
000000060  PATEL                 
000000070  SANCHEZ               
000000080  SO                    
000000090  PULASKI               
000000100  ANDERSON              

SET FIXFRMINPUT = NONCOND
-? SET FIXFRMINPUT &FIXF
 
MODIFY FILE EMPDATA                                  
 FIXFORM FROM TRANS                                   
 MATCH PIN                                            
  ON MATCH UPDATE LN                                  
  ON NOMATCH REJECT                                   
 DATA ON TRANS                                        
END                                                  
 
TABLE FILE EMPDATA 
HEADING                                              
" "                  
"VALUE OF FIXFRMINPUT IS &FIXF "                  
" "                  
PRINT PIN LN                      
 IF PIN FROM '000000010' TO '000000100'               
END 

 VALUE OF FIXFRMINPUT IS NONCOND
                                
PIN        LASTNAME             
---        --------             
000000010  VALINO               
000000020  BELLA                
000000030  CASSANOVA            
000000040                       
000000050  ADDAMS               
000000060  PATEL                
000000070  SANCHEZ              
000000080  SO                   
000000090  PULASKI              
000000100  ANDERSON             

You may use a fixed-format transaction record to modify multiple segment instances. The set of transaction fields that modify the instances is called a repeating group because the fields repeat for each instance. Instead of explicitly specifying each field, you specify the repeating group once with a multiplying factor in front.

The syntax is

FIXFORM factor (group)

where:

factor

Is the number of times that the group repeats.

group

Is the repeating group consisting of a list of fields and formats.

For example, assume you design a request that records the last 12 months of employees' monthly pay in the EMPLOYEE data source. Each transaction record contains the employee's ID and 12 pairs of fields: the first field in each pair is the pay date, the second is the monthly pay (GROSS). The request is:

MODIFY FILE EMPLOYEE
FIXFORM EMP_ID/9 X1 12 (PAY_DATE/6 GROSS/7)
MATCH EMP_ID
  ON NOMATCH REJECT
  ON MATCH CONTINUE
MATCH PAY_DATE
  ON MATCH REJECT
  ON NOMATCH INCLUDE
DATA ON EMPGROSS
END

Each incoming record that the request reads contains one EMP_ID field and 12 groups of fields, each group consisting of a pay date field and a monthly pay field. The request reads a record, then splits the record into 12 smaller logical records, each consisting of the employee ID of the original record and one group. FOCUS then executes the request for each logical record, processing each group separately.

You may specify more than one group in a FIXFORM statement, but they cannot be nested.

Note: To process repeating groups in a Case Logic request, place each repeating group in a FIXFORM statement in a separate case. The case should include the following:

• A counter that counts the group being processed.
• An IF statement that branches out of the case after all the groups are processed.
• GOTO phrases that branch back to the beginning of the case after each group is processed.

The following request adds and updates information on employees' monthly pay. Note the ON INVALID phrase that branches back to the beginning of the case if a monthly pay entry is greater than $2500. The request is:

MODIFY FILE EMPLOYEE
COMPUTE
  COUNTER/I3 = 0;
FIXFORM EMP_ID/9
MATCH EMP_ID
  ON NOMATCH REJECT
  ON MATCH GOTO NEWPAY
GOTO NEWPAY

CASE NEWPAY
COMPUTE
  COUNTER/I1 = COUNTER + 1;
IF COUNTER GT 3 GOTO TOP;
FIXFORM 3 (PAY_DATE/6 GROSS/7)
VALIDATE
  PAYTEST = IF GROSS GT 2500 THEN 0 ELSE 1;
  ON INVALID GOTO NEWPAY
MATCH PAY_DATE
  ON NOMATCH INCLUDE
  ON NOMATCH GOTO NEWPAY
  ON MATCH UPDATE GROSS
  ON MATCH GOTO NEWPAY
ENDCASE
DATA ON PAYFILE
END

The syntax of the FREEFORM statement is

FREEFORM [ON ddname] [field-1field-2 ... field-n]

where:

ON ddname

Is an option that specifies the ddname of the transaction data source containing the incoming data. Use this option only when the DATA statement does not specify a ddname or specifies a ddname of a different data source.

field-1 ...

Are the names of the fields in the order that they appear in the record.

Note: FREEFORM follows the same rules as FIXFORM when dealing with TEXT fields. For more information see Reading Fixed-Format Data: The FIXFORM Statement.

If the order of fields is specified in the data, you do not need it in the syntax and if the order of fields is specified in the syntax, you do not need it in the data.

The list of fields must fit on one line. If the list is too long for a single line, use a FREEFORM statement for each line. For example:

FREEFORM EMP_ID LAST_NAME FIRST_NAME
FREEFORM DEPARTMENT CURR_SAL

These two FREEFORM statements act as one statement and read one record into the buffer.

Each time a FREEFORM statement is executed, it reads one record up to the comma-dollar sign (,$). It does not read beyond that. If the FREEFORM command is used with incoming data having embedded commas, the data must be enclosed in single quotation marks in the input data source.

If a MODIFY request has a FREEFORM statement, the statement must specify all the fields in the transaction data source. If the transaction data source has fields not specified in the FREEFORM statement, the request terminates and generates an error message.

If you do not include a transaction statement in your MODIFY request, the request assumes the default FREEFORM and expects to read comma-delimited data. The request reads one record every time it executes the first statement in the request. Nevertheless, you should include a FREEFORM statement to make clear that the request is reading comma-delimited data, to show when the request reads the data, and to allow greater flexibility in entering data into comma-delimited data sources.

If the Master File lists a date format with a translation option (see the Describing Data manual), you can type the date values in the transaction data source as they appear in reports generated by TABLE requests (but do not type the commas in the dates). Note the following conditions:

• The date format must have had the translation option before the FOCUS data source was created.
• All names of months must be in uppercase, even if the translation option is t or tr.

For example, assume you change the format of the HIRE_DATE field in the EMPLOYEE Master File from I6YMD to YMDT. You then write a request that creates a new EMPLOYEE data source. The request begins with this FREEFORM statement:

FREEFORM EMP_ID FIRST_NAME LAST_NAME HIRE_DATE/9

Both these records are valid input:

444555666, DOROTHY, TAILOR, 860613, $
444555666, DOROTHY, TAILOR, 86 JUN 13, $

The syntax of the PROMPT statement is

PROMPT {field-1[.text.] field-2[.text.] ... field-n[.text.]|*}

where:

field-1 ...

Are the names of the fields for which you are prompting. An asterisk * instead of field names prompts for all fields described in the Master File in the order that they are declared.

The list of fields must fit on one line. If the list is too long to fit on one line, use a PROMPT statement for each line. For example:

PROMPT EMP_ID LAST_NAME FIRST_NAME
PROMPT DEPARTMENT CURR_SAL

Each field in the Master File with a text field format must appear in a separate PROMPT statement as the last field in the statement. When prompted for text, note that the length of the text entry is limited only by the amount of virtual storage space. The last line of text data that you enter must be followed by the end-of-text mark (%$) on a line by itself. For additional guidelines regarding fields with a text field format, see Entering Text Data Using TED.

text

Is optional prompting text, up to 38 characters per field.

Do not place an END statement at the end of the request. Conclude the request with the DATA statement.

The following request updates information about employees' department assignments, salaries, and job codes:

MODIFY FILE EMPLOYEE
PROMPT EMP_ID DEPARTMENT CURR_SAL CURR_JOBCODE
MATCH EMP_ID
  ON MATCH UPDATE DEPARTMENT CURR_SAL CURR_JOBCODE
  ON NOMATCH REJECT
DATA

When you execute the command, the following appears on your screen

> EMPLOYEE ON 06/19/98 AT 14.38.27
DATA FOR TRANSACTION 1

MP_ID= >

where:

EMPLOYEE

Is the system name of the data source (in this case, the TSO name).

ON 06/19/98 AT 14.38.27

Is the date and time that FOCUS opened the data source: June 19, 1998 at 2:38:27 p.m.

DATA FOR TRANSACTION 1

Notifies the user that the request is prompting for the first transaction. Each cycle of prompts constitutes one transaction. When the next transaction begins, the request prompts again for the first field in the cycle. In this request, the EMP_ID, DEPARTMENT, CURR_SAL, and CURR_JOBCODE prompts constitute one transaction. When the next transaction begins, the request prompts for the EMP_ID field again.

EMP_ID = >

Is the default prompt for the EMP_ID field (the field name).

As each prompt appears, enter the value for the field requested. When you finish entering values, end execution by entering End or Quit at any prompt. The following is a sample execution of the request shown above (user input is shown in lowercase; computer responses are in uppercase):

> EMPLOYEE ON 06/19/98 AT 14.38.27
    DATA FOR TRANSACTION 1
 
    EMP_ID        = > 071382660
    DEPARTMENT    = > mis
    CURR_SAL      = > 22500.35
    CURR_JOBCODE  = > b12
    DATA FOR TRANSACTION 2
 
    EMP_ID        = > end
    TRANSACTIONS: TOTAL=  1  ACCEPTED=  1  REJECTED= 0
    SEGMENTS:     INPUT=  0  UPDATED=   1  DELETED=  0

When you design a request that prompts for fields and validates them, we recommend that validating the field values after every prompt is recommended. This saves extra typing if one of the field values proves invalid. Validation tests are discussed in Validating Transaction Values: The VALIDATE Statement.

If the Master File lists a date format with a translation option (see the Describing Data manual), you may type the date as it appears in reports generated by TABLE requests (but do not type the commas in the dates). Note that the date format must have had the translation option before the FOCUS data source was created.

For example, assume you change the format of the HIRE_DATE field in the EMPLOYEE Master File from I6YMD to YMDT. You then write a request that creates a new EMPLOYEE data source. The request begins with this FIXFORM statement:

PROMPT EMP_ID FIRST_NAME LAST_NAME HIRE_DATE

When you execute the request, a sample transaction might appear like this:

DATA FOR TRANSACTION 2
 
EMP_ID           = > 444555666
FIRST_NAME       = > dorothy
LAST_NAME        = > tailor
HIRE_DATE (YMDT) = > 98 jun 13

Note that you can also respond to the HIRE_DATE prompt with the value 980613.

You may prompt for the same group of fields repeatedly. This is convenient when you want to modify a child segment chain. You prompt once for the key field of the parent instance and prompt repeatedly for the values of the child instances. Without repeating groups, you must prompt for the key field of the parent instance each time you prompt for a child instance.

For example, a MODIFY request updates employees' monthly pay. It first prompts for an employee ID, then for 12 pairs of fields: the first field in each pair is a pay date, the second field is the updated pay. The pay date and updated pay fields are a repeating group.

To specify a repeating group, use the following syntax

PROMPT factor (group)

where:

factor

Is the number of times the group repeats.

group

Is the repeating group of fields.

Note that the transaction counter that appears during prompting counts each repeating group cycle of prompts as one transaction.

For example, the following request adds three instances of monthly pay (GROSS) for each employee:

MODIFY FILE EMPLOYEE
PROMPT EMP_ID 3 (PAY_DATE GROSS)
MATCH EMP_ID
  ON NOMATCH REJECT
  ON MATCH CONTINUE
MATCH PAY_DATE
  ON MATCH REJECT
  ON NOMATCH INCLUDE
DATA

This request prompts you for an employee ID, then a pay date, a monthly pay, a pay date, a monthly pay, and so on until it prompts you for three pay dates and three monthly pays. It then prompts you for the next employee ID.

The following is a sample execution of the previous request:

> EMPLOYEE  ON 09/19/98 AT 15.01.38
    DATA FOR TRANSACTION   1
 
    EMP_ID      = > 071382660
    PAY_DATE    = > 860131
    GROSS       = > 1360.50
    DATA FOR TRANSACTION   2
 
    PAY_DATE    = > 860228
    GROSS       = > 1360.85
    DATA FOR TRANSACTION   3
 
    PAY_DATE    = > 860331
    GROSS       = > 1360.50
    DATA FOR TRANSACTION   4
 
    EMP_ID      = >

You can place multiple repeating groups in the same statement. This PROMPT statement contains two repeating groups:

PROMPT EMP_ID 3 (PAY_DATE GROSS) 2 (DAT_INC SALARY)

The statement prompts for:

1. An employee ID.
2. A pay date and a monthly pay, three times.
3. A salary raise date (DAT_INC) and a new salary, two times.
4. The next employee ID.

You can nest repeating groups. For example, this prompt statement

PROMPT EMP_ID 6 (PAY_DATE 7 (DED_CODE DED_AMT))

prompts for:

1. An employee ID.
2. A pay date.
3. A deduction code and deduction amount, seven times.
4. Steps 2 and 3 repeat for a total of six times.
5. The next employee ID.

When you run a request containing PROMPT statements, the request prompts you for each field by displaying the field name and an equal sign (=). However, you may specify your own prompt. The syntax is

PROMPT fieldname.text.

where:

fieldname

Is the name of the field you are prompting for.

text

Is the text you want to appear as the prompt, up to 38 characters. Text must be enclosed within periods.

Note the following rules regarding prompt text:

• The text must be delimited by a period (.) on either side, with no space between the field name and the first period.
• The text cannot contain apostrophes or single quotation marks (').
• The text must be typed on one line.
• A single MODIFY request can contain up to 4000 characters of prompt text.

This request adds new employees to the EMPLOYEE data source:

MODIFY FILE EMPLOYEE
PROMPT EMP_ID.ENTER THE EMPLOYEE ID NUMBER:.
PROMPT FIRST_NAME.ENTER FIRST NAME:.
PROMPT LAST_NAME.ENTER LAST NAME:.
PROMPT HIRE_DATE.WHAT DATE WAS EMPLOYEE HIRED?.
PROMPT CURR_SAL.WHAT IS THE STARTING SALARY?.

MATCH EMP_ID
  ON MATCH REJECT
  ON NOMATCH INCLUDE
DATA