my $db = Bio::EnsEMBL::Funcgen::DBSQL::DBAdaptor->new(...);

  my $csa = $db->get_CoordSystemAdaptor();

  #
  # Fetch by name, schema_build and version(opt).
  #

  $cs = $csa->fetch_by_name_schema_build_version('chromosome', '39_36a', 'NCBI36');

  #As this is a multi-assembly DB, we have to accomodate the idea of schema versions, which will
  #enable a mapping from the feature table back to assembly/core DB of origin.

  #Old core methods, some may not work as they assume that there will only be one default version
  #where are there maybe multiple default versions, one for each assembly/schema_build

  #
  # Get all coord systems in the database:
  #
  foreach my $cs (@{$csa->fetch_all()}) {
    print $cs->name, ' ',  $cs->version, "\n";
  }

  #
  # Fetching by name:
  #

  #use the default version of coord_system 'chromosome' (e.g. NCBI33):
  $cs = $csa->fetch_by_name('chromosome');

  #get an explicit version of coord_system 'chromosome':
  $cs = $csa->fetch_by_name('chromsome', 'NCBI34');

  #get all coord_systems of name 'chromosome':
  foreach $cs (@{$csa->fetch_all_by_name('chromosome')}) {
     print $cs->name, ' ', $cs->version, "\n";
  }

  #
  # Fetching by rank:
  #
  $cs = $csa->fetch_by_rank(2);

  #
  # Fetching the pseudo coord system 'toplevel'
  #

  #Get the default top_level coord system:
  $cs = $csa->fetch_top_level();

  #can also use an alias in fetch_by_name:
  $cs = $csa->fetch_by_name('toplevel');

  #can also request toplevel using rank=0
  $cs = $csa->fetch_by_rank(0);

  #
  # Fetching by sequence level:
  #

  #Get the coord system which is used to store sequence:
  $cs = $csa->fetch_sequence_level();

  #can also use an alias in fetch_by_name:
  $cs = $csa->fetch_by_name('seqlevel');

  #
  # Fetching by id
  #
  $cs = $csa->fetch_by_dbID(1);

  my $self = shift;
  my $attrib = shift;

  my @coord_systems = ();
  foreach my $dbID (keys %{$self->{"_is_$attrib"}}) {
    push @coord_systems, $self->{"_dbID_cache"}->{$dbID};
  }

  return\@ coord_systems;

  my $self = shift;
  my $attrib = shift;
  my $version = shift;

  $version = lc($version) if($version);

  my @dbIDs = keys %{$self->{"_is_$attrib"}};

  throw("No $attrib coordinate system defined") if(!@dbIDs);

  foreach my $dbID (@dbIDs) {
    my $cs = $self->{'_dbID_cache'}->{$dbID};
    if($version) {
      return $cs if(lc($version) eq $cs->version());
    } elsif($self->{'_is_default_version'}->{$dbID}) {
      return $cs;
    }
  }

  #specifically requested attrib system was not found
  if($version) {
    throw("$attrib coord_system with version [$version] does not exist");
  }

  #coordsystem with attrib exists but no default is defined:
  my $dbID = shift @dbIDs;
  my $cs = $self->{'_dbID_cache'}->{$dbID};
  my $v = $cs->version();
  warning("No default version for $attrib coord_system exists. " .
          "Using version [$v] arbitrarily");

  return $cs;

  my $self = shift;


  throw('Not implement rank cache');

  my @coord_systems;

  #order the array by rank in ascending order
  foreach my $rank (sort {$a <=> $b} keys %{$self->{'_rank_cache'}}) {
    push @coord_systems, $self->{'_rank_cache'}->{$rank};
  }

  return\@ coord_systems;

  my $self = shift;
  my $name = lc(shift); #case insensitive matching

  throw('Name argument is required') if(!$name);

  if($name eq 'seqlevel') {
    return [$self->fetch_sequence_level()];
  } elsif($name eq 'toplevel') {
    return [$self->fetch_top_level()];
  }

  return $self->{'_name_cache'}->{$name} || [];

  my $self = shift;
  my $dbID = shift;

  throw('dbID argument is required') if(!$dbID);

  my $cs = $self->{'_dbID_cache'}->{$dbID};

  return undef if(!$cs);

  return $cs;

  my $self = shift;
  my $name = lc(shift);
  my $version = lc(shift);  
  my $sbuild = $self->db->_get_schema_build($self->db->dnadb());
  my $assembly =  $self->db->get_CoordSystemAdaptor->fetch_by_name('chromosome')->version();
  my ($cs, $found_cs);
 
  throw('Mandatory argument\' name\'') if(! $name);

  #can we not just use
  #if(($name eq 'toplevel' || $name eq 'seqlevel') && ! $schema_build){
  #	throw('To access toplevel or seqlevel you must provide a the third schema_build argument');
  # }

  warn "Using dnadb(".$sbuild.") to acquire $name" if($name =~ /level/);

  if($name eq 'seqlevel') {
	return $self->fetch_sequence_level_by_schema_build($sbuild);
  } elsif($name eq 'toplevel') {
    return $self->fetch_top_level_by_schema_build($sbuild);
  }

  if(! exists($self->{'_name_cache'}->{$name})) {
    if($name =~ /top/) {
      warn("Did you mean 'toplevel' coord system instead of '$name'?");
    } elsif($name =~ /seq/) {
      warn("Did you mean 'seqlevel' coord system instead of '$name'?");
    }
    return undef;
  }


  my @coord_systems = @{$self->{'_name_cache'}->{$name}};
 
  #Filter versions if or get the default for the schema_build or comparable

  #This will only get non-versioned CSs if there are already loaded on a given schema_build
  #Hence we can never retrieve a 'comparable' supercontig if it has not been loaded onto the current schema_build
  #Hence we end up loading a new CS for each non-versioned level.
  
  foreach $cs (@coord_systems) {
	#Need if version first to allow for versioned and non-versioned supercontig level

    if($version) {
	  #we need to get the one which corresponds to the dnadb?
	  #mmmm, no, dnadb may be set to the latest schema_build
	  #which may not contain name version
	  #take the dnadb if present, or else the latest
	  #should we sort here or sort the caches in new
	  #what if we add a new schema_build?  Will that be cached and sorted?

	  if(lc($cs->version()) eq $version){
		$found_cs = $cs;
		last;
		#push @schema_css, $cs if(lc($cs->version()) eq $version);
	  }
	}elsif($cs->version eq $assembly){
	  #assume we want the current dnadb assembly version
	  #No longer need to check schema build as we a forcing the use of assembly version in eFG
	  $found_cs = $cs;
	  last;
	}


	  #if($cs->contains_schema_build($sbuild) && $cs->{'core_cache'}{$sbuild}{'DEFAULT'}){#exact match
	#	$found_cs = $cs;
	#	last;
	#  }else{#find best equivalent default
		
	#	foreach my $cache_sbuild(keys %{$cs->{'core_cache'}}){
	#	  warn "got cached $cache_sbuild matching against assembly $assembly";
		  
		  #we need to deal with the version here rather than the DB assembly_version string
		  
		  
	#	  #Find DB with same assembly and take default CS
	#	  if($cache_sbuild =~ /_${assembly}/ && $cs->{'core_cache'}{$cache_sbuild}{'DEFAULT'}){
	#		$found_cs = $cs;
	#		last;
	#	  }
	#	}
	#  }
	#}else{#non-assmebled levels e.g. clone
	#	#should only ever be one of these by definition		
	#	throw("Found more than one non-versioned CoordSystem:\t$name") if $found_cs;
	#	$found_cs = $cs;
	#  }
  }
  


  #should these throw?
  if(! $found_cs){
	if($version) {
	  warn "No coord system found for $sbuild version '$version'";
	  return undef;
	}else{
	  warn "Could not find default CoordSystem for '$sbuild', use next ranking?";
	  return undef
	}
  }



  #didn't find a default, just take first one
  #my $cs =  shift @coord_systems;
  #warning("No default version for coord_system [$name] exists. " .
  #    "Using version [".$cs->version()."] arbitrarily");

  return $found_cs;

  my $self = shift;
  my $rank = shift;

  thrw('not implemented rank cache yet');

  throw("Rank argument must be defined.") if(!defined($rank));
  throw("Rank argument must be a non-negative integer.") if($rank !~ /^\d+$/);

  if($rank == 0) {
    return $self->fetch_top_level();
  }

  return $self->{'_rank_cache'}->{$rank};

  my $self = shift;

  throw("Not yet implemented with schema_build");

  my @dbIDs = keys %{$self->{'_is_sequence_level'}};

  throw('No sequence_level coord_system is defined') if(!@dbIDs);

  if(@dbIDs > 1) {
    throw('Multiple sequence_level coord_systems are defined.' .
          'Only one is currently supported');
  }

  return $self->{'_dbID_cache'}->{$dbIDs[0]};

  my $self = shift;

  throw("Not yet implemented with schema_build");

  return $self->{'_top_level'};

  my $self = shift;
  my $cs1 = shift;
  my $cs2 = shift;

  if(!ref($cs1) || !ref($cs2) ||
     !$cs1->isa('Bio::EnsEMBL::CoordSystem') ||
     !$cs2->isa('Bio::EnsEMBL::CoordSystem')) {
    throw('Two Bio::EnsEMBL::CoordSystem arguments expected.');
  }

  my $key1 = $cs1->name() . ":" . $cs1->version();
  my $key2 = $cs2->name() . ":" . $cs2->version();

  my $path = $self->{'_mapping_paths'}->{"$key1|$key2"};

  return $path if($path);

  $path = $self->{'_mapping_paths'}->{"$key2|$key1"};

  if(!$path) {
    # No path was explicitly defined, but we might be able to guess a
    # suitable path.  We only guess for missing 2 step paths.

    my %mid1;
    my %mid2;

    foreach my $path (values(%{$self->{'_mapping_paths'}})) {
      next if(@$path != 2);

      my $match = undef;

      if($path->[0]->equals($cs1)) {
        $match = 1;
      } elsif($path->[1]->equals($cs1)) {
        $match = 0;
      }

      if(defined($match)) {
        my $mid = $path->[$match];
        my $midkey = $mid->name() . ':' . $mid->version();

        # is the same cs mapped to by other cs?
        if($mid2{$midkey}) {
          my $path = [$cs1,$mid,$cs2];
          $self->{'_mapping_paths'}->{"$key1|$key2"} = $path;
          $key1 =~ s/\:$//;
          $key2 =~ s/\:$//;
          $midkey =~ s/\:$//;
          warning("Using implicit mapping path between '$key1' and '$key2' " .
                  "coord systems.\n" .
                  "An explicit 'assembly.mapping' entry should be added " .
                  "to the meta table.\nExample: " .
                  "'$key1|$midkey|$key2'\n");
          return $path;
        } else {
          $mid1{$midkey} = $mid;
        }
      }

      $match = undef;

      if($path->[0]->equals($cs2)) {
        $match = 1;
      } elsif($path->[1]->equals($cs2)) {
        $match = 0;
      }


      if(defined($match)) {
        my $mid = $path->[$match];
        my $midkey = $mid->name() . ':' . $mid->version();

        # is the same cs mapped to by other cs?
        if($mid1{$midkey}) {
          my $path = [$cs2,$mid,$cs1];
          $self->{'_mapping_paths'}->{"$key2|$key1"} = $path;

          $key1 =~ s/\:$//;
          $key2 =~ s/\:$//;
          $midkey =~ s/\:$//;
          warning("Using implicit mapping path between '$key1' and '$key2' " .
                  "coord systems.\n" .
                  "An explicit 'assembly.mapping' entry should be added " .
                  "to the meta table.\nExample: " .
                  "'$key1|$midkey|$key2'\n");

          return $path;
        } else {
          $mid2{$midkey} = $mid;
        }
      }
    }
  }

  return $path || [];

  my $caller = shift;

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

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

  #
  # Cache the entire contents of the coord_system table cross-referenced
  # by dbID and name
  #

  #Funcgen specific
  #Added extra key on schema_build for all
  #keyed on name, list of coord_system value
  $self->{'_name_cache'} = {};

  #keyed on id, coord_system value
  $self->{'_dbID_cache'} = {};

  #keyed on rank
  #$self->{'_rank_cache'} = {};

  #keyed on id, 1/undef values
  $self->{'_is_sequence_level'} = {};
  $self->{'_is_default_version'} = {};
  
  my $sql = 'SELECT coord_system_id, name, rank, version, attrib, schema_build, core_coord_system_id FROM coord_system';
  my @args;
  if($self->is_multispecies()) {
  	$sql.=' where species_id =?';
  	push(@args, $self->species_id());
  }
	$sql.=' order by coord_system_id';
  my $sth = $self->prepare($sql);
  $sth->execute(@args);

  my ($dbID, $name, $rank, $version, $attrib, $sbuild, $ccs_id, $cs);
  $sth->bind_columns(\$dbID,\$ name,\$ rank,\$ version,\$ attrib,\$ sbuild,\$ ccs_id);

  while($sth->fetch()) {
    my $seq_lvl = 0;
    my $default = 0;


	#what we need is an add schema_build, seq_level, default, rank method
	#name and version shoudl be same for one CS

	if($attrib) {
      foreach my $attrib (split(',', $attrib)) {
        $self->{"_is_$attrib"}->{$dbID} = 1;
        if($attrib eq 'sequence_level') {
          $seq_lvl = 1;
        } elsif($attrib eq 'default_version') {
          $default = 1;
        }
      }
    }


	#Found new name, version pair
	if(! $cs || ($dbID != $cs->dbID())){

	  if($cs){

		#handle caching here
		
		#the get methods which utilise these caches need to sort the results based on the latest schema build.
		#or maybe instead of just having one name, where cat the schema_build, but point to the same cs
		#so loop through all the schema build for one CS?


		$self->{'_dbID_cache'}->{$cs->dbID()} = $cs;



		#Right then
		#Unless we're querying by cs_id from the eFG DB then we will always need
		#schema_build&level||rank or name&version

		#No point in having NR rank cache, need to resolve with schema_build?
		#Name 
		#have schema_build as optional arg in all methods, get from BDAdaptor if not defined?
		#This will just match the schema build to the current eFG DB

		$self->{'_name_cache'}->{lc($cs->name())} ||= [];
		#$self->{'_rank_cache'}->{$rank} ||= [];
		

		#push @{$self->{'_rank_cache'}->{$rank}}, $cs;
		push @{$self->{'_name_cache'}->{lc($cs->name())}}, $cs;
		


	  }


	  $cs = Bio::EnsEMBL::Funcgen::CoordSystem->new
		(-DBID           => $dbID,
		 -ADAPTOR        => $self,
		 -NAME           => $name,
		 -VERSION        => $version,
		 #-RANK           => $rank,
		 #-SEQUENCE_LEVEL => $seq_lvl,
		 #-DEFAULT        => $default,
		 #-SCHEMA_BUILD   => $sbuild,
		 #-CORE_COORD_SYSTEM_ID => $ccs_id
	  );
	}


	#could we fetch the actual core CS here, and add it to the eFG coord sys?
	#or should we just handle the individual args?
	#do we need to write generic method in DBAdaptor for this, then we can use the 
	#CSAdaptor as a cache for all DBAdaptor(CSs) should we not use reg for this?

	#we could populate objects from new rather than from db, then create adaptor as required?
	#still need to store is stored in CD?  and also we need to test everytime to see if we have an adaptor

	$cs->add_core_coord_system_info(
									-RANK                 => $rank,
									-SEQUENCE_LEVEL       => $seq_lvl,
									-DEFAULT              => $default,
									-SCHEMA_BUILD         => $sbuild,
									-CORE_COORD_SYSTEM_ID => $ccs_id,
									-IS_STORED            => 1,
									);

	#orig


    #if($attrib) {
    #  foreach my $attrib (split(',', $attrib)) {
    #    $self->{"_is_$attrib"}->{$dbID} = 1;
    #    if($attrib eq 'sequence_level') {
    #      $seq_lvl = 1;
    #    } elsif($attrib eq 'default_version') {
    #      $default = 1;
    #    }
    #  }
    #}

    #my $cs = Bio::EnsEMBL::Funcgen::CoordSystem->new
    #  (-DBID           => $dbID,
    #   -ADAPTOR        => $self,
    #   -NAME           => $name,
    #   -VERSION        => $version,
    #   -RANK           => $rank,
    #   -SEQUENCE_LEVEL => $seq_lvl,
	#   -DEFAULT        => $default,
	#   -SCHEMA_BUILD   => $sbuild,
	# );


	#can we change these caches to use just the name and version rather than schema_build?

	#$self->{'_sb_name_cache'}->{$sbuild.":".lc($name)} ||= [];
    #$self->{'_dbID_cache'}->{$dbID} = $cs;
    #$self->{'_sb_rank_cache'}->{$sbuild.":".$rank} = $cs;
    #push @{$self->{'_sb_name_cache'}->{$sbuild.":".lc($name)}}, $cs;
  }


  #handle last cs
 
  if($cs){
	$self->{'_dbID_cache'}->{$cs->dbID()} = $cs;
	#push @{$self->{'_rank_cache'}->{$rank}}, $cs;
	push @{$self->{'_name_cache'}->{lc($cs->name())}}, $cs;
  }

  $sth->finish();



  #Get rid?  Let core handle this
  #No mapping paths present in meta table!

  #
  # Retrieve a list of available mappings from the meta table.
  # this may eventually be moved a table of its own if this proves too
  # cumbersome
  #

  #my %mapping_paths;
  #my $mc = $self->db()->get_MetaContainer();


 #MAP_PATH:
  #foreach my $map_path (@{$mc->list_value_by_key('assembly.mapping')}) {
  #  my @cs_strings = split(/[|#]/, $map_path);

