my $uoa = $database_adaptor->get_UnmappedObjectAdaptor();

  my $missed = @{ $uoa->fetch_all_by_type('xref') };

  my $self = shift;

  return qw(uo.unmapped_object_id uo.type uo.analysis_id uo.external_db_id
            uo.identifier uo.unmapped_reason_id uo.query_score uo.target_score 
	    uo.ensembl_id uo.ensembl_object_type 
	    ur.summary_description ur.full_description);

  return( [ 'unmapped_object', "uo.unmapped_reason_id = ur.unmapped_reason_id" ]);

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

  my($unmapped_object_id, $type, $analysis_id, $external_db_id, $identifier,
     $unmapped_reason_id, $query_score, $target_score, $ensembl_id, 
     $ensembl_object_type, $summary, $full_desc);

  $sth->bind_columns(\$unmapped_object_id,\$type,\$ analysis_id,\$ 
		     external_db_id,\$ identifier,\$ unmapped_reason_id,\$ 
		     query_score,\$ target_score,\$ ensembl_id,\$ 
		     ensembl_object_type,\$ summary,\$ full_desc);

  my $analysis_adaptor = $self->db->get_AnalysisAdaptor();

  my @features;
  while($sth->fetch()) {
    my $analysis = $analysis_adaptor->fetch_by_dbID($analysis_id);
    
    #print "$identifier\n";

    push( @features,
          $self->_create_feature(
                         'Bio::EnsEMBL::UnmappedObject', {
                           -unmapped_object_id  => $unmapped_object_id,
                           -unmapped_reason_id  => $unmapped_reason_id,
                           -type                => $type,
                           -analysis            => $analysis,
                           -external_db_id      => $external_db_id,
                           -identifier          => $identifier,
                           -query_score         => $query_score,
                           -target_score        => $target_score,
                           -ensembl_id          => $ensembl_id,
                           -ensembl_object_type => $ensembl_object_type,
                           -summary             => $summary,
                           -full_desc           => $full_desc,
                           -adaptor             => $self
                         } ) );

  }
  return\@ features;

  return( [ 'unmapped_object', "uo.unmapped_reason_id = ur.unmapped_reason_id" ]);

  my $self = shift;

  return (['unmapped_object', 'uo'],
	  ['unmapped_reason', 'ur']);
}


# _columns
#  Arg [1]    : none
#  Example    : none
#  Description: PROTECTED implementation of superclass abstract method
#               returns a list of columns to use for queries
#  Returntype : list of strings
#  Exceptions : none
#  Caller     : internal
#  Status     : At Risk

  my ($self, $analysis,$dbname) = @_;
  
  unless($analysis) {
    throw("analysis argument is required");
  }
  $self->bind_param_generic_fetch($analysis->dbID,SQL_INTEGER);
  my $constraint = "uo.analysis_id = ?";
  if(defined($dbname)){
    my $db_id =0;
    my $sth = $self->prepare('select external_db_id from external_db where db_name like "'.
			      $dbname.'"');
    $sth->execute;
    $sth->bind_columns(\$db_id);
    $sth->fetch();
    if(!defined($db_id) or $db_id == 0){
      throw("$dbname could not be found in the external database table\n");
    }
    $self->bind_param_generic_fetch($db_id,SQL_INTEGER);
    $constraint .= " AND uo.external_db_id = ?";
  }
  $self->generic_fetch($constraint);

  my ($self, $type) = @_;
  
  unless($type) {
    throw("type argument is required");
  }
  $self->bind_param_generic_fetch($type,SQL_VARCHAR);
  $self->generic_fetch("uo.type = ?");

  my ($self, $identifier, $dbname) = @_;
  
  unless($identifier) {
    throw("identifier argument is required");
  }
  $self->bind_param_generic_fetch($identifier,SQL_VARCHAR);
  my $constraint = 'uo.identifier like ?';

  if(defined($dbname)){
    my $db_id =0;
    my $sth = $self->prepare('select external_db_id from external_db where db_name like "'.
			      $dbname.'"');
    $sth->execute;
    $sth->bind_columns(\$db_id);
    $sth->fetch();
    if(!defined($db_id) or $db_id == 0){
      throw("$dbname could not be found in the external database table\n");
    }
    $self->bind_param_generic_fetch($db_id,SQL_INTEGER);
    $constraint .= " AND uo.external_db_id = ?";
  }
  return $self->generic_fetch($constraint);
}

