Help-Site Computer Manuals
  Algorithms & Data Structures   Programming Languages   Revision Control
  Cameras   Computers   Displays   Keyboards & Mice   Motherboards   Networking   Printers & Scanners   Storage
  Windows   Linux & Unix   Mac

Methods for processing data from the GeneX DB table: Contact

Bio::Genex::Contact - Methods for processing data from the GeneX DB table: Contact


Bio::Genex::Contact - Methods for processing data from the GeneX DB table: Contact


  use Bio::Genex::Contact;

  # instantiating an instance

  my $Contact = Bio::Genex::Contact->new(id=>47);

  # retrieve data from the DB for all columns


  # creating an instance, without pre-fetching all columns

  my $Contact = new Bio::Genex::Contact(id=>47);

  # creating an instance with pre-fetched data

  my $Contact = new Bio::Genex::Contact(id=>47, 'fetch_all'=>1);

  # retrieving multiple instances via primary keys

  my @objects = Bio::Genex::Contact->get_objects(23,57,98)

  # retrieving all instances from a table

  my @objects = Bio::Genex::Contact->get_all_objects();

  # retrieving the primary key for an object, generically

  my $primary_key = $Contact->id();

  # or specifically

  my $con_pk_val = $Contact->con_pk();

  # retreving other DB column attributes

  my $type_val = $Contact->type();


  my $organization_val = $Contact->organization();


  my $contact_person_val = $Contact->contact_person();


  my $contact_person_phone_val = $Contact->contact_person_phone();


  my $contact_person_email_val = $Contact->contact_person_email();


  my $org_phone_val = $Contact->org_phone();


  my $org_email_val = $Contact->org_email();


  my $org_mail_address_val = $Contact->org_mail_address();


  my $org_toll_free_phone_val = $Contact->org_toll_free_phone();


  my $org_fax_val = $Contact->org_fax();


  my $url_val = $Contact->url();


  my $last_updated_val = $Contact->last_updated();



Each Genex class has a one to one correspondence with a GeneX DB table of the same name (i.e. the corresponding table for Bio::Genex::Contact is Contact).

Most applications will first create an instance of Bio::Genex::Contact and then fetch the data for the object from the DB by invoking fetch(). However, in cases where you may only be accessing a single value from an object the built-in delayed fetch mechanism can be used. All objects are created without pre-fetching any data from the DB. Whenever an attribute of the object is accessed via a getter method, the data for that attribute will be fetched from the DB if it has not already been. Delayed fetching happens transparently without the user needing to enable or disable any features.

Since data is not be fetched from the DB until it is accessed by the calling application, it could presumably save a lot of access time for large complicated objects when only a few attribute values are needed.


There are three different types of attributes which instances of Bio::Genex::Contact can access: raw foreign key attributes, Obect-Oriented foreign key attributes, and simple column attributes.

Raw Foreign Keys Attributes
Object Oriented Foreign Key Attributes
This mode presents foreign key attributes in a special way, with all non-foreign key attributes presented normally. Foreign keys are first retrieved from the DB, and then objects of the appropriate classes are created and stored in slots. This mode is useful for applications that want to process information from the DB because it automates looking up information.

Specifying the 'recursive_fetch' parameter when calling new(), modifies the behavior of this mode. The value given specifies the number of levels deep that fetch will be invoked on sub-objects created.

Simple Column Attributes


Class Bio::Genex::Contact defines the following utility variables for assisting programmers to access the Contact table.

If defined, $LIMIT will set a limit on any select statements that can return multiple instances of this class (for example get_objects() or any call to a ONE_TO_MANY or LOOKUP_TABLE foreign key accessor method).

This variable controls whether the class will cache any objects created in calls to new(). Objects are cached by primary key. The caching is very simple, and no effort is made to track whether different invocations of new() are being made for an object with the same primary key value, but with different options set. If you desire to reinstantiate an object with a different set of parameters, you would need to undefine $USE_CACHE first.

WARNING: variables other than those listed here are for internal use only and are subject to change without notice. Use them at your own risk.


It is possible to retrieve only the subset of attributes one chooses by simply creating an object instance and then calling the appropriate getter function. The object will automatically fetch the value from the DB when requested. This can potentially save time for large complicated objects. This triggers a separate DB query for each attribute that is accessed, whereas calling fetch() will retrieve all fields of the object with a single query.

For example:

  my $Contact = Bio::Genex::Contact->new(id=>47);

  my $val = $Contact->con_pk();

The attribute's value is then cached in the object so any further calls to that attribute's getter method do not trigger a DB query.

NOTE: Methods may still return undef if their value in the DB is NULL.


The following methods can all be called without first having an instance of the class via the Bio::Genex::Contact->methodname() syntax.

new() accepts the following arguments:
Numeric or string value. The value of the primary key for looking up the object in the DB.

Used by generic functions to determine if a specified class is a linking table class. For Bio::Genex::Contact it returns 0, since it is not a linking table class.

This method returns the name of the column which is used as the primary key for this DB table. This method only exists for non-linking table classes, and for Bio::Genex::Contact it returns the value 'con_pk';

