use Bio::EnsEMBL::Compara::DBSQL::DBAdaptor; 
  my $db = new Bio::EnsEMBL::Compara::DBSQL::DBAdaptor (
      -host => $host,
      -user => $dbuser,
      -pass => $dbpass,
      -port => $port,
      -dbname => $dbname,
      -conf_file => $conf_file);

  my $mlssa = $db->get_MethodLinkSpeciesSetAdaptor();

  
  use Bio::EnsEMBL::Registry; 
  Bio::EnsEMBL::Registry->load_all($conf_file); # $conf_file can be undef

  use Bio::EnsEMBL::Registry; 
  Bio::EnsEMBL::Registry->load_all($conf_file); # $conf_file can be undef

  Bio::EnsEMBL::Registry->load_all();

  my $mlssa = Bio::EnsEMBL::Registry->get_adaptor(
      $compara_db_name, "compara", "MethodLinkSpeciesSet");

  
  $mlssa->store($method_link_species_set);

  my $method_link_species_sets = $mlssa->fetch_all;

  my $method_link_species_set = $mlssa->fetch_by_dbID(1);

  my $method_link_species_set = $mlssa->fetch_by_method_link_type_registry_aliases(
        "BLASTZ_NET", ["human", "Mus musculus"]);

  my $method_link_species_sets = $mlssa->fetch_all_by_method_link_type("BLASTZ_NET");

  my $method_link_species_sets = $mlssa->fetch_all_by_GenomeDB($genome_db);

  my $method_link_species_sets = $mlssa->fetch_all_by_method_link_type_GenomeDB(
        "PECAN", $gdb1);

  my $method_link_species_set = $mlssa->fetch_by_method_link_type_GenomeDBs(
        "TRANSLATED_BLAT", [$gdb1, $gdb2]);

  my ($self, $method_link_id) = @_;
  my $class; # returned string
  
  my $sql = qq{
		SELECT class
		FROM method_link
		WHERE method_link_id = ?
	};

  my $sth = $self->prepare($sql);
  $sth->execute($method_link_id);
  
  $class = $sth->fetchrow_array();

  return $class;

  my ($self, $genome_db_ids) = @_;
  my $species_set_id;

  ## Fetch all the species_set which contain all these species_set_ids
  my $sql = qq{
          SELECT
            species_set_id,
            COUNT(*) as count
          FROM
            species_set
          WHERE
            genome_db_id in (}.join(",", @$genome_db_ids).qq{)
          GROUP BY species_set_id
          HAVING count = }.(scalar(@$genome_db_ids));
  my $sth = $self->prepare($sql);
  $sth->execute();
  my $all_rows = $sth->fetchall_arrayref();
  if (!@$all_rows) {
    return undef;
  }
  my $species_set_ids = [map {$_->[0]} @$all_rows];

  ## Keep only the species_set which does not contain any other genome_db_id
  $sql = qq{
          SELECT
            species_set_id,
            COUNT(*) as count
          FROM
            species_set
          WHERE
            species_set_id in (}.join(",", @$species_set_ids).qq{)
          GROUP BY species_set_id
          HAVING count = }.(scalar(@$genome_db_ids));
  $sth = $self->prepare($sql);
  $sth->execute();

  $all_rows = $sth->fetchall_arrayref();
  if (!@$all_rows) {
    return undef;
  } elsif (@$all_rows > 1) {
    warning("Several species_set_ids have been found for genome_db_ids (".
        join(",", @$genome_db_ids)."): ".join(",", map {$_->[0]} @$all_rows));
  }
  $species_set_id = $all_rows->[0]->[0];

  return $species_set_id;

  my ($self, $species_set) = @_;
  my $genome_db_ids = [];

  foreach my $this_genome_db (@$species_set) {
    if (UNIVERSAL::isa($this_genome_db, "Bio::EnsEMBL::Compara::GenomeDB") and $this_genome_db->dbID) {
      push(@$genome_db_ids, $this_genome_db->dbID);
    } else {
      throw("[$this_genome_db] is not a Bio::EnsEMBL::Compara::GenomeDB or has no dbID");
    }
  }
  return $self->_get_species_set_id_from_genome_db_ids([map {$_->dbID} @$species_set]);

  my ($self, $method_link_id, $genome_db_ids) = @_;
  my $method_link_species_set;

  my $species_set_id = $self->_get_species_set_id_from_genome_db_ids($genome_db_ids);

  if ($species_set_id) {
    my $sql = qq{
            SELECT
              method_link_species_set_id
            FROM
              method_link_species_set mlss
            WHERE
              species_set_id =\" $species_set_id\"
              AND method_link_id =\" $method_link_id\"
            };
    my $sth = $self->prepare($sql);
    $sth->execute();
    my ($dbID) = $sth->fetchrow_array();

    $method_link_species_set = $self->fetch_by_dbID($dbID);
    $sth->finish;
  }

  return $method_link_species_set;

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

  my $method_link_species_set_sql = qq{
          DELETE FROM
            method_link_species_set
          WHERE
            method_link_species_set_id = ?
      };
  $sth = $self->prepare($method_link_species_set_sql);
  $sth->execute($method_link_species_set_id);

  ## Delete corresponding entry in meta table
  $self->db->get_MetaContainer->delete_key("max_align_$method_link_species_set_id");

  my ($self) = @_;
  my $method_link_species_sets = [];
  
  my $sql = qq{
          SELECT
            method_link_species_set_id,
            method_link_species_set.method_link_id,
            name,
            source,
            url,
            method_link_species_set.species_set_id,
            genome_db_id,
            type,
            class
          FROM
            method_link_species_set
            LEFT JOIN method_link USING (method_link_id),
            species_set
          WHERE
            method_link_species_set.species_set_id = species_set.species_set_id
      };

  my $sth = $self->prepare($sql);
  $sth->execute();
  my $all_method_link_species_sets;
  my $gdba = $self->db->get_GenomeDBAdaptor;

  while (my ($method_link_species_set_id, $method_link_id, $name, $source, $url,
      $species_set_id, $genome_db_id, $type, $class) = $sth->fetchrow_array()) {
    $all_method_link_species_sets->{$method_link_species_set_id}->{'METHOD_LINK_ID'} = $method_link_id;
    $all_method_link_species_sets->{$method_link_species_set_id}->{'NAME'} = $name;
    $all_method_link_species_sets->{$method_link_species_set_id}->{'SOURCE'} = $source;
    $all_method_link_species_sets->{$method_link_species_set_id}->{'URL'} = $url;
    $all_method_link_species_sets->{$method_link_species_set_id}->{'SPECIES_SET_ID'} = $species_set_id;
    $all_method_link_species_sets->{$method_link_species_set_id}->{'METHOD_LINK_TYPE'} = $type;
    $all_method_link_species_sets->{$method_link_species_set_id}->{'METHOD_LINK_CLASS'} = $class;
    push(@{$all_method_link_species_sets->{$method_link_species_set_id}->{'SPECIES_SET'}},
        $gdba->fetch_by_dbID($genome_db_id));
  }

  foreach my $method_link_species_set_id (keys %$all_method_link_species_sets) {
    my $this_method_link_species_set;
    eval { $this_method_link_species_set = new Bio::EnsEMBL::Compara::MethodLinkSpeciesSet(
            -adaptor => $self,
            -dbID => $method_link_species_set_id,
            -method_link_id =>
                $all_method_link_species_sets->{$method_link_species_set_id}->{'METHOD_LINK_ID'},
            -method_link_type =>
                $all_method_link_species_sets->{$method_link_species_set_id}->{'METHOD_LINK_TYPE'},
            -method_link_class =>
                $all_method_link_species_sets->{$method_link_species_set_id}->{'METHOD_LINK_CLASS'},
            -name =>
                $all_method_link_species_sets->{$method_link_species_set_id}->{'NAME'},
            -source =>
                $all_method_link_species_sets->{$method_link_species_set_id}->{'SOURCE'},
            -url =>
                $all_method_link_species_sets->{$method_link_species_set_id}->{'URL'},
            -species_set_id =>
                $all_method_link_species_sets->{$method_link_species_set_id}->{'SPECIES_SET_ID'},
            -species_set =>
                $all_method_link_species_sets->{$method_link_species_set_id}->{'SPECIES_SET'},
        );
    };
    push(@$method_link_species_sets, $this_method_link_species_set) if (defined($this_method_link_species_set));
  }

  return $method_link_species_sets;

  my ($self, $genome_db) = @_;
  my $method_link_species_sets = [];

  throw "[$genome_db] must be a Bio::EnsEMBL::Compara::GenomeDB object"
      unless ($genome_db and $genome_db->isa("Bio::EnsEMBL::Compara::GenomeDB"));
  my $genome_db_id = $genome_db->dbID;
  throw "[$genome_db] must have a dbID" if (!$genome_db_id);

  my $all_method_link_species_sets = $self->fetch_all;

  foreach my $this_method_link_species_set (@$all_method_link_species_sets) {
    foreach my $this_genome_db (@{$this_method_link_species_set->species_set}) {
      if ($this_genome_db->dbID == $genome_db_id) {
        push (@$method_link_species_sets, $this_method_link_species_set);
        last;
      }
    }
  }

  return $method_link_species_sets;

  my ($self, $genome_db_id) = @_;
  my $method_link_species_sets = [];

  deprecate("Use the fetch_all_by_GenomeDB method instead");

  my $all_method_link_species_sets = $self->fetch_all;

  foreach my $this_method_link_species_set (@$all_method_link_species_sets) {
    foreach my $this_genome_db (@{$this_method_link_species_set->species_set}) {
      if ($this_genome_db->dbID == $genome_db_id) {
        push (@$method_link_species_sets, $this_method_link_species_set);
        last;
      }
    }
  }

  return $method_link_species_sets;

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

  deprecate("Use the fetch_all_by_method_link_type method instead");

  my $method_link_type = $self->get_method_link_type_from_method_link_id($method_link_id);
  return $self->fetch_all_by_method_link_type($method_link_type);

  my ($self, $method_link_id, $genome_db) = @_;
  my $method_link_species_sets = [];

  deprecate("Use the fetch_all_by_method_link_type_GenomeDB method instead");

  my $method_link_type = $self->get_method_link_type_from_method_link_id($method_link_id);
  return $self->fetch_all_by_method_link_type_GenomeDB ($method_link_type, $genome_db);

  my ($self, $method_link_id, $genome_db_id) = @_;

  deprecate("Use the fetch_all_by_method_link_type_GenomeDB method instead");
  my $method_link_type = $self->get_method_link_type_from_method_link_id($method_link_id);
  my $genome_db = $self->db->get_GenomeDBAdaptor->fetch_by_dbID($genome_db_id);

  return $self->fetch_all_by_method_link_type_GenomeDB($method_link_type, $genome_db);

  my ($self, $method_link_type) = @_;
  my $method_link_species_sets = [];

  return [] if (!defined($method_link_type));

  my $all_method_link_species_sets = $self->fetch_all();
  foreach my $this_method_link_species_set (@$all_method_link_species_sets) {
    if ($this_method_link_species_set->method_link_type eq $method_link_type) {
      push(@$method_link_species_sets, $this_method_link_species_set);
    }
  }

  return $method_link_species_sets;

  my ($self, $method_link_type, $genome_db) = @_;
  my $method_link_species_sets = [];
  
  throw "[$genome_db] must be a Bio::EnsEMBL::Compara::GenomeDB object or the corresponding dbID"
      unless ($genome_db and $genome_db->isa("Bio::EnsEMBL::Compara::GenomeDB"));
  my $genome_db_id = $genome_db->dbID;
  throw "[$genome_db] must have a dbID" if (!$genome_db_id);

  my $all_method_link_species_sets = $self->fetch_all();
  foreach my $this_method_link_species_set (@$all_method_link_species_sets) {
    if ($this_method_link_species_set->method_link_type eq $method_link_type and
        grep (/^$genome_db_id$/, map {$_->dbID} @{$this_method_link_species_set->species_set})) {
      push(@$method_link_species_sets, $this_method_link_species_set);
    }
  }

  return $method_link_species_sets;

  my ($self, $method_link_type, $genome_db_id) = @_;

  deprecate("Use the fetch_all_by_method_link_type_GenomeDB method instead");
  my $genome_db = $self->db->get_GenomeDBAdaptor->fetch_by_dbID($genome_db_id);

  return $self->fetch_all_by_method_link_type_GenomeDB($method_link_type, $genome_db);

  my ($self, $dbID) = @_;
  my $method_link_species_set; # returned object
  
  my $gdba = $self->db->get_GenomeDBAdaptor;
  my $sql = qq{
          SELECT
            method_link_species_set_id,
            mlss.method_link_id,
            name,
            source,
            url,
            mlss.species_set_id,
            genome_db_id,
            type
          FROM
            method_link_species_set mlss
            LEFT JOIN method_link ml USING (method_link_id),
            species_set ss
          WHERE
            mlss.species_set_id = ss.species_set_id
            AND method_link_species_set_id = ?
	};

  my $sth = $self->prepare($sql);
  $sth->execute($dbID);
  
  my $this_method_link_species_set;
  
  ## Get all rows corresponding to this method_link_species_set
  while (my ($method_link_species_set_id, $method_link_id, $name, $source, $url,
      $species_set_id, $genome_db_id, $type, $class) = $sth->fetchrow_array()) {
    $this_method_link_species_set->{'METHOD_LINK_ID'} = $method_link_id;
    $this_method_link_species_set->{'METHOD_LINK_TYPE'} = $type;
    $this_method_link_species_set->{'METHOD_LINK_CLASS'} = $class;
    $this_method_link_species_set->{'NAME'} = $name;
    $this_method_link_species_set->{'SOURCE'} = $source;
    $this_method_link_species_set->{'URL'} = $url;
    push(@{$this_method_link_species_set->{'SPECIES_SET'}}, $gdba->fetch_by_dbID($genome_db_id));
  }
  
  return undef if (!defined($this_method_link_species_set));
  
  ## Create the object
  $method_link_species_set = new Bio::EnsEMBL::Compara::MethodLinkSpeciesSet(
          -adaptor => $self,
          -dbID => $dbID,
          -method_link_id => $this_method_link_species_set->{'METHOD_LINK_ID'},
          -method_link_type => $this_method_link_species_set->{'METHOD_LINK_TYPE'},
          -method_link_class => $this_method_link_species_set->{'METHOD_LINK_CLASS'},
          -name => $this_method_link_species_set->{'NAME'},
          -source => $this_method_link_species_set->{'SOURCE'},
          -url => $this_method_link_species_set->{'URL'},
          -species_set_id => $this_method_link_species_set->{'SPECIES_SET_ID'},
          -species_set => $this_method_link_species_set->{'SPECIES_SET'}
      );
  if (!$method_link_species_set) {
    warning("No Bio::EnsEMBL::Compara::MethodLinkSpeciesSet with id = $dbID found");
  }

  return $method_link_species_set;

  my ($self, $method_link_id, $genome_dbs) = @_;

  deprecate("Use the fetch_by_method_link_type_GenomeDBs method instead");
  my $method_link_type = $self->get_method_link_type_from_method_link_id($method_link_id);

  return $self->fetch_by_method_link_type_GenomeDBs($method_link_type, $genome_dbs);

  my ($self, $method_link_id, $genome_db_ids) = @_;
  my $method_link_species_set;

  deprecate("Use the fetch_by_method_link_type_GenomeDBs method instead");
  my $method_link_type = $self->get_method_link_type_from_method_link_id($method_link_id);
  my $genome_db_adaptor = $self->db->get_GenomeDBAdaptor();
  my $genome_dbs;
  foreach my $this_genome_db_id (@$genome_db_ids) {
    push(@$genome_dbs, $genome_db_adaptor->fetch_by_dbID($this_genome_db_id ));
  }

  return $self->fetch_by_method_link_type_GenomeDBs($method_link_type, $genome_dbs);
}


