• Home
• net.sf.jt400
• jt400
• 20.0.8
• source code
• KeyedFile.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.ibm.as400.access.KeyedFile Maven / Gradle / Ivy

///////////////////////////////////////////////////////////////////////////////
//                                                                             
// JTOpen (IBM Toolbox for Java - OSS version)                              
//                                                                             
// Filename: KeyedFile.java
//                                                                             
// The source code contained herein is licensed under the IBM Public License   
// Version 1.0, which has been approved by the Open Source Initiative.         
// Copyright (C) 1997-2004 International Business Machines Corporation and     
// others. All rights reserved.                                                
//                                                                             
///////////////////////////////////////////////////////////////////////////////

package com.ibm.as400.access;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.net.UnknownHostException;
import java.util.Vector;
import java.beans.PropertyChangeSupport;
import java.beans.PropertyChangeListener;
import java.beans.VetoableChangeListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyVetoException;
import java.math.BigDecimal;

/**
 *The KeyedFile class represents a physical or logical file on the system.
 *It allows the user to do the following:
 *

 *
Create a physical file by:
 *

 *
Specifying a record length.
 *
Specifying an existing DDS source file.
 *
Specifying a RecordFormat object that contains a description of the
 *    record format for the file.
 *
 *
Access the records in a file sequentially or by key.
 *    Note: The read...() methods of this class return records in key order.
 *
Write records to a file sequentially or by key.
 *
Update records in a file sequentially or by key.
 *
Lock a file for different types of access.
 *
Use commitment control when accessing a file.  The user can:
 *

 *
Start commitment control for the connection.
 *
Specify different commitment control lock levels for the individual
 *    files being accessed.
 *
Commit and rollback transactions for the connection.
 *
 *
Delete a physical or logical file or member.
 *
 *KeyedFile objects generate the following events:
 *

 *
FileEvent
 *
The events fired are:
 *

 *
FILE_CLOSED
 *
FILE_CREATED
 *
FILE_DELETED
 *
FILE_MODIFIED
 *
FILE_OPENED
 *
 *
PropertyChangeEvent
 *
VetoableChangeEvent
 *
 *@see MemberList
**/
public class KeyedFile extends AS400File implements Serializable
{
    static final long serialVersionUID = 4L;


  /**
   *Constant indicating search type of equal.
  **/
  static public final int KEY_EQ = 0;

  /**
   *Constant indicating search type of greater than.
  **/
  static public final int KEY_GT = 1;

  /**
   *Constant indicating search type of greater than or equal.
  **/
  static public final int KEY_GE = 2;

  /**
   *Constant indicating search type of less than.
  **/
  static public final int KEY_LT = 3;

  /**
   *Constant indicating search type of less than or equal.
  **/
  static public final int KEY_LE = 4;

  static protected final int[] TYPE_TABLE = {0x0B, 0x0D, 0x0C, 0x09, 0x0A};
  
  /**
   *Constructs a KeyedFile object.
  **/
  public KeyedFile()
  {
  }

  /**
   *Constructs a KeyedFile object. It uses the specified file.
   *If the name for the file does not include a member, the
   *first member of the file will be used.
   *@param system The system to which to connect. The system cannot
   *be null.
   *@param name The integrated file system pathname of the file. The name
   *cannot be null.
  **/
  public KeyedFile(AS400 system, String name)
  {
    super(system, name);
  }

//@RBA
  /**
   * Set to read records with Record Number in long type. 
   * @param v 
   */
  public void setLongRecordNumber(boolean v){
    longRecordNumber = v;
  }
  
