use Bio::EnsEMBL::Registry;

  Bio::EnsEMBL::Registry->load_registry_from_db(
    -host => 'ensembldb.ensembl.org',
    -user => 'anonymous'
  );

  $analysis_adaptor =
    Bio::EnsEMBL::Registry->get_adaptor( "human", "core", "analysis" );

  my $analysis = $analysis_adaptor->fetch_by_logic_name('genscan');

  Module to encapsulate all db access for persistent class Analysis.
  There should be just one per application and database connection.

  my $self = shift;
  my $rowHash = shift;

  my $web_data = $rowHash->{web_data} ? $self->get_dumped_data($rowHash->{web_data}) : '';
  my $analysis = Bio::EnsEMBL::Analysis->new(
      -id              => $rowHash->{analysis_id},
      -adaptor         => $self,
      -db              => $rowHash->{db},
      -db_file         => $rowHash->{db_file},
      -db_version      => $rowHash->{db_version},
      -program         => $rowHash->{program},
      -program_version => $rowHash->{program_version},
      -program_file    => $rowHash->{program_file},
      -gff_source      => $rowHash->{gff_source},
      -gff_feature     => $rowHash->{gff_feature},
      -module          => $rowHash->{module},
      -module_version  => $rowHash->{module_version},
      -parameters      => $rowHash->{parameters},
      -created         => $rowHash->{created},
      -logic_name      => $rowHash->{logic_name},
      -description     => $rowHash->{description},
      -display_label   => $rowHash->{display_label},
      -displayable     => $rowHash->{displayable},
					     -web_data        => $web_data,
    );

  return $analysis;
}



1;

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

  if(!ref($anal) || !$anal->isa("Bio::EnsEMBL::Analysis")) {
    throw("Object is not a Bio::EnsEMBL::Analysis");
  }

  #if this analysis is stored in this db already return its dbID
  if($anal->is_stored($self->db())) {
    return $anal->dbID();
  }

  #this analysis object is not stored but one exactly like it may have been
  foreach my $cacheId (keys %{$self->{_cache}}) {
    if ($self->{_cache}->{$cacheId}->compare($anal) >= 0) {
      # $anal->dbID( $cacheId );
      # $anal->adaptor( $self );
      return $cacheId;
    }
  }

  #no analysis like this one exists in the database
  return undef;

  # Can't think of a way to do this programatically, so hard-coded
  return qw(
            AffyFeature
            DensityFeature
            DnaAlignFeature
            Gene
            PredictionTranscript
            MarkerFeature
            OligoFeature
            ProteinAlignFeature
            ProteinFeature
            QtlFeature
            RepeatFeature
            SimpleFeature
            );

  my $self = shift;
  my ( $analysis, $dbID );
  my $rowHashRef;

  $self->{_cache} = {};
  $self->{_logic_name_cache} = {};

  my $sth = $self->prepare( q  {
    SELECT analysis.analysis_id, logic_name,
           program, program_version, program_file,
           db, db_version, db_file,
           module, module_version,
           gff_source, gff_feature,
           created, parameters, description, display_label, displayable, web_data
    FROM   analysis
    LEFT JOIN analysis_description
    ON analysis.analysis_id = analysis_description.analysis_id } );
  $sth->execute;

  while( $rowHashRef = $sth->fetchrow_hashref ) {
    my $analysis = $self->_objFromHashref( $rowHashRef  );

    $self->{_cache}->{$analysis->dbID}                    = $analysis;
    $self->{_logic_name_cache}->{lc($analysis->logic_name())} = $analysis;
  }

  my @ana = values %{$self->{_cache}};

  return\@ ana;

  my $self = shift;
  my $feat_class = shift || throw( "Need a feature type, e.g. SimpleFeature" );
 
  my @feature_classes = $self->feature_classes; # List of all feature classes
  my %feat_table_map;
  foreach my $class( @feature_classes ){
    # Map e.g. DnaAlignFeature to dna_align_feature
    my $table = join( "_", map lc, ( $class =~ /([A-Z][a-z]+)/g ) );
    $feat_table_map{$class} = $table;
  }
  $feat_table_map{DensityFeature}='density_type'; # analysis_id in diff table
  my $feat_table = $feat_table_map{$feat_class} || 
      ( warning( "No feature type corresponding to $feat_class" ) &&
        return [] );

  my $sql_t = qq||
