my $self = shift;

	return qw(
			  es.experimental_set_id  es.experiment_id
			  es.feature_type_id      es.cell_type_id
			  es.format               es.vendor
			  es.name     			  ess.name
			  ess.experimental_subset_id
		 );

  my $self = shift;
	
  return (['experimental_subset', 'es.experimental_set_id = ess.experimental_set_id']);

  my ($self, $sth) = @_;
  
  my ($dbid, $exp_id, $ftype_id, $ctype_id, $format, $vendor, $name, $ess_name, $ess_id);
  my ($eset, @esets, $ftype, $ctype);
  my $ft_adaptor = $self->db->get_FeatureTypeAdaptor();
  my $ct_adaptor = $self->db->get_CellTypeAdaptor();
  my $exp_adaptor = $self->db->get_ExperimentAdaptor();
  $sth->bind_columns(\$dbid,\$ exp_id,\$ ftype_id,\$ ctype_id,\$ format,\$ vendor,\$ name,\$ ess_name,\$ ess_id);
  
  #this fails if we delete entries from the joined tables
  #causes problems if we then try and store an rs which is already stored

  while ( $sth->fetch() ) {

    if(! $eset || ($eset->dbID() != $dbid)){
      
      push @esets, $eset if $eset;
      $ftype = (defined $ftype_id) ? $ft_adaptor->fetch_by_dbID($ftype_id) : undef;
      $ctype = (defined $ctype_id) ? $ct_adaptor->fetch_by_dbID($ctype_id) : undef;

      $eset = Bio::EnsEMBL::Funcgen::ExperimentalSet->new(
														  -DBID         => $dbid,
														  -EXPERIMENT   => $exp_adaptor->fetch_by_dbID($exp_id),
														  -FORMAT       => $format,
														  -VENDOR       => $vendor,
														  -FEATURE_TYPE => $ftype,
														  -CELL_TYPE    => $ctype,
														  -ADAPTOR      => $self,
														  -NAME         => $name,
														 );
    }
    
    #This assumes logical association between chip from the same exp, confer in store method?????????????????
	
	
	#we're not controlling ctype and ftype during creating new ExperimentalSets to store.
	#we should change add_table_id to add_ExperimentalChip and check in that method
    if(defined $ess_name){
	  
	  $eset->add_new_subset($ess_name, Bio::EnsEMBL::Funcgen::ExperimentalSubset->new( -name    => $ess_name,
																				   -dbID    => $ess_id,
																				   -adaptor => $self,
																				   -experimental_set => $eset,
																				 ));
	  
	}
  }
  
  push @esets, $eset if $eset;
  
  return\@ esets;

  my $self = shift;
	
  return (
		  [ 'experimental_set',    'es' ],
		  [ 'experimental_subset', 'ess' ],
		 );

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

  if( !(ref($ctype) && $ctype->isa("Bio::EnsEMBL::Funcgen::CellType") && $ctype->dbID())){
    throw("Need to pass a valid stored Bio::EnsEMBL::Funcgen::CellType");
  }
	
  my $constraint = "es.cell_type_id =".$ctype->dbID();
	
  return $self->generic_fetch($constraint);

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

  if( ! ( ref($exp) &&
		  $exp->isa('Bio::EnsEMBL::Funcgen::Experiment') &&
		  $exp->dbID())){
	throw('Need to pass a valid stored Bio::EnsEMBL::Funcgen::Experiment');
  }
		
  return $self->generic_fetch('es.experiment_id = '.$exp->dbID());

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

  if( !(ref($ftype) && $ftype->isa("Bio::EnsEMBL::Funcgen::FeatureType") && $ftype->dbID())){
    throw("Need to pass a valid stored Bio::EnsEMBL::Funcgen::FeatureType");
  }
  
  my $constraint = "es.feature_type_id =".$ftype->dbID();
	
  return $self->generic_fetch($constraint);

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

  throw('Need to pass a name argument') if( ! defined $name);
		
  return $self->generic_fetch("es.name ='${name}'")->[0];

	my $self = shift;
	
	return $self->_list_dbIDs('result_set');
}

1;

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

  throw("Must provide a list of ExperimentalSet objects") if(scalar(@exp_sets == 0));
  
  
  
  my $sth = $self->prepare('INSERT INTO experimental_set (experiment_id, feature_type_id, 
                                                       cell_type_id, format, vendor, name) 
                                                       VALUES (?, ?, ?, ?, ?, ?)');
  
  my $db = $self->db();
  
  foreach my $set (@exp_sets) {
    
    if( ! ref $set || ! $set->isa('Bio::EnsEMBL::Funcgen::ExperimentalSet') ) {
      throw('Must be an ExperimentalSet object to store');
    }
    
        
    if ( $set->is_stored($db) ) {
      throw('ExperimentalSet [' . $set->dbID() . '] is already stored in the database\nExperimentalSetAdaptor does not yet accomodate updating ExperimentalSets');
      #would need to retrive stored result set and update table_ids
    }
   

	my $ct_id = (defined $set->cell_type()) ? $set->cell_type->dbID() : undef;
	my $ft_id = (defined $set->feature_type()) ? $set->feature_type->dbID() : undef;

    $sth->bind_param(1, $set->get_Experiment->dbID(),   SQL_INTEGER);
	$sth->bind_param(2, $ft_id,                         SQL_INTEGER);
	$sth->bind_param(3, $ct_id,                         SQL_INTEGER);
  	$sth->bind_param(4, $set->format,                   SQL_VARCHAR);
  	$sth->bind_param(5, $set->vendor,                   SQL_VARCHAR);
	$sth->bind_param(6, $set->name,                     SQL_VARCHAR);
	
    
    $sth->execute();
    
    $set->dbID( $sth->{'mysql_insertid'} );
    $set->adaptor($self);

    
    $self->store_ExperimentalSubsets($set->get_subsets()) if @{$set->get_subsets()};
  }
  
  return\@ exp_sets;

  my ($self, $ssets) = @_;
  
  my $sth = $self->prepare("
		INSERT INTO experimental_subset (
			experimental_set_id, name
		) VALUES (?, ?)
	");

  throw('Must provide at least one ExperimentalSubset') if(! @$ssets);

  #Store and set all previously unstored table_ids
  foreach my $sset(@$ssets){
	
	#use is_stored here?
	if($sset->dbID()){
	  warn "Skipping ExperimentalSubset ".$sset->name()." - already stored in the DB";
	  next;
	}
	

	$sth->bind_param(1, $sset->experimental_set->dbID(), SQL_INTEGER);
	$sth->bind_param(2, $sset->name(),                   SQL_VARCHAR);
	$sth->execute();

	$sset->dbID($sth->{'mysql_insertid'});
	$sset->adaptor($self);


	#No need to set it as we're working on the hasref here, so should be updated in the class.
	#add directly to avoid name clash warnings
	#$exp_set->{'subsets'}{$sub_set_name} = Bio::EnsEMBL::Funcgen::ExperimentalSubset->new
	#  (
	#   -dbID    => $sth->{'mysql_insertid'},
	#   -name    => $sub_set_name,
	#   -adaptor => $self,
	#   #-experimental_set_id?
	#  );

  }
  
  #don't really need to return as we're passing the ref
  return $ssets;

  Args       : None
  Example    : None
  Description: PROTECTED implementation of superclass abstract method.
               Returns an additional table joining constraint to use for
			   queries.
  Returntype : List of strings
  Exceptions : None
  Caller     : Internal
  Status     : At Risk