Keys and adding, deleting and modifying records in an array

1
Keys and adding, deleting and modifying records
in an array

• Record Keys
• Reading and Adding Records
• Partition or Sentinels Marking Space in Use
• Dynamic allocation example
• Deleting records
• Modifying Records

2
Record Keys

• A key is one or more fields used to identify a
  record in a database table. For the key to be
  useful in identifying records this key must be
  unique. A key can be kept unique if
• New records aren't added if the key is used for
  an existing record.
• Key fields can't be changed to match other record
  keys.
• A suitable natural key may or may not be
  available. E.G. System accounts might use the
  email address as a natural key. The advantage
  would be that users can be expected to remember
  their email address when they login, so they
  don't have to remember any other identifier. The
  email address is a natural key because it is
  assumed unique, but has other purposes within the
  system, e.g. for sending account passwords.

3
Surrogate keys

• Sometimes a surrogate (made-up or artificial) key
  is preferred, because no suitable natural unique
  key exists. The email address would be unsuitable
  if 2 accounts could share the same email address.
  It might also be unsuitable if the system design
  requires account anonymity. Another reason for
  having a surrogate key would be to minimise key
  size, in order to speed manual data input
  required for record identification. Perhaps one
  of the best known surrogate keys is the UK
  postcode system. This only provides a unique
  address record key when combined with other parts
  of the address, e.g. a house number.

4
Keys and database integrity

• Many system designs will prevent modification of
  key fields. If this is needed, a record might be
  deleted and a new one added. Changing a value
  which is a foreign key in another table will
  leave records referring to it unlinked.
  Multi-table system designs will often require
  records containing a foreign key to be removed
  before the record they refer to can be removed.

5
Reading and Adding Records

• Arrays are often the simplest and most convenient
  data structure used for maintaining sets of
  records. Having defined a record we can use an
  array to store as many records as memory allows.
  The array can be allocated either at compile time
  or dynamically. If we use dynamic allocation we
  can calculate the memory needed by counting the
  records in the file before allocating the
  required amount of space.
• This assumes we
• a. open the file
• b. count the number of records in the file
• c. allocate the required amount of memory
  space
• d. rewind the file (or close and reopen
  it)?
• e. read the records from the file into the
  space now allocated.

6
Avoiding memory overflow

• Compile time allocation is simpler but less
  flexible the maximum number of records is
  decided for the program at coding time, most
  conveniently through a global constant e.g.
  MAXRECS which may be changed prior to
  compilation.
• If we want to add records to an array while the
  program is operating this may only be
  accomplished safely, without overflowing the
  array bounds, if a check is made prior to the
  record being added to ensure that there is unused
  space within the array for the additional record.
  If we allocate the array as having space for
  MAXRECS e.g. RECORD aMAXRECS we can safely use
  positions from a0 to aMAXRECS-1 .

7
Array Partition or Sentinels Marking Used Space

• If the array size allows for more records than
  are in use at any given time, 2 approaches are
  commonly used which enable identification of used
  and unused array positions
• If n of MAX records are in use, these occupy
  positions indexed between 0 and n-1 in the array.
  Positions n to MAX-1 are unused. n is stored as
  an integer (e.g. int nrecs), which is incremented
  when a record is read into the array or added to
  it, and decremented when a record is deleted.
  This approach allows use of standard search and
  sort functions.
• A sentinel value is used for the key field (e.g.
  -1 when used keys are all positive integers) to
  indicate unused positions. When adding records
  the first unused position is used. When deleting
  records the sentinel value is substituted for the
  key value. Every access to the array will have to
  look for sentinel values to distinguish used and
  unused positions.

8
Dynamic allocation example
9
Dynamic allocation example 2
10
Dynamic allocation example 3

• The above program code dynamically allocates
  space for maxrecs records in the array a with
  maxrecs being set as the number of records found
  in the input file plus 5, to allow for the user
  to add up to 5 extra records during the program
  run. The program keeps track of how many records
  within the array a are used at any given time.
• The approach coded above is naive, because it
  does not prevent addition of duplicate keys.

11
Deleting records 1

• In the example above, where there are maxrecs
  positions within the array of which nrecs
  positions are used, it has been assumed that at
  any given time all array indices between 0 and
  nrecs-1 are in use and remaining indices from
  nrecs to maxrecs-1 are vacant. If we adopt this
  approach there are 2 methods by which we could
  delete a record.
• The first involves finding the record to be
  deleted and shuffling all higher records down by
  one in turn starting with the record above the
  delete position and then taking one away from
  (decrementing) nrecs. If the record we wish to
  delete is randomly positioned within the used
  slots we will have to move nrecs/2 records on
  average to accomplish this

12
Deleting records 2

• The approach above will be required if the array
  is to be kept in sorted order as it doesn't
  change the order of the remaining records.
• However, moving on average nrecs/2 records is
  inefficient for a very large unsorted array if
  there is no need to maintain the record order. A
  faster approach is to to move the top record used
  to the deletion position and decrement nrecs.
  This only moves a single record

13
Deleting records 3
14
Deleting records 4
15
Deleting records 5
16
Modifying Records

• A function which modifies a record should
  generally not modify a key. If a key needs to be
  modified, this can be done more safely by using
  the functions to delete the old and add the new
  version of the record. A well-designed delete()
  function will prevent removal of a referent from
  a foreign key in a multi-table database.
• Other fields can be modified so long as the same
  validation constraints are maintained as when a
  record is added.

17
Functionality common to add, mod and delete
record functions

• The index of the record to be modified must be
  identified. An add() function must identify that
  the key does not already exist to prevent
  duplicates. A del() function must identify the
  index of the record to be removed. The
  requirement to search for a key is therefore
  shared between these 3 modules. To avoid breaking
  modularity, finding the index corresponding to a
  key or identifying the absence of a key within
  the array must be programmed as a separate find()
  function.
• The add() and del() functions may need to alter
  nrecs, the number of records in the used
  partition of the array. The mod() function will
  not need to change this value.