SELECT DISTINCT analysis_id FROM %s |;
  
  my $sql = sprintf( $sql_t, $feat_table );
  my $sth = $self->prepare( $sql );
  my $rv  = $sth->execute();
  my $res = $sth->fetchall_arrayref;
  my @analyses;
  foreach my $r( @{$res} ){
    my $analysis = $self->fetch_by_dbID($r->[0]) 
        || throw( "analysis_id $r->[0] from $feat_table table "
                  . "is not in the analysis table!" );
    push @analyses, $analysis;
  }
  return [@analyses];

  my $self = shift;
  my $id = shift;

  if( defined $self->{_cache}->{$id} ) {
    return $self->{_cache}->{$id};
  }

  my $query = q{
    SELECT analysis.analysis_id, logic_name,
           program, program_version, program_file,
           db, db_version, db_file,
           module, module_version,
           gff_source, gff_feature,
           created, parameters, description, display_label, displayable, web_data
    FROM   analysis
    LEFT JOIN analysis_description
    ON analysis.analysis_id = analysis_description.analysis_id
    WHERE  analysis.analysis_id = ? };

  my $sth = $self->prepare($query);
  $sth->bind_param(1,$id,SQL_INTEGER);
  $sth->execute();
  my $rowHashRef = $sth->fetchrow_hashref;
  if( ! defined $rowHashRef ) {
    return undef;
  }

  my $anal = $self->_objFromHashref( $rowHashRef );
  $self->{_cache}->{$anal->dbID} = $anal;
  $self->{_logic_name_cache}->{lc($anal->logic_name())} = $anal;
  return $anal;

  my $self = shift;
  my $logic_name = shift;
  my $analysis;
  my $rowHash;

  #check the cache for the logic name
  if(defined $self->{_logic_name_cache}{lc($logic_name)}) {
    return $self->{_logic_name_cache}{lc($logic_name)};
  }

  my $sth = $self->prepare( "
    SELECT analysis.analysis_id, logic_name,
           program, program_version, program_file,
           db, db_version, db_file,
           module, module_version,
           gff_source, gff_feature,
           created, parameters, description, display_label, displayable, web_data
    FROM   analysis
    LEFT JOIN analysis_description
    ON analysis.analysis_id = analysis_description.analysis_id
    WHERE  logic_name = ?" );

  $sth->bind_param(1,$logic_name,SQL_VARCHAR);
  $sth->execute();
  my $rowHashRef;
  $rowHashRef = $sth->fetchrow_hashref;

  unless(defined $rowHashRef) {
    return undef;
  }

  $analysis = $self->_objFromHashref( $rowHashRef );

  #place the analysis in the caches, cross referenced by dbID and logic_name
  $self->{_cache}->{$analysis->dbID()} = $analysis;
  $self->{_logic_name_cache}->{lc($logic_name)} = $analysis;

  return $analysis;

  my ($class, $db) = @_;

  my $self = $class->SUPER::new($db);

  #load and cache all of the Analysis objects
  $self->fetch_all;

  return $self;

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

  if (!defined $analysis || !ref $analysis) {
    throw("called remove on AnalysisAdaptor with a [$analysis]");
  }

  if(!$analysis->is_stored($self->db())) {
    return undef;
  }

  my $sth = $self->prepare("DELETE FROM analysis WHERE analysis_id = ?");
  $sth->bind_param(1,$analysis->dbID,SQL_INTEGER);
  $sth->execute();

  $sth = $self->prepare("DELETE FROM analysis_description WHERE analysis_id = ?");
  $sth->execute($analysis->dbID());

  # remove this analysis from the cache
  delete $self->{'_cache'}->{$analysis->dbID()};
  delete $self->{'_logic_name_cache'}->{lc($analysis->logic_name)};


  # unset the adaptor and dbID
  $analysis->dbID(undef);
  $analysis->adaptor(undef);

  return;

  my $self = shift;
  my $analysis = shift;

  if(!ref($analysis) || !$analysis->isa('Bio::EnsEMBL::Analysis')) {
    throw("Bio::EnsEMBL::Analysis argument expected.");
  }

  if($analysis->is_stored($self->db())) {
    return $analysis->dbID();
  }

  if(!$analysis->logic_name()) {
    throw("Analysis cannot be stored without a valid logic_name");
  }
    

  my $rows_inserted = 0;
  my $sth;

  if($analysis->created ) {

    # we use insert IGNORE so that this method can be used in a multi-process
    # environment.  If another process has already written this record
    # then there will not be a problem

    $sth = $self->prepare( q{
      INSERT IGNORE INTO analysis
      SET created = ?,
          logic_name = ?,
	        db = ?,
	        db_version = ?,
          db_file = ?,
          program = ?,
          program_version = ?,
          program_file = ?,
	        parameters = ?,
          module = ?,
          module_version = ?,
          gff_source = ?,
          gff_feature = ?

			    } );
    $sth->bind_param(1,$analysis->created,SQL_DATETIME);
    $sth->bind_param(2,$analysis->logic_name,SQL_VARCHAR);
    $sth->bind_param(3,$analysis->db,SQL_VARCHAR);
    $sth->bind_param(4,$analysis->db_version,SQL_VARCHAR);
    $sth->bind_param(5,$analysis->db_file,SQL_VARCHAR);
    $sth->bind_param(6,$analysis->program,SQL_VARCHAR);
    $sth->bind_param(7,$analysis->program_version,SQL_VARCHAR);
    $sth->bind_param(8,$analysis->program_file,SQL_VARCHAR);
    $sth->bind_param(9,$analysis->parameters,SQL_VARCHAR);
    $sth->bind_param(10,$analysis->module,SQL_VARCHAR);
    $sth->bind_param(11,$analysis->module_version,SQL_VARCHAR);
    $sth->bind_param(12,$analysis->gff_source,SQL_VARCHAR);
    $sth->bind_param(13,$analysis->gff_feature,SQL_VARCHAR);
    $rows_inserted = $sth->execute();

  } else {
    $sth = $self->prepare( q{
      INSERT IGNORE INTO analysis
      SET created = now(),
          logic_name = ?,
          db = ?,
          db_version = ?,
          db_file = ?,
          program = ?,
          program_version = ?,
          program_file = ?,
	        parameters = ?,
          module = ?,
          module_version = ?,
          gff_source = ?,
          gff_feature = ?
	 } );
    
    $sth->bind_param(1,$analysis->logic_name,SQL_VARCHAR);
    $sth->bind_param(2,$analysis->db,SQL_VARCHAR);
    $sth->bind_param(3,$analysis->db_version,SQL_VARCHAR);
    $sth->bind_param(4,$analysis->db_file,SQL_VARCHAR);
    $sth->bind_param(5,$analysis->program,SQL_VARCHAR);
    $sth->bind_param(6,$analysis->program_version,SQL_VARCHAR);
    $sth->bind_param(7,$analysis->program_file,SQL_VARCHAR);
    $sth->bind_param(8,$analysis->parameters,SQL_VARCHAR);
    $sth->bind_param(9,$analysis->module,SQL_VARCHAR);
    $sth->bind_param(10,$analysis->module_version,SQL_VARCHAR);
    $sth->bind_param(11,$analysis->gff_source,SQL_VARCHAR);
    $sth->bind_param(12,$analysis->gff_feature,SQL_VARCHAR);

    $rows_inserted = $sth->execute();
  }

  my $dbID;
  # if we need to fetch the timestamp, or the insert failed due to existance
  # of an existing entry, we need to retrieve the entry from the db
  # note: $sth->execute can return 0E0 on error which is zero, but true
  # which is why the $rows_inserted clause was added.
  if(!$analysis->created() || !$rows_inserted || $rows_inserted == 0) {
    my $new_analysis = $self->fetch_by_logic_name($analysis->logic_name);

    if(!$new_analysis) {
      throw("Could not retrieve just stored analysis from database.\n" .
            "Possibly incorrect db permissions or missing analysis table\n");
    }

    $dbID = $new_analysis->dbID();
    $analysis->created($new_analysis->created());
  } 
  
  $dbID ||= $sth->{'mysql_insertid'};
  $sth->finish();

  # store description and display_label
  if( defined( $analysis->description() ) || defined( $analysis->display_label() )|| defined( $analysis->web_data() )) {
      $sth = $self->prepare( "INSERT IGNORE INTO analysis_description (analysis_id, display_label, description, displayable, web_data) VALUES (?,?,?,?, ?)");

      $sth->bind_param(1,$dbID,SQL_INTEGER);
      $sth->bind_param(2,$analysis->display_label(),SQL_VARCHAR);
      $sth->bind_param(3,$analysis->description,SQL_LONGVARCHAR);
      $sth->bind_param(4,$analysis->displayable,SQL_TINYINT);
      #$sth->bind_param(5,$analysis->web_data(),SQL_LONGVARCHAR);
      my $web_data;
      $web_data = $self->dump_data($analysis->web_data()) if ($analysis->web_data());
      $sth->bind_param(5,$web_data,SQL_LONGVARCHAR);
      $sth->execute();

      $sth->finish();
  }
  


  $self->{_cache}->{$dbID} = $analysis;
  $self->{_logic_name_cache}{lc($analysis->logic_name)} = $analysis;

  $analysis->adaptor( $self );
  $analysis->dbID( $dbID );

  return $dbID;

  my $self = shift;
  my $a    = shift;

  if (!ref($a) || !$a->isa('Bio::EnsEMBL::Analysis')) {
    throw("Expected Bio::EnsEMBL::Analysis argument.");
  }

  if(!$a->is_stored($self->db())) {
    return undef;
  }

  my $sth = $self->prepare
    ("UPDATE analysis " .
     "SET created = ?, logic_name = ?, db = ?, db_version = ?, db_file = ?, ".
     "    program = ?, program_version = ?, program_file = ?,  ".
     "    parameters = ?, module = ?, module_version = ?, ".
     "    gff_source = ?, gff_feature = ? " .
     "WHERE analysis_id = ?");



  $sth->bind_param(1,$a->created,SQL_DATETIME);
  $sth->bind_param(2,$a->logic_name,SQL_VARCHAR);
  $sth->bind_param(3,$a->db,SQL_VARCHAR);
  $sth->bind_param(4,$a->db_version,SQL_VARCHAR);
  $sth->bind_param(5,$a->db_file,SQL_VARCHAR);
  $sth->bind_param(6,$a->program,SQL_VARCHAR);
  $sth->bind_param(7,$a->program_version,SQL_VARCHAR);
  $sth->bind_param(8,$a->program_file,SQL_VARCHAR);
  $sth->bind_param(9,$a->parameters,SQL_VARCHAR);
  $sth->bind_param(10,$a->module,SQL_VARCHAR);
  $sth->bind_param(11,$a->module_version,SQL_VARCHAR);
  $sth->bind_param(12,$a->gff_source,SQL_VARCHAR);
  $sth->bind_param(13,$a->gff_feature,SQL_VARCHAR);
  $sth->bind_param(14,$a->dbID,SQL_INTEGER);

  $sth->execute();

  $sth->finish();

  # also update description & display label - may need to create these if
  # not already there
  $sth = $self->prepare("SELECT description FROM analysis_description WHERE analysis_id= ?");
  $sth->execute($a->dbID);
  my $web_data; #this is an anonymous reference to a hash, will have to be dumped into string before writing to db
  if ($sth->fetchrow_hashref) { # update if exists
      $web_data = $self->dump_data($a->web_data()) if ($a->web_data());
      $sth = $self->prepare
      ("UPDATE analysis_description SET description = ?, display_label = ?, displayable = ?, web_data = ? WHERE analysis_id = ?");
      $sth->bind_param(1,$a->description,SQL_LONGVARCHAR);     
      $sth->bind_param(2,$a->display_label(),SQL_VARCHAR);
      $sth->bind_param(3,$a->displayable,SQL_TINYINT);
      #      print "after $web_data\n";
      $sth->bind_param(4,$web_data,SQL_LONGVARCHAR);
      $sth->bind_param(5,$a->dbID,SQL_INTEGER);
      $sth->execute();

  } else { # create new entry

    if( $a->description() || $a->display_label() || $a->web_data) {
	$web_data = $self->dump_data($a->web_data()) if ($a->web_data());
      #my $web_data = $self->dump_data($a->web_data());
      $sth = $self->prepare( "INSERT IGNORE INTO analysis_description (analysis_id, display_label, description, displayable, web_data) VALUES (?,?,?,?,?)");
	$sth->bind_param(1,$a->dbID,SQL_INTEGER);	
	$sth->bind_param(2,$a->display_label(),SQL_VARCHAR);
	$sth->bind_param(3,$a->description,SQL_LONGVARCHAR);     
	$sth->bind_param(4,$a->displayable,SQL_TINYINT);
	#my $web_data = $self->dump_data($a->web_data());
	$sth->bind_param(5,$web_data,SQL_LONGVARCHAR);
	$sth->execute();

    }

  }


    $sth->finish();

  # the logic_name cache needs to be re-updated now, since we may have just
  # changed the logic_name
  $self->fetch_all();

  return 1;

  Copyright (c) 1999-2009 The European Bioinformatics Institute and
  Genome Research Limited.  All rights reserved.

  This software is distributed under a modified Apache license.
  For license details, please see

    /info/about/code_licence.html

  Please email comments or questions to the public Ensembl
  developers list at <ensembl-dev@ebi.ac.uk>.

  Questions may also be sent to the Ensembl help desk at
  <helpdesk@ensembl.org>.