  /**
   *Deletes the record specified by key.  The file must be open when invoking
   *this method.
   *@param key The values that make up the key with which to find the record.
   *The key must contain at least one element.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.  The number of elements in key cannot exceed the
   *number of key fields in the record format for this file.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public void deleteRecord(Object[] key)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameter(key); //@C0A
    // Find the record to delete
    impl_.doIt("positionCursorToKey", new Class[] { Object[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(TYPE_TABLE[KEY_EQ]) });
    deleteCurrentRecord();
  }


  // @A2A
  /**
   *Deletes the record specified by key.  The file must be open when invoking
   *this method.
   *@param key The byte array that contains the byte values that make up the key with which to find the record.
   *The byte array key must contain the byte values from at least one key field.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param numberOfKeyFields The number of key fields contained in the byte array key. This number cannot exceed the
   *total number of key fields in the record format for this file.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public void deleteRecord(byte[] key, int numberOfKeyFields)
   throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameters(key, numberOfKeyFields); //@C0A
    // Find the record to delete
    if(longRecordNumber)//@RBA
      impl_.doIt("positionCursorToKeyLong", new Class[] { byte[].class, Integer.TYPE, Integer.TYPE }, new Object[] { key, Integer.valueOf(TYPE_TABLE[KEY_EQ]), Integer.valueOf(numberOfKeyFields) });
    else
      impl_.doIt("positionCursorToKey", new Class[] { byte[].class, Integer.TYPE, Integer.TYPE }, new Object[] { key, Integer.valueOf(TYPE_TABLE[KEY_EQ]), Integer.valueOf(numberOfKeyFields) });
    deleteCurrentRecord();
  }

  //@C0D - moved code to base class
  /**
   *Opens the file.  The file must not be open when invoking this method.
   *If commitment control is not started for the connection,
   *commitLockLevel is ignored.  The file cursor is positioned prior
   *to the first record.  If blockingFactor is greater than one (or
   *if zero is specified and a blocking factor greater than one is determined
   *by the object) and the file is opened for READ_ONLY, the record cache will
   *be filled with an initial set of records.

   *The record format for the file must be set prior to calling this method.

   *The name of the file and the system to which to connect must be set prior
   *to invoking this method.
   *@see AS400File#AS400File(com.ibm.as400.access.AS400, java.lang.String)
   *@see AS400File#setPath
   *@see AS400File#setSystem
   *@see AS400File#refreshRecordCache
   *@see AS400File#setRecordFormat
   *@param openType The manner in which to open the file.  Valid values are:
   *                

   *                
READ_ONLY
   *                
READ_WRITE
   *                
WRITE_ONLY
   *                
   *@param blockingFactor The number of records to retrieve or to write during a
   *read or write operation.

   *The AS400File object will attempt to anticipate the need for data by accessing
   *blocks of records if the openType is READ_ONLY.  If the openType
   *is WRITE_ONLY, blockingFactor number of records will be written at one
   *time when writing an array of records.
   *If the open type is READ_WRITE, blockingFactor is ignored and a
   *blocking factor of 1 will be used for data integrity reasons.
   *Specify an appropriate blockingFactor for your performance needs.

   *If 0 is specified for blockingFactor, a default value will be calculated
   *by taking the integer result of dividing 2048 by the byte length of the record
   *plus 16.

   *If the user either specifies a blocking factor greater than 1, or specifies 0
   *which will cause a blocking factor to be calculated, there is the risk of
   *obtaining stale data when doing multiple read operations.
   *Invoke the refreshRecordCache() method prior to reading a record to cause the object
   *to read from the system if this is a problem.

   *@param commitLockLevel Used to control record locking during a transaction if
   *commitment control has been started for the connection.
   *Valid values are:
   *

   *
COMMIT_LOCK_LEVEL_ALL
   *
COMMIT_LOCK_LEVEL_CHANGE
   *
COMMIT_LOCK_LEVEL_CURSOR_STABILITY
   *
COMMIT_LOCK_LEVEL_DEFAULT
   *
COMMIT_LOCK_LEVEL_NONE
   *
   *The commitLockLevel is ignored if commitment control is not started for
   *the connection.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
   *@exception ServerStartupException If the host server cannot be started.
   *@exception UnknownHostException If the system cannot be located.
  **/
/* @C0D  public void open(int openType, int blockingFactor, int commitLockLevel)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    // Verify the object state
    if (recordFormat_ == null)
    {
      throw new ExtendedIllegalStateException("recordFormat", ExtendedIllegalStateException.PROPERTY_NOT_SET);
    }
    // Verify the parameters
    if (openType != READ_ONLY &&
        openType != READ_WRITE &&
        openType != WRITE_ONLY)
    {
      throw new ExtendedIllegalArgumentException("openType", ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
    }
    if (blockingFactor < 0)
    {
      throw new ExtendedIllegalArgumentException("blockingFactor", ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
    }
    if (commitLockLevel < 0 || commitLockLevel > 4)
    {
      throw new ExtendedIllegalArgumentException("commitLockLevel", ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
    }
    // Open the file
    openFile(openType, blockingFactor, commitLockLevel, "key");
  }
*/ // @C0D

