Creates a storage map for a relation.  A storage map associates a
 relation with a particular storage area or areas.  The DEFINE STORAGE
 MAP statement allows you to specify:

  o  Which storage areas the records in a relation will be stored in
  o  Whether an index will be used to choose a target location for
     storing the record
  o  Whether data compression will be enabled when the records are
     stored
  o  Which storage areas segmented strings will be stored in


 Example:

    RDO>   DEFINE STORAGE MAP JOBS_MAP FOR JOBS
    cont>    STORE WITHIN JOBS
    cont>  END JOBS_MAP STORAGE MAP.

Additional information available:

FormatMoreExamples

 DEFINE STORAGE MAP ───────────> map-name ─────────┐
 ┌────────────────────────<────────────────────────┘
 └──────┬─────────────────>───────────────┬────────┐
        └─> 
D
E
S
C
R
I
P
T
I
O
N typebox (I)typebox (S) typebox (/)typebox (*)  text  */ ──┘        │
 ┌────────────────────────<────────────────────────┘
 └─> 
F
O
R ─────> relation-map-clause ───────────────┐
  ┌───────────────────────────────<────────────────┘
  └─> 
E
N
D ──┬───────>──────┬──┬────────>───────┬─> .
            └─> map-name ──┘  └─> 
S
T
O
R
A
G
E 
M
A
P ─┘

Additional information available:

map-nametextrelation-map-clause

 Specifies the name for the storage map being defined.

 A text string that adds a comment to the storage map definition.

 relation-map-clause =

 ──┬─> relation-name ────> typebox (R)typebox (E)typebox (L)typebox (A)typebox (T)typebox (I)typebox (O)typebox (N) ──┬───────┐
   └─> 
S
E
G
M
E
N
T
E
D 
S
T
R
I
N
G
S ─────────────┘       │
  ┌────────────────────<──────────────────────┘
  └──┬─┬──> store-clause ────────────────────────┬─┬─>
     │ ├──> 
P
L
A
C
E
M
E
N
T 
V
I
A 
I
N
D
E
X ──> index-name ──┤ │
     │ └┬──> 
D
I
S
A
B
L
E ──┬─> 
C
O
M
P
R
E
S
S
I
O
N ──────────┘ │
     │  └──> 
E
N
A
B
L
E ───┘                           │
     └─────────────────────────<───────────────────┘

Additional information available:

SEGMENTED_STRINGSPLACEMENT_VIA_INDEX

relation-namestore-clauseCOMPRESSION clause

 Specifies the relation to which the storage map will apply.  The
 relation must already be defined and cannot have a storage map
 associated with it.

 Specified when you want to store segmented strings in multiple
 storage areas.  Use the store-clause to specify the storage areas in
 which you wish to store the segmented strings.

 store-clause =

 STORE ──┐
 ┌───────┘
 └┬> 
W
I
T
H
I
N ┬> area-name ┬────────────────────>─────────────┬┬─> typebox (;) ┬─┬─>
  │         │            └> 
F
O
R ─┬┬┬> rel-name ─┬───────────┤│     │ │
  │         │                    ││└─── , <─────┘           ││     │ │
  │         │                    │└┬> rel-name.field-name ─┬┘│     │ │
  │         │                    │ └───────── , <──────────┘ │     │ │
  │         │                    └──────────── , <───────────┘     │ │
  │         └────────────────────────<─────────────────────────────┘ │
  └> 
U
S
I
N
G ─┬─> field-name ─┬─> 
W
I
T
H
I
N ──────>──────┐                │
            └─────── , ─────┘                       │                │
   ┌───────────────────────<────────────────────────┘                │
   └┬─> area-name ─> 
W
I
T
H 
L
I
M
I
T typebox (O)F ─┬> literal ─┬─> typebox (;) ─┬─┐           │
    │                               └──── , <───┘      │ │           │
    └───────────────────<──────────────────────────────┘ │           │
   ┌─────────────────────────<───────────────────────────┘           │
   └───────> area-name ───────────>──────────────────────────────────┘

Additional information available:

WITH_LIMIT_OF