#    if(@cs_strings < 2) {
#      warning("Incorrectly formatted assembly.mapping value in meta " .
#              "table: $map_path");
#      next MAP_PATH;
#    }

#    my @coord_systems;
#    foreach my $cs_string (@cs_strings) {
#      my($name, $version) = split(/:/, $cs_string);
#      my $cs = $self->fetch_by_name($name, $version);
#      if(!$cs) {
#        warning("Unknown coordinate system specified in meta table " .
#                " assembly.mapping:\n  $name:$version");
#        next MAP_PATH;
#      }
#      push @coord_systems, $cs;
#    }

    # if the delimiter is a # we want a special case, multiple parts of the same
    # componente map to same assembly part. As this looks like the "long" mapping
    # we just make the path a bit longer :-)

#    if( $map_path =~ /\#/ && scalar( @coord_systems ) == 2 ) {
#      splice( @coord_systems, 1, 0, ( undef ));
#    }

#    my $cs1 = $coord_systems[0];
#    my $cs2  = $coord_systems[$#coord_systems];

#    my $key1 = $cs1->name().':'.$cs1->version();
#    my $key2 = $cs2->name().':'.$cs2->version();

#    if(exists($mapping_paths{"$key1|$key2"})) {
#      warning("Meta table specifies multiple mapping paths between " .
#              "coord systems $key1 and $key2.\n" .
#              "Choosing shorter path arbitrarily.");#