1;

   my ($self) = @_;

   return $self->_list_dbIDs("unmapped_object");

   my ($self) = @_;

   return $self->_list_dbIDs("unmapped_reason");
}


# _objs_from_sth

#  Arg [1]    : StatementHandle $sth
#  Example    : none
#  Description: PROTECTED implementation of abstract superclass method.
#               responsible for the creation of UnmappedObjects
#  Returntype : listref of Bio::EnsEMBL::UnmappedObjects
#  Exceptions : none
#  Caller     : internal
#  Status     : At Risk

  my $proto = shift;

  my $class = ref($proto) || $proto;

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

  my $sth =
    $self->prepare(   "SELECT unmapped_reason_id, full_description "
                    . "FROM unmapped_reason" );

  $sth->execute();

  my ( $id, $desc );
  $sth->bind_columns(\(  $id, $desc ) );

  while ( $sth->fetch() ) {
    $desc_to_id{$desc} = $id;
  }

  $sth->finish();

  return $self;
}


# _tables
#  Arg [1]    : none
#  Description: PROTECTED implementation of superclass abstract method
#               returns the names, aliases of the tables to use for queries
#  Returntype : list of listrefs of strings
#  Exceptions : none
#  Caller     : internal
#  Status     : At Risk

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

  if( scalar(@uos) == 0 ) {
    throw("Must call store with list of UnmappedObjects");
  }


  my $db = $self->db();
  my $analysis_adaptor = $db->get_AnalysisAdaptor();

  my $sth_reason = $self->prepare
    ("INSERT INTO unmapped_reason (summary_description, full_description)".
     " VALUES (?,?)");

  my $sth_unmapped_object = $self->prepare
	("INSERT INTO unmapped_object (type, analysis_id, external_db_id,
              identifier, unmapped_reason_id, query_score, target_score,
              ensembl_id, ensembl_object_type)".
	    " VALUES (?,?,?,?,?,?,?,?,?)");

 FEATURE: foreach my $uo ( @uos ) {

    if( !ref $uo || !$uo->isa("Bio::EnsEMBL::UnmappedObject") ) {
      throw("UnmappedObject must be an Ensembl UnmappedObject, " .
            "not a [".ref($uo)."]");
    }
    if($uo->is_stored($db)){
      next;
    } 
    
    my $analysis = $uo->analysis();
    throw("UnmappedObject must have an analysis object.".$uo->analysis."\n") if(!defined($analysis));

    my $analysis_id;
    if($analysis->is_stored($db)) {
      $analysis_id = $analysis->dbID();
    } else {
      $analysis_id = $db->get_AnalysisAdaptor->store($analysis);
    }

    #First check to see unmapped reason is stored
    if(!defined($desc_to_id{$uo->{'description'}})){
      $sth_reason->bind_param(1,$uo->{'summary'},SQL_VARCHAR);
      $sth_reason->bind_param(2,$uo->{'description'},SQL_VARCHAR);
      $sth_reason->execute();
      $uo->{'unmapped_reason_id'} = $desc_to_id{$uo->{'description'}} 
	= $sth_reason->{'mysql_insertid'};
      
    }
    else{
      $uo->{'unmapped_reason_id'} = $desc_to_id{$uo->{'description'}} ;
    }
    $sth_unmapped_object->bind_param(1,$uo->{'type'},SQL_VARCHAR);
    $sth_unmapped_object->bind_param(2,$uo->analysis->dbID,SQL_INTEGER);
    $sth_unmapped_object->bind_param(3,$uo->{'external_db_id'},SQL_INTEGER);
    $sth_unmapped_object->bind_param(4,$uo->{'identifier'},SQL_VARCHAR);
    $sth_unmapped_object->bind_param(5,$uo->{'unmapped_reason_id'},SQL_VARCHAR);
    $sth_unmapped_object->bind_param(6,$uo->{'query_score'},SQL_DOUBLE);
    $sth_unmapped_object->bind_param(7,$uo->{'target_score'},SQL_DOUBLE);
    $sth_unmapped_object->bind_param(8,$uo->{'ensembl_id'},SQL_INTEGER);
    $sth_unmapped_object->bind_param(9,$uo->{'ensembl_object_type'},SQL_VARCHAR);
    $sth_unmapped_object->execute();
    $uo->dbID($sth_unmapped_object->{'mysql_insertid'});
  }
  $sth_reason->finish();      
  return;

  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>.