area-namerel namerel name field nameUSING field-name

 The name of the storage area you want records stored in.  You must
 define this storage area with the DEFINE DATABASE statement before
 you refer to it in the store clause.

 The name of the relation whose segmented strings you want to store in
 the specified storage area.  If you want to store the segmented
 strings of more than one relation in the storage area, separate the
 names of the relations with commas.

 The name of the relation and segmented string field that you want to
 store in the specified storage area.  If you want to store more than
 one segmented string field in the storage area, separate the list
 items with commas.

 The names of the fields whose values will be used as limits for
 partitioning the relation across multiple storage areas.  Rdb/VMS
 compares values in the fields to the values in the WITH LIMIT OF
 clause to determine where to initially store the record.

 The maximum value for the index key that will reside in the specified
 storage area.

 The number of literals in this clause must be the less than or equal
 to the number of fields in the USING clause.  Repeat this clause to
 partition the index entries among multiple storage areas.

 When you define a multisegmented index using multiple keys and use
 the STORE USING...WITH LIMITS clauses, if the values for the first
 key are all the same, then set the limit for the first key at that
 value.  By doing this, you ensure that the value of the second key
 determines the storage area in which each record will be stored.

 Note that the last storage area you specify CANNOT have a WITH LIMIT
 OF clause associated with it.

 Indicates that Rdb/VMS should attempt to store a record in a way that
 optimizes access to that record via the indicated path.

 If the index named is a hashed index, the storage area named must
 have a MIXED page format.  If the hashed index definition and the
 storage map for the relation designate the same storage area, then
 the record is stored on the same page as the hashed index node.
 Otherwise, Rdb/VMS uses the same relative page within the data
 storage area as the target page.

 If the index named is a sorted index, Rdb/VMS finds the dbkey of the
 next lowest record to the one being stored and uses the page number
 in the dbkey as the target page.

 Specifies whether data compression will be enabled or disabled when
 the records are stored.  ENABLE COMPRESSION is the default.

 To define a storage map for a relation, you need the Rdb/VMS DEFINE
 privilege to the relation.

 You must execute this statement in a read/write transaction.  If
 there is no active transaction and you issue this statement, Rdb/VMS
 starts a read/write transaction implicitly.

 Other users are allowed to be attached to the database when you issue
 the DEFINE STORAGE MAP statement.  However, they are not allowed to
 be using the relation whose storage map is being defined.

 Example 1

 The following statement defines a storage map for the employees
 relation in MF_PERSONNEL.

 DEFINE STORAGE MAP EMPLOYEES_MAP
    DESCRIPTION IS /* EMPLOYEES partitioned by EMPLOYEE_ID */
    FOR EMPLOYEES RELATION
  STORE USING EMPLOYEE_ID
   WITHIN
    EMPIDS_LOW WITH LIMIT OF "00200";
    EMPIDS_MID WITH LIMIT OF "00400";
    EMPIDS_OVER
 END EMPLOYEES_MAP STORAGE MAP.

 Example 2

 The following example shows how to define a storage map that stores
 all records from a relation in the named storage area:


 RDO>  DEFINE STORAGE MAP SALARY_HISTORY_MAP
 cont>  DESCRIPTION IS /* Map for salary history records */
 cont>  FOR SALARY_HISTORY RELATION
 cont>   STORE WITHIN SALARY_HISTORY
 cont> END SALARY_HISTORY_MAP STORAGE MAP.

 This statement stores all the records from the SALARY_HISTORY
 relation into the storage area, SALARY_HISTORY.  SALARY_HISTORY is
 the name of a storage area that was created with the DEFINE DATABASE
 statement.

 Example 3

 The following example uses the PLACEMENT VIA INDEX clause to store
 records in a storage area according to a hashed index:

 RDO>   DEFINE STORAGE MAP DEPARTMENTS_MAP
 cont>    FOR DEPARTMENTS RELATION
 cont>    STORE WITHIN DEPARTMENTS
 cont>    PLACEMENT VIA INDEX DEPARTMENTS_INDEX
 cont>  END DEPARTMENTS_MAP STORAGE MAP.

 Example 4

 The following example defines a database and two relations that
 contain segmented strings.  The two relations are mapped along with
 their segmented strings to separate storage areas.

 DEFINE DATABASE SEGSTR_0
   DESCRIPTION IS
   /*
   This database is used to test the Rdb/VMS V4.0 enhanced
   segmented string support.  Two relations that contain
   segmented strings are mapped along with their segmented
   string data to separate storage areas.
   */
   DICTIONARY IS NOT USED

   DEFINE STORAGE AREA RDB$SYSTEM
     FILENAME 'SEGSTR_0'
   END

   DEFINE STORAGE AREA SEGSTR_1
     FILENAME 'SEGSTR_1'
   END

   DEFINE STORAGE AREA SEGSTR_2
     FILENAME 'SEGSTR_2'
   END

   DEFINE STORAGE AREA SEGSTR_SS1
     FILENAME 'SEGSTR_SS1'
   END

   DEFINE STORAGE AREA SEGSTR_SS2
     FILENAME 'SEGSTR_SS2'
   END

   SEGMENTED STRING STORAGE AREA IS SEGSTR_SS2.

 DEFINE FIELD STANDARD_DATE
 DATATYPE DATE.

 DEFINE FIELD TITLE
 DATATYPE TEXT SIZE 50.

 DEFINE FIELD DIARY_ENTRY
 DATATYPE SEGMENTED STRING
 SUB_TYPE TEXT
 SEGMENT_LENGTH 200.

 DEFINE RELATION DAILY_DIARY
   DESCRIPTION /* Simple diary */.
   ENTRY_DATE          BASED ON STANDARD_DATE.
   TITLE.
   DIARY_ENTRY.
 END.

 DEFINE RELATION SPECIAL_EVENTS
   DESCRIPTION IS
   /* Special events - birthdays, anniversaries, etc. */.
   EVENT_DATE           BASED ON STANDARD_DATE.
   EVENT_NAME           BASED ON TITLE.
   EVENT_DESCRIPTION    BASED ON DIARY_ENTRY.
   SPECIAL_INSTRUCTIONS BASED ON DIARY_ENTRY.
 END.

 DEFINE STORAGE MAP DAILY_DIARY_MAP
   DESCRIPTION IS
   /* Diary entries are randomly partitioned over two areas */
   FOR DAILY_DIARY
   STORE WITHIN SEGSTR_1; SEGSTR_2
 END.

 DEFINE STORAGE MAP SPECIAL_EVENTS_MAP
   DESCRIPTION IS
   /* Special events entries are stored in one area */
   FOR SPECIAL_EVENTS
   STORE WITHIN SEGSTR_1
 END.

 DEFINE STORAGE MAP DIARY_TEXT
   DESCRIPTION IS
   /* Keep segmented strings in separate areas */
   FOR SEGMENTED STRINGS
   STORE WITHIN
     SEGSTR_SS1 FOR DAILY_DIARY, SPECIAL_EVENTS.EVENT_DESCRIPTION;
     SEGSTR_SS2 FOR DAILY_DIARY;
     SEGSTR_1 FOR SPECIAL_EVENTS.SPECIAL_INSTRUCTIONS;
     RDB$SYSTEM      ! RDB$SYSTEM stores other segmented strings
     END.