#      next MAP_PATH if(@{$mapping_paths{"$key1|$key2"}} < @coord_systems);
#    }

#    $mapping_paths{"$key1|$key2"} = \@coord_systems;
#  }

  #
  # Create the pseudo coord system 'toplevel' and cache it so that
  # only one of these is created for each db...
  #
  

  #Not yet implemented across multiple dbs
  #my $toplevel = Bio::EnsEMBL::Funcgen::CoordSystem->new(-TOP_LEVEL => 1,
  #														 -NAME      => 'toplevel',
  #														 -ADAPTOR   => $self);
  # $self->{'_top_level'} = $toplevel;

  #$self->{'_mapping_paths'} = \%mapping_paths;

  return $self;

  my $self = shift;
  my $cs = shift;

  if(!$cs || !ref($cs) || !$cs->isa('Bio::EnsEMBL::Funcgen::CoordSystem')) {
    throw('CoordSystem argument expected.');
  }

  my $sth;
  my $db = $self->db();
  my $name = $cs->name();
  my $version = $cs->version();

  if($name eq 'toplevel' || $name eq 'seqlevel' || !$name) {
    throw("[$name] is not a valid name for a storable CoordSystem.");
  } 
  
  foreach my $sbuild(keys %{$cs->{'core_cache'}}){
	my $rank    = $cs->{'core_cache'}->{$sbuild}->{'RANK'};
	my $seqlevel = $cs->{'core_cache'}->{$sbuild}->{'SEQUENCE_LEVEL'};
	my $default  = $cs->{'core_cache'}->{$sbuild}->{'DEFAULT'};
	my $ccs_id = $cs->{'core_cache'}->{$sbuild}->{'CORE_COORD_SYSTEM_ID'};

	#
	# Do lots of sanity checking to prevent bad data from being entered
	#
	
	if($cs->{'core_cache'}->{$sbuild}->{'IS_STORED'}) {
	  #Doesn't this only check on dbID?
	  next;
	}

 
	#if($seqlevel && keys(%{$self->{'_is_sequence_level'}})) {
	#  throw("There can only be one sequence level CoordSystem.");
	#}

	#if(exists $self->{'_name_cache'}->{lc($name)}) {
	#  my @coord_systems = @{$self->{'_name_cache'}->{lc($name)}};

	#  foreach my $c (@coord_systems) {
	#	if(lc($c->version()) eq lc($version)) {
	#	  warning("CoordSystem $name $version is already in db.\n");
	#	  return;
	#	}
	#	if($default && $self->{'_is_default_version'}->{$c->dbID()}) {
	#	  throw("There can only be one default version of CoordSystem $name");
	#	}
	#  }
	#}

	if($rank !~ /^\d+$/) {
	  throw("Rank attribute must be a positive integer not [$rank]");
	}

	if($rank == 0) {
	  throw("Only toplevel CoordSystem may have rank of 0.");
	}

	#if(defined($self->{'_rank_cache'}->{$rank})) {
	#  throw("CoordSystem with rank [$rank] already exists.");
	#}

	my @attrib;

	push @attrib, 'default_version' if($default);
	push @attrib, 'sequence_level' if($seqlevel);

	my $attrib_str = (@attrib) ? join(',', @attrib) : undef;

	#
	# store the coordinate system in the database
	#
	
	if(! $cs->dbID()){
		
		$sth = $self->prepare('insert into coord_system (name, version, attrib, rank, schema_build, core_coord_system_id, species_id) values (?,?,?,?,?,?,?)');  

	  $sth->bind_param(1, $name,               SQL_VARCHAR);
	  $sth->bind_param(2, $version,            SQL_VARCHAR);
	  $sth->bind_param(3, $attrib_str,         SQL_VARCHAR);
	  $sth->bind_param(4, $rank,               SQL_INTEGER);
	  $sth->bind_param(5, $sbuild,             SQL_VARCHAR);
	  $sth->bind_param(6, $ccs_id,             SQL_INTEGER);
	  $sth->bind_param(7, $self->species_id(), SQL_INTEGER);

	  $sth->execute();
	  my $dbID = $sth->{'mysql_insertid'};
	  $sth->finish();

	  if(!$dbID) {
		throw("Did not get dbID from store of CoordSystem.");
	  }

	  $cs->dbID($dbID);
	  $cs->adaptor($self);
	}else{
	  #can we prep this out of the loop
	  #we don't know until we're in it
		my $sql = 'insert into coord_system (coord_system_id, name, version, attrib, rank, schema_build, core_coord_system_id, species_id) values (?,?,?,?,?,?,?,?)';
	  $sth = $db->dbc->prepare($sql);

	  $sth->bind_param(1, $cs->dbID(),         SQL_INTEGER);
	  $sth->bind_param(2, $name,               SQL_VARCHAR);
	  $sth->bind_param(3, $version,            SQL_VARCHAR);
	  $sth->bind_param(4, $attrib_str,         SQL_VARCHAR);
	  $sth->bind_param(5, $rank,               SQL_INTEGER);
	  $sth->bind_param(6, $sbuild,             SQL_VARCHAR);
	  $sth->bind_param(7, $ccs_id,             SQL_INTEGER);
	  $sth->bind_param(8, $self->species_id(), SQL_INTEGER);
	  $sth->execute();
	  $sth->finish();
	}
	
	$cs->{'core_cache'}{$sbuild}{'IS_STORED'} = 1;


  }

 
  #
  # update the internal caches that are used for fetching
  #
  #$self->{'_is_default_version'}->{$dbID} = 1 if($default);
  #$self->{'_is_sequence_level'}->{$dbID} = 1 if($seqlevel);

  $self->{'_name_cache'}->{lc($name)} ||= [];
  #$self->{'_rank_cache'}->{$rank} ||= [];
  $self->{'_dbID_cache'}->{$cs->dbID()} = $cs;
  #this will duplicate CS in cache if we add a core cs and then store
  #same with rank cache, need to replace
  my $push = 1;

  foreach my $name_cs(@{$self->{'_name_cache'}->{lc($name)}}){
	
	if($name_cs->version() eq $cs->version()){
	  $push = 0;
	  $name_cs = $cs;
	}
  }

  push @{$self->{'_name_cache'}->{lc($name)}}, $cs if $push;

  #$push = 1;

  

  #this could result in mixed rank cs in the same rank cache
  #push @{$self->{'_rank_cache'}->{$rank}}, $cs;
  #need to rethink rank cache?  make it schema_rank cache
  

  return $cs;

  my ($self, $cs) = @_;
	
  if(! (ref($cs) && $cs->isa('Bio::EnsEMBL::CoordSystem') && $cs->dbID())){
	throw('Must provide a valid stored Bio::EnsEMBL::CoordSystem');
  }
  

  #Need to add to Funcgen coord_system here
  #check if name and version are present and reset coord_system_id to that one, else get last ID and create a new one
  #coord_system_ids will not match those in core DBs, so we need ot be mindful about this.
  #can't use is_stored as this simply checks the dbID
  #seq_region_ids may change between schemas with the same assembly version
  #Store schema_version in coord_system and create seq_region translation
  #table to maintain the seq_region_id mapping back to each core DB

  
  #Do we need to check the the dnadb and the slice db match?
  #Do we have to have specified a dnadb at this point?  No.
  #But need to put checks in place for dnadb methods i.e. seq/slice retrieval





  my $sbuild = $self->db->_get_schema_build($cs->adaptor->db());

  #this should implicitly use the current schema_build
  #hence providing specificty for non-version CS's e.g. supercontig etc...
  my $fg_cs = $self->fetch_by_name($cs->name(), $cs->version());


  #this needs to satify both schema_build and version
  #retrieving by name version should retunr the lastest schema_build unless the it is not the toplevel or highest expected rank?
  
  my $version;

  if(! $fg_cs){
	
		if($cs->name ne 'clone' && (! $cs->version)){
	  	#NO VERSION for assembled level !!
	  	#Assume the default version
	  	#we could get this from meta, but is unreliable
	  	#get from default chromosome version
	  	my $tmp_cs = $cs->adaptor->fetch_by_name('chromosome');
	  	$version = $tmp_cs->version;
		}

	
		$fg_cs = Bio::EnsEMBL::Funcgen::CoordSystem->new(
													 -NAME    => $cs->name(),
													 -VERSION => $version || $cs->version(),
													);

		warn "Created new CoordSystem:\t".$fg_cs->name().":".$fg_cs->version()."\n";
  }


  #This is done in BaseFeatureAdaptor->_pre_store
  #to avoid users without write permission trying 
  #to store olf assemblies on new shema_builds 
  #on old schema_build which are already present
  #If the CS can't be found then you're probably 
  #importing for the first time and have write permissions

  #re-instated as we don't want any extra calls in _pre_store
  #as this iterates over every features stored
  #increasing import time.

  if(! $fg_cs->contains_schema_build($sbuild)){
	
	$fg_cs->add_core_coord_system_info(
									   -RANK                 => $cs->rank(), 
									   -SEQUENCE_LEVEL       => $cs->is_sequence_level(), 
									   -DEFAULT              => $cs->is_default(), 
									   -SCHEMA_BUILD         => $sbuild, 
									   -CORE_COORD_SYSTEM_ID => $cs->dbID(),
									   -IS_STORED            => 0,
									  );
	
	eval {  $fg_cs = $self->store($fg_cs) };
	
	if($@){
	  warning("$@\nYou do not have permisson to store the CoordSystem for schema_build $sbuild\n".
		"Using comparable CoordSystem:\t".$fg_cs->name.':'.$fg_cs->version."\n");
	}
  }
  
  return $fg_cs;
}


1;

  Arg [1]    : 
  Example    : 
  Description: 
  Returntype : 
  Exceptions : 
  Caller     : 
  Status     : At risk

  Arg [1]    : 
  Example    : 
  Description: 
  Returntype : 
  Exceptions : 
  Caller     : 
  Status     : At risk