Returns the name of the DB table represented by this class. For Bio::Genex::Contact it returns 'Contact';

This method returns a hashref that translates DB column names into human readable format.

This method returns a hashref that is a reverse lookup table to translate the human readable version of a DB column name back into the column_name. This is useful for preparing table output in CGI scripts:

    %column2name = %{$class->column2name()};

    if (exists $column2name{$_}) {




    # now that we've translated the names, we sort them

    @column_copy = sort @column_copy;


    # make a header element. 


This method returns a hashref that holds all the foreign key entries for the Contact table.

This method returns an array ref which holds the names of all the columns in table Contact.

    # first retrieve the data from the DB

    $object = $full_module_name->new(id=>$id);


    # now extract the data from the object

    foreach (@{$class->column_names}) {

    # we use this to temporarily relax the strict pragma

    # to use symbolic references

      no strict 'refs';

      $tmp_values{$_} = $object->$_;

    # back to our regularily scheduled strictness


This method inserts the data for the object into the database specified by the DB handle $dbh. To use this method, create a blank object with new(), set the attributes that you want, and then call insert_db().

  my $dbh = Bio::Genex::current_connection(USER=>$SU_USERNAME,


  my Contact = Bio::Genex::Contact->new();



NOTE: You must log into the DB with a user/password that has INSERT priveleges in the DB, otherwise you will get a DBI error.

WARNING: fetch() will not be called, so if you are using this method to insert a copy of an existing DB object, then it is up to you to call fetch(), otherwise, only the attributes that are currently set in the object will be inserted.

This method update the data for an object already in the database specified by the DB handle $dbh. To use this method, fetch an object from the DB, change the attributes that you want, and then call update_db().

  my $dbh = Bio::Genex::current_connection(USER=>$SU_USERNAME,


  my Contact = Bio::Genex::Contact->new(id=>43);



NOTE: You must log into the DB with a user/password that has INSERT priveleges in the DB, otherwise you will get a DBI error.

NOTE: Any modification of the primary key value will be discarded ('con_pk' for module Bio::Genex::Contact).

This method is used to retrieve multiple instances of class Bio::Genex::Contact simultaneously. There are three different ways to invoke this method.

By passing in an @id_list, get_objects() uses each element of the list as a primary key for the Contact table and returns a single instance for each entry.

WARNING: Passing incorrect id values to get_objects() will cause a warning from Bio::Genex::Contact::initialize(). Objects will be created for other correct id values in the list.

get_all_objects() returns an instance for every entry in the table.

By passing an anonymous hash reference that contains the 'column' and 'name' keys, the method will return all objects from the DB whose that have the specified value in the specified column.

NOTE: All objects must have the 'id' parameter set before attempting to use fetch() or any of the objects getter functions.


The following methods can only be called by first having valid instance of class Bio::Genex::Contact.

This method triggers a DB query to retrieve ALL columns from the DB associated with this object.

WARNING: methods other than those listed here are for internal use only and are subject to change without notice. Use them at your own risk.


These are the setter and getter methods for attributes in class Bio::Genex::Contact.

NOTE: To use the getter methods, you may either invoke the fetch() method to retrieve all the values for an object, or else rely on delayed fetching to retrieve the attributes as needed.

id() is a special attribute method that is common to all the Genex classes. This method returns the primary key of the given instance (and for class Bio::Genex::Contact it is synonomous with the con_pk()method). The id() method can be useful in writing generic methods because it avoids having to know the name of the primary key column.

This is the primary key attribute for Bio::Genex::Contact. It has no setter method.

$value = type();
Methods for the type attribute.

$value = organization();
Methods for the organization attribute.

$value = contact_person();
Methods for the contact_person attribute.

$value = contact_person_phone();
Methods for the contact_person_phone attribute.

$value = contact_person_email();
Methods for the contact_person_email attribute.

$value = org_phone();
Methods for the org_phone attribute.

$value = org_email();
Methods for the org_email attribute.

$value = org_mail_address();
Methods for the org_mail_address attribute.

$value = org_toll_free_phone();
Methods for the org_toll_free_phone attribute.

$value = org_fax();
Methods for the org_fax attribute.

$value = url();
Methods for the url attribute.

$value = last_updated();
Methods for the last_updated attribute.

WARNING: methods other than those listed here are for internal use only and are subject to change without notice. Use them at your own risk.


These classes are automatically generated by the script. Each class is a subclass of the Class::ObjectTemplate::DB class (which is in turn a subclass of Class::ObjectTemplate written by Sriram Srinivasan, described in Advanced Perl Programming, and modified by Jason Stewart). ObjectTemplate implements automatic class creation in perl (there exist other options such as Class::Struct and Class::MethodMaker by Damian Conway) via an attributes() method call at class creation time.


Please send bug reports to


on Mon Feb 5 21:23:57 2001 by /home/jasons/work/GeneX-Server/Genex/scripts/ --dir=/home/jasons/work/GeneX-Server/Genex --target=Contact


Jason E. Stewart (