1;

  my ($self, $method_link_type, $genome_dbs, $no_warning) = @_;
  my $method_link_species_set;

  my $genome_db_ids;
  foreach my $genome_db (@$genome_dbs) {
    throw "[$genome_db] must be a Bio::EnsEMBL::Compara::GenomeDB object or the corresponding dbID"
        unless ($genome_db and $genome_db->isa("Bio::EnsEMBL::Compara::GenomeDB"));
    my $genome_db_id = $genome_db->dbID;
    throw "[$genome_db] must have a dbID" if (!$genome_db_id);
    push (@$genome_db_ids, $genome_db_id);
  }
  my $method_link_id = ($self->get_method_link_id_from_method_link_type($method_link_type) || 0);
  
  $method_link_species_set = $self->_run_query_from_method_link_id_genome_db_ids($method_link_id, $genome_db_ids);
  if (!$method_link_species_set and !$no_warning) {
    my $warning = "No Bio::EnsEMBL::Compara::MethodLinkSpeciesSet found for\n".
        "  <$method_link_type> and ".
        join(", ", map {$_->name."(".$_->assembly.")"} @$genome_dbs);
    warning($warning);
  }
  return $method_link_species_set;

  my ($self, $method_link_type, $genome_db_ids) = @_;
  my $method_link_species_set;
   
  my $method_link_id = ($self->get_method_link_id_from_method_link_type($method_link_type) || 0);
  
  return $self->_run_query_from_method_link_id_genome_db_ids($method_link_id, $genome_db_ids)

  my ($self,$method_link_type, $registry_aliases) = @_;

  my $gdba = $self->db->get_GenomeDBAdaptor;
  my @genome_dbs;
  
  foreach my $alias (@{$registry_aliases}) { 
    if (Bio::EnsEMBL::Registry->alias_exists($alias)) {
      my ($binomial, $gdb);
      try {
        $binomial = Bio::EnsEMBL::Registry->get_alias($alias);
        $gdb = $gdba->fetch_by_name_assembly($binomial);
      } catch {
        my $meta_c = Bio::EnsEMBL::Registry->get_adaptor($alias, 'core', 'MetaContainer');
        $binomial=$gdba->get_species_name_from_core_MetaContainer($meta_c);
        $gdb = $gdba->fetch_by_name_assembly($binomial);
      };
      push @genome_dbs, $gdb;
    } else {
      throw("Database alias $alias is not known\n");
    }
  }

  return $self->fetch_by_method_link_type_GenomeDBs($method_link_type,\@genome_dbs);

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

  my $method_link_species_set_id = ($method_link_species_set->dbID or 0);
  my $values = $self->db->get_MetaContainer->list_value_by_key(
      "max_align_$method_link_species_set_id");
  if ($values && @$values) {
    return $method_link_species_set->max_alignment_length($values->[0]);
  } else {
    $values = $self->db->get_MetaContainer->list_value_by_key("max_alignment_length");
    if($values && @$values) {
      warning("Meta table key 'max_align_$method_link_species_set_id' not defined\n" .
          " -> using old meta table key 'max_alignment_length' [".$values->[0]."]");
      return $method_link_species_set->max_alignment_length($values->[0]);
    } else {
      warning("Meta table key 'max_align_$method_link_species_set_id' not defined and\n" .
          "old meta table key 'max_alignment_length' not defined\n" .
          " -> using default value [$DEFAULT_MAX_ALIGNMENT]");
      return $method_link_species_set->max_alignment_length($DEFAULT_MAX_ALIGNMENT);
    }
  }

  my ($self, $method_link_type) = @_;
  my $dbID; # returned integer
  
  my $sql = qq{
		SELECT method_link_id
		FROM method_link
		WHERE type = ?
	};

  my $sth = $self->prepare($sql);
  $sth->execute($method_link_type);
  
  $dbID = $sth->fetchrow_array();
  $sth->finish;

  if (!$dbID) {
    warning("No method_link matches <$method_link_type>");
  }

  return $dbID;

  my ($self, $method_link_id) = @_;
  my $type; # returned string
  
  my $sql = qq{
		SELECT type
		FROM method_link
		WHERE method_link_id = ?
	};

  my $sth = $self->prepare($sql);
  $sth->execute($method_link_id);
  
  $type = $sth->fetchrow_array();

  return $type;

  my $class = shift;

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

  return $self;

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

  throw("method_link_species_set must be a Bio::EnsEMBL::Compara::MethodLinkSpeciesSet\n")
    unless ($method_link_species_set && ref $method_link_species_set &&
        $method_link_species_set->isa("Bio::EnsEMBL::Compara::MethodLinkSpeciesSet"));

  $method_link_species_set->adaptor($self);

  my $method_link_sql = qq{SELECT 1 FROM method_link WHERE method_link_id = ?};
  my $method_link_type_sql   = qq{SELECT method_link_id from method_link where type = ?};
  my $method_link_insert_sql = qq{INSERT INTO method_link (type, class) VALUES(?, ?)};

  my $method_link_species_set_sql = qq{
        INSERT IGNORE INTO method_link_species_set (
          method_link_species_set_id,
          method_link_id,
          species_set_id,
          name,
          source,
          url)
        VALUES (?, ?, ?, ?, ?, ?)
    };

  my $method_link_id   = $method_link_species_set->method_link_id;
  my $method_link_type = $method_link_species_set->method_link_type;
  my $method_link_class = ($method_link_species_set->method_link_class or "");
  my $species_set = $method_link_species_set->species_set;

  ## If we have method_link_type but no method_link_id
  if( $method_link_type and ! $method_link_id ){
    # Is the type in the DB?
    my $sth = $self->prepare($method_link_type_sql);
    $sth->execute( $method_link_type );
    if( my $res = $sth->fetchrow_arrayref ){
      # Found existing
      $method_link_id = $res->[0];
    } else {
      # Insert new
      my $sth = $self->prepare($method_link_insert_sql);
      $sth->execute( $method_link_type, $method_link_class );
      $method_link_id = $sth->{'mysql_insertid'};      
    }
    # Update the object
    $method_link_species_set->method_link_id($method_link_id);
  }

  ## Checks if method_link_id already exists in the database
  $sth = $self->prepare($method_link_sql);
  $sth->execute($method_link_id);
  if (!$sth->fetchrow_array) {
    throw("method_link_id $method_link_id is not in the database!\n");
  }
  $sth->finish;

  ## Fetch genome_db_ids from Bio::EnsEMBL::Compara::GenomeDB objects
  my @genome_db_ids;
  foreach my $species (@$species_set) {
    push(@genome_db_ids, $species->dbID);
  }

  my $dbID;
  my $already_existing_method_link_species_set = 
      $self->fetch_by_method_link_type_GenomeDBs($method_link_type,$species_set, 1);
  if ($already_existing_method_link_species_set) {
    $dbID = $already_existing_method_link_species_set->dbID;
  }

  if (!$dbID) {
    ## Lock the table in order to avoid a concurrent process to store the same object with a different dbID
    # from mysql documentation 13.4.5 : 
    #   "If your queries refer to a table using an alias, then you must lock the table using that same alias. 
    #   "It will not work to lock the table without specifying the alias" 
    #Thus we need to lock method_link_species_set as a, method_link_species_set as b, and method_link_species_set 

    $self->dbc->do(qq{ LOCK TABLES method_link WRITE, 
                       method_link_species_set as mlss WRITE, 
                       method_link_species_set as mlss1 WRITE, 
                       method_link_species_set as mlss2 WRITE, 
                       method_link as ml WRITE, 
                       species_set WRITE,
                       species_set as ss WRITE,
                       species_set as ss1 WRITE,
                       species_set as ss2 WRITE,
                       method_link_species_set WRITE });

    # Now, check if the object has not been stored before (tables are locked)
    $already_existing_method_link_species_set = 
        $self->fetch_by_method_link_type_GenomeDBs($method_link_type,$species_set, 1);
    if ($already_existing_method_link_species_set) {
      $dbID = $already_existing_method_link_species_set->dbID;
    }

    # If the object still does not exist in the DB, store it
    if (!$dbID) {
      $dbID = $method_link_species_set->dbID();
      if (!$dbID) {
        ## Use convetion rule for getting a new dbID. At the moment, we yse the following
        ## ranges:
        ##
        ## dna-dna alignments: method_link_id E [1-100], method_link_species_set_id E [1-10000]
        ## synteny:            method_link_id E [101-100], method_link_species_set_id E [10001-20000]
        ## homology:           method_link_id E [201-300], method_link_species_set_id E [20001-30000]
        ## families:           method_link_id E [301-400], method_link_species_set_id E [30001-40000]
        ##
        ## => the method_link_species_set_id must be between 10000 times the hundreds in the
        ## method_link_id and the next hundred.
        my $sth2 = $self->prepare("SELECT
            MAX(mlss1.method_link_species_set_id + 1)
            FROM method_link_species_set mlss1 LEFT JOIN method_link_species_set mlss2
              ON (mlss2.method_link_species_set_id = mlss1.method_link_species_set_id + 1)
            WHERE mlss2.method_link_species_set_id IS NULL
              AND mlss1.method_link_species_set_id > 10000 * ($method_link_id DIV 100)
              AND mlss1.method_link_species_set_id < 10000 * (1 + $method_link_id DIV 100)
            ");
        $sth2->execute();
        ($dbID) = $sth2->fetchrow_array();
        $dbID = 10000 * int($method_link_id / 100) + 1 if (!defined($dbID));
      }
      my $species_set_id;
      if ($method_link_species_set->species_set_id) { 
        $species_set_id = $method_link_species_set->species_set_id;
        my $sth2 = $self->prepare("INSERT IGNORE INTO species_set VALUES (?, ?)");
        foreach my $genome_db_id (@genome_db_ids) {
          $sth2->execute($species_set_id, $genome_db_id);
        }
      } else {
        $species_set_id = $self->_get_species_set_id_from_species_set($species_set);
      }
      if (!$species_set_id) {
        my $sth2 = $self->prepare("INSERT INTO species_set VALUES (?, ?)");
        foreach my $genome_db_id (@genome_db_ids) {
          $sth2->execute(($species_set_id or "NULL"), $genome_db_id);
          $species_set_id = $sth2->{'mysql_insertid'};
        }
      }
      $sth = $self->prepare($method_link_species_set_sql);
      $sth->execute(($dbID or "NULL"), $method_link_id, $species_set_id,
          ($method_link_species_set->name or "NULL"), ($method_link_species_set->source or "NULL"),
          ($method_link_species_set->url or ""));
      $dbID = $sth->{'mysql_insertid'};
    }

    ## Unlock tables
    $self->dbc->do("UNLOCK TABLES");
  }

  ## If this MethodLinkSpeciesSet object has a max_alignment_length attribute.
  ## We have to use the attribute and not the method here as the method is used
  ## for lazy-loading data from the meta table and could use default values if
  ## none has been specified. As some method_link_species_sets do not have any
  ## max_alignment_length, using the method here would result in adding a default
  ## max_alignment_length to those method_link_species_sets!
  if (defined($method_link_species_set->{max_alignment_length})) {
    my $values = $self->db->get_MetaContainer->list_value_by_key("max_align_$dbID");
    if (@$values) {
      if ($values->[0] != $method_link_species_set->max_alignment_length){
        #... update it if it was already defined and it is different from current one
        $self->db->get_MetaContainer->update_key_value("max_align_$dbID",
            $method_link_species_set->max_alignment_length);
      }
    } else {
        #... store it if it was not defined yet
      $self->db->get_MetaContainer->store_key_value("max_align_$dbID",
          $method_link_species_set->max_alignment_length)
    }
  }

  $sth->finish;
  
  $method_link_species_set->dbID($dbID);
  
  return $method_link_species_set;

 - Bio::EnsEMBL::Registry
 - Bio::EnsEMBL::DBSQL::BaseAdaptor
 - Bio::EnsEMBL::BaseAdaptor
 - Bio::EnsEMBL::Compara::MethodLinkSpeciesSet
 - Bio::EnsEMBL::Compara::GenomeDB
 - Bio::EnsEMBL::Compara::DBSQL::GenomeDBAdaptor