my $dbobj = new Bio::EnsEMBL::Pipeline::DBSQL::DBAdaptor;
    $dbobj->do_funky_db_stuff;

   my ($obj) = @_;

   if( $obj->{'_db_handle'} ) {
       $obj->{'_db_handle'}->disconnect;
       $obj->{'_db_handle'} = undef;
   }

    my ($self,$arg) = @_;

    if (defined($arg)) {
	$self->{_db_handle} = $arg;
    }
    return $self->{_db_handle};

  my ($self) = @_;

  my $pairs = $self->SUPER::get_available_adaptors();

  $pairs->{'Analysis'}                  = 'Bio::EnsEMBL::Pipeline::DBSQL::AnalysisAdaptor';
  $pairs->{'Job'}                       = 'Bio::EnsEMBL::Pipeline::DBSQL::JobAdaptor';
  $pairs->{'PmatchFeature'}             = 'Bio::EnsEMBL::Pipeline::DBSQL::PmatchFeatureAdaptor';
  $pairs->{'Rule'}                      = 'Bio::EnsEMBL::Pipeline::DBSQL::RuleAdaptor';
  $pairs->{'StateInfoContainer'}        = 'Bio::EnsEMBL::Pipeline::DBSQL::StateInfoContainer';
  $pairs->{'CompressedDnaAlignFeature'} = 'Bio::EnsEMBL::Pipeline::DBSQL::CompressedDnaAlignFeatureAdaptor';

  return $pairs;

    my ($self, $key, $value) = @_;
    $self->throw("No key to get supplied") unless $key;
    my $sth = $self->prepare(qq{
        SELECT meta_value
        FROM   meta
        WHERE  meta_key = ? LIMIT 1
    }); # ONLY RETRIEVES FIRST ENTRY,
    # SHOULD THERE BE A UNIQUE KEY ON meta_key??
    $sth->execute($key);
    my $row = $sth->fetchrow_arrayref();
    $value = $row->[0] if $row;
    $sth->finish();
    return $value;

    my ($self,$string) = @_;
    if($string){
        my $hash = { eval $string };
        $@ ? die "error evaluating $string" : return $hash || {};
    }
    return {};
}
1;

    my ($self, $hash) = @_;
    my $dbh = $self->_db_handle();
    return join(",\n", map{ $dbh->quote($_)." => ".$dbh->quote($hash->{$_}) } keys(%$hash));

    my ($self, $string) = @_;
    my $lock = 'pipeline.lock';

    return $string ? $self->store_meta_key_value($lock, $string) : $self->get_meta_value_by_key($lock);

    my ($self) = @_;
    $self->remove_meta_key('pipeline.lock');

  my ($self, @args) = @_;

  $self->dbc->prepare(@args);

    my ($self, $key) = @_;
    $self->throw("No key to remove supplied") unless $key;
    my $sth = $self->prepare(qq{
	DELETE
	FROM   meta
	WHERE  meta_key = ?
    });
    $sth->execute($key);
    $sth->finish;
    return undef;

    my ($self, $key, $value) = @_;
    $self->throw("No key|value to insert supplied") unless $key && $value;
    my $sth = $self->prepare(qq{
        INSERT INTO meta (meta_key, meta_value) VALUES (?, ?)
    });
    $sth->execute($key, $value);
    $sth->finish();
    return undef;

 Title   : get_JobAdaptor
 Usage   : $db->get_JobAdaptor
 Function: The Adaptor for Job objects in this db
 Example :
 Returns : Bio::EnsEMBL::Pipeline::DBSQL::JobAdaptor
 Args    : nothing

 Title   : get_RuleAdaptor
 Usage   : $db->get_RuleAdaptor
 Function: The Adaptor for Rule objects in this db
 Example :
 Returns : Bio::EnsEMBL::Pipeline::DBSQL::RuleAdaptor
 Args    : nothing

 Title   : get_StateInfoContainer
 Usage   : $db->get_StateInfoContainer
 Function:
 Example :
 Returns : Bio::EnsEMBL::Pipeline::DBSQL::StateInfoContainer
 Args    : nothing

 Access to the meta table of the schema including
 
 pipeline_lock             - write a lock to the meta table
 pipeline_unlock           - remove the lock
 get_meta_value_by_key     - retrieve value by key
 store_meta_key_value      - write key, value pair
 remove_meta_key           - delete by key name
 make_meta_value_from_hash - flatten a hash to a string (uses dbi->quote to escape)
 make_hash_from_meta_value - returns a hash from a previously flattened string
 
    $lock_string = 'whatever to lock';
    $dbA->pipeline_lock($lock_string);
    my $lock_string = $dbA->pipeline_lock();
    
    $dbA->pipeline_unlock();
 
    $dbA->store_meta_key_value('my_key', 'the value');

    my $value = $dbA->get_meta_value_by_key('my_key');
    
    $dbA->remove_meta_key('my_key');

    my %hash = ('-host' => 'pfam', '-port' => '3306'...);
    my $flat = $dbA->make_meta_value_from_hash(\%hash);
    my %retrieved = %{$dbA->make_hash_from_meta_value($flat)};