  /**
   *Positions the file cursor to the first record matching the specified
   *key.  The file must be open when invoking this method.
   *@param key The values that make up the key with which to find the record.
   *The key must contain at least one element.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
   **/
  public void positionCursor(Object[] key)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    positionCursor(key, KEY_EQ);
  }



  // @A2A
  /**
   *Positions the file cursor to the first record matching the specified
   *key.  The file must be open when invoking this method.
   *@param key The byte array that contains the byte values that make up the key with which to find the record.
   *The byte array key must contain the byte values from at least one key field.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param numberOfKeyFields The number of key fields contained in the byte array key.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
   **/
  public void positionCursor(byte[] key, int numberOfKeyFields)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    positionCursor(key, KEY_EQ, numberOfKeyFields);
  }




  /**
   *Positions the file cursor to the first record meeting the specified search criteria
   *based on key.  The searchType indicates that the cursor should be
   *positioned to the record whose key first meets the search criteria when compared
   *to key.  The file must be open when invoking this method.
   *@param key The values that make up the key with which to find the record.
   *The key must contain at least one element.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param searchType Constant indicating the type of match required.  Valid values are:
   *

   *
KEY_EQ

   *First record whose key is equal to key.
   *
KEY_LT

   *First record whose key is less than key.
   *
KEY_LE

   *First record whose key is less than or equal to key.
   *
KEY_GT

   *First record whose key is greater than key.
   *
KEY_GE

   *First record whose key is greater than or equal to key.
   *
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public void positionCursor(Object[] key, int searchType)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameter(key); //@C0A
    if (searchType < KEY_EQ || searchType > KEY_LE)
    {
      throw new ExtendedIllegalArgumentException("searchType", ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
    }
    if(longRecordNumber)//@RBA
      impl_.doIt("positionCursorLong", new Class[] { Object[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(TYPE_TABLE[searchType]) });
    else
      impl_.doIt("positionCursor", new Class[] { Object[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(TYPE_TABLE[searchType]) });
  }

  // @A2A
  /**
   *Positions the file cursor to the first record meeting the specified search criteria
   *based on key.  The searchType indicates that the cursor should be
   *positioned to the record whose key first meets the search criteria when compared
   *to key.  The file must be open when invoking this method.
   *@param key The byte array that contains the byte values that make up the key with which to find the record.
   *The byte array key must contain the byte values from at least one key field.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param searchType Constant indicating the type of match required.  Valid values are:
   *

   *
KEY_EQ

   *First record whose key is equal to key.
   *
KEY_LT

   *First record whose key is less than key.
   *
KEY_LE

   *First record whose key is less than or equal to key.
   *
KEY_GT

   *First record whose key is greater than key.
   *
KEY_GE

   *First record whose key is greater than or equal to key.
   *
   *@param numberOfKeyFields The number of key fields contained in the byte array key.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public void positionCursor(byte[] key, int searchType, int numberOfKeyFields)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameters(key, numberOfKeyFields); //@C0A
    if (searchType < KEY_EQ || searchType > KEY_LE)
    {
      throw new ExtendedIllegalArgumentException("searchType", ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
    }
    if(longRecordNumber)//@RBA
      impl_.doIt("positionCursorLong", new Class[] { byte[].class, Integer.TYPE, Integer.TYPE }, new Object[] { key, Integer.valueOf(TYPE_TABLE[searchType]), Integer.valueOf(numberOfKeyFields) });
    else
      impl_.doIt("positionCursor", new Class[] { byte[].class, Integer.TYPE, Integer.TYPE }, new Object[] { key, Integer.valueOf(TYPE_TABLE[searchType]), Integer.valueOf(numberOfKeyFields) });
  }


  /**
   *Positions the file cursor to the first record after the record specified
   *by key.  The file must be open when invoking this method.
   *@param key The values which make up the key with which to find the record.
   *The key must contain at least one element.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public void positionCursorAfter(Object[] key)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameter(key); //@C0A
    if(longRecordNumber)//@RBA
      impl_.doIt("positionCursorAfterLong", new Class[] { Object[].class }, new Object[] { key });
    else
      impl_.doIt("positionCursorAfter", new Class[] { Object[].class }, new Object[] { key });
  }


  // @A2A
  /**
   *Positions the file cursor to the first record after the record specified
   *by key.  The file must be open when invoking this method.
   *@param key The byte array that contains the byte values which make up the key with which to find the record.
   *The byte array key must contain the byte values from at least one key field.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param numberOfKeyFields The number of key fields contained in the byte array key.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public void positionCursorAfter(byte[] key, int numberOfKeyFields)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameters(key, numberOfKeyFields); //@C0A
    if(longRecordNumber)//@RBA
      impl_.doIt("positionCursorAfterLong", new Class[] { byte[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(numberOfKeyFields) });
    else
    impl_.doIt("positionCursorAfter", new Class[] { byte[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(numberOfKeyFields) });
  }


  /**
   *Positions the file cursor to the first record before the record specified
   *by key.  The file must be open when invoking this method.
   *@param key The values which make up the key with which to find the record.
   *The key must contain at least one element.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public void positionCursorBefore(Object[] key)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameter(key); //@C0A
    if(longRecordNumber)//@RBA
      impl_.doIt("positionCursorBeforeLong", new Class[] { Object[].class }, new Object[] { key });
    else
      impl_.doIt("positionCursorBefore", new Class[] { Object[].class }, new Object[] { key });
  }


  // @A2A
  /**
   *Positions the file cursor to the first record before the record specified
   *by key.  The file must be open when invoking this method.
   *@param key The byte array that contains the byte values which make up the key with which to find the record.
   *The byte array key must contain the byte values from at least one key field.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param numberOfKeyFields The number of key fields contained in the byte array key.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public void positionCursorBefore(byte[] key, int numberOfKeyFields)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameters(key, numberOfKeyFields); //@C0A
    if(longRecordNumber)//@RBA
      impl_.doIt("positionCursorBeforeLong", new Class[] { byte[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(numberOfKeyFields) });
    else
      impl_.doIt("positionCursorBefore", new Class[] { byte[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(numberOfKeyFields) });
  }


  /**
   *Reads the first record with the specified key.  The file must be open when
   *invoking this method.
   *@param key The values that make up the key with which to find the record.
   *The key must contain at least one element.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record read(Object[] key)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    return read(key, KEY_EQ);
  }

 

  // @A2A
  /**
   *Reads the first record with the specified key.  The file must be open when
   *invoking this method.
   *@param key The byte array that contains the byte values that make up the key with which to find the record.
   *The byte array key must contain the byte values from at least one key field.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param numberOfKeyFields The number of key fields contained in the byte array key.
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record read(byte[] key, int numberOfKeyFields)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    return read(key, KEY_EQ, numberOfKeyFields);
  }



  /**
   *Reads the first record meeting the specified search criteria based on
   *key.  The searchType indicates that the record whose key first meets
   *the search criteria when compared to key should be returned.  The file must
   *be open when invoking this method.
   *@param key The values that make up the key with which to find the record.
   *The key must contain at least one element.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param searchType Constant indicating the type of match required.  Valid values are:
   *

   *
KEY_EQ

   *First record whose key is equal to key.
   *
KEY_LT

   *First record whose key is less than key.
   *
KEY_LE

   *First record whose key is less than or equal to key.
   *
KEY_GT

   *First record whose key is greater than key.
   *
KEY_GE

   *First record whose key is greater than or equal to key.
   *
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record read(Object[] key, int searchType)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameter(key); //@C0A
    if (searchType < KEY_EQ || searchType > KEY_LE)
    {
      throw new ExtendedIllegalArgumentException("searchType", ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
    }
    if(longRecordNumber)//@RBA
      return fillInRecord(impl_.doItRecord("readLong", new Class[] { Object[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(TYPE_TABLE[searchType]) })); //@D0C
    
    return fillInRecord(impl_.doItRecord("read", new Class[] { Object[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(TYPE_TABLE[searchType]) })); //@D0C
  }

  // @A2A
  /**
   *Reads the first record meeting the specified search criteria based on
   *key.  The searchType indicates that the record whose key first meets
   *the search criteria when compared to key should be returned.  The file must
   *be open when invoking this method.
   *@param key The byte array that contains the byte values that make up the key with which to find the record.
   *The byte array key must contain the byte values from at least one key field.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param searchType Constant indicating the type of match required.  Valid values are:
   *

   *
KEY_EQ

   *First record whose key is equal to key.
   *
KEY_LT

   *First record whose key is less than key.
   *
KEY_LE

   *First record whose key is less than or equal to key.
   *
KEY_GT

   *First record whose key is greater than key.
   *
KEY_GE

   *First record whose key is greater than or equal to key.
   *
   *@param numberOfKeyFields The number of key fields contained in the byte array key.
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record read(byte[] key, int searchType, int numberOfKeyFields)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameters(key, numberOfKeyFields); //@C0A
    if (searchType < KEY_EQ || searchType > KEY_LE)
    {
      throw new ExtendedIllegalArgumentException("searchType", ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
    }
    if(longRecordNumber)//@RBA
      return fillInRecord(impl_.doItRecord("readLong", new Class[] { byte[].class, Integer.TYPE, Integer.TYPE }, new Object[] { key, Integer.valueOf(TYPE_TABLE[searchType]), Integer.valueOf(numberOfKeyFields) })); //@D0C
    else
      return fillInRecord(impl_.doItRecord("read", new Class[] { byte[].class, Integer.TYPE, Integer.TYPE }, new Object[] { key, Integer.valueOf(TYPE_TABLE[searchType]), Integer.valueOf(numberOfKeyFields) })); //@D0C
  }


  /**
   *Reads the first record after the record with the specified key.  The file must
   *be open when invoking this method.
   *@param key The values that make up the key with which to find the record.
   *The key must contain at least one element.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record readAfter(Object[] key)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameter(key); //@C0A
    if(longRecordNumber)//@RBA
      return fillInRecord(impl_.doItRecord("readAfterLong", new Class[] { Object[].class }, new Object[] { key })); //@D0C
    else
      return fillInRecord(impl_.doItRecord("readAfter", new Class[] { Object[].class }, new Object[] { key })); //@D0C
  }


  // @A2A
  /**
   *Reads the first record after the record with the specified key.  The file must
   *be open when invoking this method.
   *@param key The byte array that contains the byte values that make up the key with which to find the record.
   *The byte array key must contain the byte values from at least one key field.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param numberOfKeyFields The number of key fields contained in the byte array key.
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record readAfter(byte[] key, int numberOfKeyFields)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameters(key, numberOfKeyFields); //@C0A
    if(longRecordNumber)//@RBA
      return fillInRecord(impl_.doItRecord("readAfterLong", new Class[] { byte[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(numberOfKeyFields) })); //@D0C
    else
      return fillInRecord(impl_.doItRecord("readAfter", new Class[] { byte[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(numberOfKeyFields) })); //@D0C
  }


  /**
   *Reads all the records in the file. The file must be closed when invoking this method.
   *The record format for the file must have been set prior to invoking this method.
   *@return The records read.  If no records are read, an array of size zero is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
   *@exception ServerStartupException If the host server cannot be started.
   *@exception UnknownHostException If the system cannot be located.
  **/
  public Record[] readAll()
    throws AS400Exception,
           AS400SecurityException,
           ConnectionDroppedException,
           InterruptedException,
           IOException,
           ServerStartupException,
           UnknownHostException
  {
    if (isOpen_)
    {
      throw new ExtendedIllegalStateException(ExtendedIllegalStateException.OBJECT_CAN_NOT_BE_OPEN);
    }
    if (recordFormat_ == null)
    {
      throw new ExtendedIllegalStateException("recordFormat", ExtendedIllegalStateException.PROPERTY_NOT_SET);
    }

    // Read all records.
    // Since readAll() now behaves under-the-covers like readNext(),
    // need to open the file. Also synchronize on this, because
    // the file isn't supposed to be open and this might mess up
    // other references to this object, which expect it to be closed.
    // See AS400FileImplRemote.readAll() for information regarding
    // changes in the under-the-covers behavior.
    chooseImpl();
    // Before we calculate, make sure the record format has had
    // its text objects initialized.
    recordFormat_.initializeTextObjects(system_); //@D0A

    // Use a calculated blocking factor, else use a large blocking factor
    int bf = 2048/(recordFormat_.getNewRecord().getRecordLength() + 16); //@D0M
    if (bf <= 1) bf = 100; //@D0M
    Record[] recs=null;
    if(longRecordNumber)//@RBA
      recs = impl_.doItRecordArray("readAllLong", new Class[] { String.class, Integer.TYPE }, new Object[] { "key", Integer.valueOf(bf) }); //@D0C
    else
      recs = impl_.doItRecordArray("readAll", new Class[] { String.class, Integer.TYPE }, new Object[] { "key", Integer.valueOf(bf) }); //@D0C
    //@D0A
    if (recs != null)
    {
      for (int i=0; ikey must contain at least one element.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record readBefore(Object[] key)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameter(key); //@C0A
    if(longRecordNumber)//@RBA
      return fillInRecord(impl_.doItRecord("readBeforeLong", new Class[] { Object[].class }, new Object[] { key })); //@D0C
    else
      return fillInRecord(impl_.doItRecord("readBefore", new Class[] { Object[].class }, new Object[] { key })); //@D0C
  }


  // @A2A
  /**
   *Reads the first record before the record with the specified key.  The file must
   *be open when invoking this method.
   *@param key The byte array that contains the byte values that make up the key with which to find the record.
   *The byte array key must contain the byte values from at least one key field.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param numberOfKeyFields The number of key fields contained in the byte array key.
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record readBefore(byte[] key, int numberOfKeyFields)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameters(key, numberOfKeyFields); //@C0A
    if(longRecordNumber)//@RBA
      return fillInRecord(impl_.doItRecord("readBeforeLong", new Class[] { byte[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(numberOfKeyFields) })); //@D0C
    else
      return fillInRecord(impl_.doItRecord("readBefore", new Class[] { byte[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(numberOfKeyFields) })); //@D0C
  }


  /**
   *Reads the next record whose key matches the full key of the current record.
   *The file must be open when invoking this method.  The file must be
   *positioned on an active record when invoking this method.
   *
Note: If the application has previously called setReadNoUpdate(false), 
   *then this method issues a request to the server which locks the record
   *returned to the client.  The key comparison occurs on the client side.
   *Therefore, even though the record may not match the key (and null
   *is returned by readNextEqual), the server side will lock the most 
   *recent record which may have been read from the file.
   *A subsequent call to any of the positionCursor() methods will unlock 
   *the last (i.e. most recent) record locked.  In addition, the close() 
   *method will also unlock the last (i.e. most recent) record locked.
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record readNextEqual()
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    // Verify object state
    checkOpen();
    if(longRecordNumber)//@RBA
      return fillInRecord(impl_.doItRecord("readNextEqualLong", new Class[0], new Object[0])); //@D0C
    else
      return fillInRecord(impl_.doItRecord("readNextEqual", new Class[0], new Object[0])); //@D0C
  }


  /**
   *Reads the next record whose key matches the specified key.  The search does
   *not include the current record.  The key may be a partial key.
   *The file must be open when invoking this method.
   *
Note: If the application has previously called setReadNoUpdate(false), 
   *then this method issues a request to the server which locks the record
   *returned to the client.  The key comparison occurs on the client side.
   *Therefore, even though the record may not match the key (and null
   *is returned by readNextEqual), the server side will lock the most 
   *recent record which may have been read from the file.
   *A subsequent call to any of the positionCursor() methods will unlock 
   *the last (i.e. most recent) record locked.  In addition, the close() 
   *method will also unlock the last (i.e. most recent) record locked.
   * @param key 
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record readNextEqual(Object[] key)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameter(key); //@C0A
    if(longRecordNumber)//@RBA
      return fillInRecord(impl_.doItRecord("readNextEqualLong", new Class[] { Object[].class }, new Object[] { key })); //@D0C
    return fillInRecord(impl_.doItRecord("readNextEqual", new Class[] { Object[].class }, new Object[] { key })); //@D0C
  }


  // @A2A
  /**
   *Reads the next record whose key matches the specified key.  The search does
   *not include the current record.  The key may be a partial key.
   *The file must be open when invoking this method.
   *@param key The byte array that contains the byte values that make up the key with which to find the record.
   *The byte array key must contain the byte values from at least one key field.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *
Note: If the application has previously called setReadNoUpdate(false), 
   *then this method issues a request to the server which locks the record
   *returned to the client.  The key comparison occurs on the client side.
   *Therefore, even though the record may not match the key (and null
   *is returned by readNextEqual), the server side will lock the most 
   *recent record which may have been read from the file.
   *A subsequent call to any of the positionCursor() methods will unlock 
   *the last (i.e. most recent) record locked.  In addition, the close() 
   *method will also unlock the last (i.e. most recent) record locked.
   *@param numberOfKeyFields The number of key fields contained in the byte array key.
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record readNextEqual(byte[] key, int numberOfKeyFields)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameters(key, numberOfKeyFields); //@C0A
    if(longRecordNumber)//@RBA
      return fillInRecord(impl_.doItRecord("readNextEqualLong", new Class[] { byte[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(numberOfKeyFields) })); //@D0C
    else
      return fillInRecord(impl_.doItRecord("readNextEqual", new Class[] { byte[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(numberOfKeyFields) })); //@D0C
  }


  /**
   *Overrides the ObjectInputStream.readObject() method in order to return any
   *transient parts of the object to there properly initialized state.  We also
   *generate a declared file name for the object.  I.e we in effect
   *call the null constructor.  By calling ObjectInputStream.defaultReadObject()
   *we restore the state of any non-static and non-transient variables.  We
   *then continue on to restore the state (as necessary) of the remaining variables.
   *@param in The input stream from which to deserialize the object.

   *@exception ClassNotFoundException If the class being deserialized is not found.
   *@exception IOException If an error occurs during deserialization.
  **/
  private void readObject(java.io.ObjectInputStream in)
    throws ClassNotFoundException,
           IOException
  {
    in.defaultReadObject();
    initializeTransient(); //@C0C
  }


  /**
   *Reads the previous record whose key matches the key of the current record.
   * The file must be open when invoking this method.  The file must be
   *positioned on an active record when invoking this method.
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record readPreviousEqual()
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    // Verify object state
    checkOpen();
    if(longRecordNumber)//@RBA
      return fillInRecord(impl_.doItRecord("readPreviousEqualLong", new Class[0], new Object[0])); //@D0C
    else
      return fillInRecord(impl_.doItRecord("readPreviousEqual", new Class[0], new Object[0])); //@D0C
  }


  /**
   *Reads the previous record whose key matches the specified key.  The search does
   *not include the current record.  The key may be a partial key.
   *The file must be open when invoking this method.
   * @param key 
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record readPreviousEqual(Object[] key)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameter(key); //@C0A
    if(longRecordNumber)//@RBA
      return fillInRecord(impl_.doItRecord("readPreviousEqualLong", new Class[] { Object[].class }, new Object[] { key })); //@D0C
    else
      return fillInRecord(impl_.doItRecord("readPreviousEqual", new Class[] { Object[].class }, new Object[] { key })); //@D0C
  }


  // @A2A
  /**
   *Reads the previous record whose key matches the specified key.  The search does
   *not include the current record.  The key may be a partial key.
   *The file must be open when invoking this method.
   *@param key The byte array that contains the byte values that make up the key with which to find the record.
   *The byte array key must contain the byte values from at least one key field.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param numberOfKeyFields The number of key fields contained in the byte array key.
   *@return The record read.  If the record is not found, null is returned.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public Record readPreviousEqual(byte[] key, int numberOfKeyFields)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    checkParameters(key, numberOfKeyFields); //@C0A
    if(longRecordNumber)//@RBA
      return fillInRecord(impl_.doItRecord("readPreviousEqualLong", new Class[] { byte[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(numberOfKeyFields) })); //@D0C
    else
      return fillInRecord(impl_.doItRecord("readPreviousEqual", new Class[] { byte[].class, Integer.TYPE }, new Object[] { key, Integer.valueOf(numberOfKeyFields) })); //@D0C
  }


  /**
   *Updates the record specified by key.  The file must be open when invoking
   *this method.
   *@param key The values that make up the key with which to find the record.
   *The key must contain at least one element.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param record The record with which to update the existing record.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public void update(Object[] key, Record record)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    // Verify parameters
    if (record == null)
    {
      throw new NullPointerException("record");
    }
    positionCursor(key);
    update(record);
  }


  // @A2A
  /**
   *Updates the record specified by key.  The file must be open when invoking
   *this method.
   *@param key The byte array that contains the byte values that make up the key with which to find the record.
   *The byte array key must contain the byte values from at least one key field.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param record The record with which to update the existing record.
   *@param numberOfKeyFields The number of key fields contained in the byte array key.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public void update(byte[] key, Record record, int numberOfKeyFields)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    // Verify parameters
    if (record == null)
    {
      throw new NullPointerException("record");
    }

    positionCursor(key, numberOfKeyFields);
    update(record);
  }



  /**
   *Updates the first record meeting the specified search criteria based on
   *key.  The searchType indicates that the record whose key first meets
   *the search criteria when compared to key should be returned.  The file
   *must be open when invoking this method.
   *@param key The values that make up the key with which to find the record.
   *The key must contain at least one element.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param record The record with which to update the existing record.
   *@param searchType Constant indicating the type of match required.  Valid values are:
   *

   *
KEY_EQ

   *First record whose key is equal to key.
   *
KEY_LT

   *First record whose key is less than key.
   *
KEY_LE

   *First record whose key is less than or equal to key.
   *
KEY_GT

   *First record whose key is greater than key.
   *
KEY_GE

   *First record whose key is greater than or equal to key.
   *
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public void update(Object[] key, Record record, int searchType)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    // Verify parameters
    if (record == null)
    {
      throw new NullPointerException("record");
    }
    positionCursor(key, searchType);
    update(record);
  }



  // @A2A
  /**
   *Updates the first record meeting the specified search criteria based on
   *key.  The searchType indicates that the record whose key first meets
   *the search criteria when compared to key should be returned.  The file
   *must be open when invoking this method.
   *@param key The byte array that contains the byte values that make up the key with which to find the record.
   *The byte array key must contain the byte values from at least one key field.  The types and order of
   *the elements that make up key must match the type and order of the
   *key fields in the record format for this object.  Null values for key fields
   *are not supported.
   *@param record The record with which to update the existing record.
   *@param searchType Constant indicating the type of match required.  Valid values are:
   *

   *
KEY_EQ

   *First record whose key is equal to key.
   *
KEY_LT

   *First record whose key is less than key.
   *
KEY_LE

   *First record whose key is less than or equal to key.
   *
KEY_GT

   *First record whose key is greater than key.
   *
KEY_GE

   *First record whose key is greater than or equal to key.
   *
   *@param numberOfKeyFields The number of key fields contained in the byte array key.
   *@exception AS400Exception If the system returns an error message.
   *@exception AS400SecurityException If a security or authority error occurs.
   *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
   *@exception InterruptedException If this thread is interrupted.
   *@exception IOException If an error occurs while communicating with the system.
  **/
  public void update(byte[] key, Record record, int searchType, int numberOfKeyFields)
    throws AS400Exception,
           AS400SecurityException,
           InterruptedException,
           IOException
  {
    // Verify parameters
    if (record == null)
    {
      throw new NullPointerException("record");
    }
    positionCursor(key, searchType, numberOfKeyFields);
    update(record);
  }


  //@C0A
  /**
  * Make sure the file is open and the key is valid.
  **/
  private void checkParameter(Object[] key)
  {
    if (key == null)
    {
      throw new NullPointerException("key");
    }
    if (key.length == 0)
    {
      throw new ExtendedIllegalArgumentException("key", ExtendedIllegalArgumentException.LENGTH_NOT_VALID);
    }
    if (key.length > recordFormat_.getNumberOfKeyFields())
    {
      throw new ExtendedIllegalArgumentException("key", ExtendedIllegalArgumentException.LENGTH_NOT_VALID);
    }
    for (int i=0; i recordFormat_.getNumberOfKeyFields()))
    {
      throw new ExtendedIllegalArgumentException("numberOfKeyFields",
         ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
    }
    checkOpen();
  }
}