Toolbar

Summary

GenomicAlignTreeAdaptor - Object used to store and retrieve GenomicAlignTrees to/from the databases

Package variables

Included modules

Inherit

Bio::EnsEMBL::Compara::DBSQL::NestedSetAdaptor

Synopsis

Description

This version of the module is still very experimental.

Methods

Methods description

  Args[1]    : DBI::row_hashref $hashref containing key-value pairs
  Example    :  my $genomic_align_group = $self->_create_GenomicAlignGroup_object_from_rowhash($rowhash);
  Description: convert DBI row hash reference into a 
               Bio::EnsEMBL::Compara::GenomicAlignGroup object
  Returntype : Bio::EnsEMBL::Compara::GenomicAlignGroup object
  Exceptions : none
  Caller     : general
  Status     : At risk

  Args[1]    : DBI::row_hashref $hashref containing key-value pairs
  Example    : my $genomic_align = $self->_create_GenomicAlign_object_from_rowhash($rowhash);
  Description: convert DBI row hash reference into a 
               Bio::EnsEMBL::Compara::GenomicAlign object
  Returntype : Bio::EnsEMBL::Compara::GenomicAlign object
  Exceptions : none
  Caller     : general
  Status     : At risk

  Args[1]    : DBI::row_hashref $hashref containing key-value pairs
  Example    :   my $genomic_align_trees = $self->_objs_from_sth($sth);
  Description: convert DBI row hash reference into a 
               Bio::EnsEMBL::Compara::GenomicAlignTreeAdaptor object
  Returntype : listref of Bio::EnsEMBL::Compara::GenomicAlignTree objects
  Exceptions : none
  Caller     : general
  Status     : At risk

  Args       : none
  Example    : $columns = $self->columns()
  Description: a list of [tablename, alias] pairs for use with generic_fetch
  Returntype : list of [tablename, alias] pairs
  Exceptions : none
  Caller     : NestedSetAdaptor::generic_fetch
  Status     : At risk

  Args[1]    : DBI::row_hashref $hashref containing key-value pairs
  Example    : my $node = $self->create_instance_from_rowhash($rowhash);
  Description: convert DBI row hash reference into a 
               Bio::EnsEMBL::Compara::GenomicAlignTree object
  Returntype : Bio::EnsEMBL::Compara::GenomicAlignTree object
  Exceptions : none
  Caller     : general
  Status     : At risk

  Args       : none
  Example    : none
  Description: a where clause for use with generic_fetch
  Returntype : none
  Exceptions : none
  Caller     : NestedSetAdaptor::generic_fetch
  Status     : At risk

  Arg  1     : reference to Bio::EnsEMBL::Compara::GenomicAlignTree
  Example    : $genomic_align_tree_adaptor->delete($root);
  Description: Method for deleting a Bio::EnsEMBL::Compara::GenomicAlignTree
               from a database. Must give the root ie does not delete
               sub-trees.
  Returntype : none
  Exceptions : none
  Caller     : none
  Status     : At risk

  Arg  1     : Bio::EnsEMBL::Compara::MethodLinkSpeciesSet $method_link_species_set
  Arg  2     : integer $limit_number [optional]
  Arg  3     : integer $limit_index_start [optional]
  Example    : my $genomic_align_trees =
                  $genomic_align_tree_adaptor->
                      fetch_all_by_MethodLinkSpeciesSet($mlss);
  Description: Retrieve the corresponding
               Bio::EnsEMBL::Compara::GenomicAlignTree objects. Objects 
  Returntype : ref. to an array of Bio::EnsEMBL::Compara::GenomicAlignTree objects.
  Exceptions : Returns ref. to an empty array if no matching
               Bio::EnsEMBL::Compara::GenomicAlignTree object can be retrieved
  Caller     : none
  Status     : At risk

  Arg  1     : Bio::EnsEMBL::Compara::MethodLinkSpeciesSet $method_link_species_set
  Arg  2     : Bio::EnsEMBL::Compara::DnaFrag $dnafrag
  Arg  3     : integer $start [optional, default = 1]
  Arg  4     : integer $end [optional, default = dnafrag_length]
  Arg  5     : integer $limit_number [optional, default = no limit]
  Arg  6     : integer $limit_index_start [optional, default = 0]
  Arg  7     : boolean $restrict_resulting_blocks [optional, default = no restriction]
  Example    : my $genomic_align_trees =
                  $genomic_align_tree_adaptor->fetch_all_by_MethodLinkSpeciesSet_DnaFrag(
                      $mlss, $dnafrag, 50000000, 50250000);
  Description: Retrieve the corresponding
               Bio::EnsEMBL::Compara::GenomicAlignTree objects. 
  Returntype : ref. to an array of Bio::EnsEMBL::Compara::GenomicAlignTree objects. Only dbID,
               adaptor and method_link_species_set are actually stored in the objects. The remaining
               attributes are only retrieved when requiered.
  Exceptions : Returns ref. to an empty array if no matching
               Bio::EnsEMBL::Compara::GenomicAlignTree object can be retrieved
  Caller     : none
  Status     : At risk

  Arg  1     : Bio::EnsEMBL::Compara::MethodLinkSpeciesSet $method_link_species_set
  Arg  2     : Bio::EnsEMBL::Slice $original_slice
  Arg  3     : integer $limit_number [optional]
  Arg  4     : integer $limit_index_start [optional]
  Arg  5     : boolean $restrict_resulting_blocks [optional]
  Example    : my $genomic_align_trees =
                  $genomic_align_tree_adaptor->fetch_all_by_MethodLinkSpeciesSet_Slice(
                      $method_link_species_set, $original_slice);
  Description: Retrieve the corresponding
               Bio::EnsEMBL::Compara::GenomicAlignTree objects. The alignments may be
               reverse-complemented in order to match the strand of the original slice.
  Returntype : ref. to an array of Bio::EnsEMBL::Compara::GenomicAlignTree objects. Only dbID,
               adaptor and method_link_species_set are actually stored in the objects. The remaining
               attributes are only retrieved when required.
  Exceptions : Returns ref. to an empty array if no matching
               Bio::EnsEMBL::Compara::GenomicAlignTree object can be retrieved
  Caller     : $object->method_name
  Status     : At risk

  Arg  1     : reference to Bio::EnsEMBL::Compara::GenomicAlignTree
  Example    : my $node = $self->adaptor->fetch_all_children_for_node($self);
  Description: Over-ride NestedSetAdaptor method for getting the all the children of a node
  Returntype : reference to Bio::EnsEMBL::Compara::GenomicAlignTree
  Exceptions : throw if not Bio::EnsEMBL::Compara::NestedSet
  Caller     : 
  Status     : At risk

  Arg  1     : Bio::EnsEMBL::Compara::GenomicAlignBlock $genomic_align_block
  Example    : my $genomic_align_tree =
                  $genomic_align_tree_adaptor->fetch_by_GenomicAlignBlock($gab_id);
  Description: Retrieve the corresponding
               Bio::EnsEMBL::Compara::GenomicAlignTree object. 
  Returntype : Bio::EnsEMBL::Compara::GenomicAlignTree object. 
  Exceptions : Returns ref. to an empty array if no matching
               Bio::EnsEMBL::Compara::GenomicAlignTree object can be retrieved
  Caller     : $object->method_name
  Status     : At risk

  Arg  1     : $node_id
  Example    : my $node = $self->adaptor->fetch_node_by_node_id($node_id);
  Description: Over-ride NestedSetAdaptor method for getting a node from its id
  Returntype : reference to Bio::EnsEMBL::Compara::GenomicAlignTree
  Exceptions : throw if not Bio::EnsEMBL::Compara::NestedSet
  Caller     : 
  Status     : At risk

  Arg  1     : reference to Bio::EnsEMBL::Compara::GenomicAlignTree
  Example    : my $parent = $self->adaptor->fetch_parent_for_node($self);
  Description: Over-ride NestedSetAdaptor method for getting the parent of a node
  Returntype : reference to Bio::EnsEMBL::Compara::GenomicAlignTree
  Exceptions : throw if not Bio::EnsEMBL::Compara::NestedSet
  Caller     : 
  Status     : At risk

  Arg  1     : reference to Bio::EnsEMBL::Compara::GenomicAlignTree
  Example    : my $root = $self->adaptor->fetch_root_by_node($self);
  Description: Over-ride NestedSetAdaptor method for getting the root of a node
  Returntype : reference to Bio::EnsEMBL::Compara::GenomicAlignTree
  Exceptions : throw if not Bio::EnsEMBL::Compara::NestedSet
  Caller     : 
  Status     : At risk

  Args[1]    : Bio::EnsEMBL::Compara::GenomicAlignTree object
  Args[2]    : DBI::row_hashref $hashref containing key-value pairs
  Example    : $self->init_instance_from_rowhash($node, $rowhash);
  Description: convert DBI row hash reference into a 
               Bio::EnsEMBL::Compara::GenomicAlignTree object
  Returntype : Bio::EnsEMBL::Compara::GenomicAlignTree object
  Exceptions : none
  Caller     : general
  Status     : At risk

  Args       : none
  Example    : none
  Description: a left join clause for use with generic_fetch
  Returntype : none
  Exceptions : none
  Caller     : NestedSetAdaptor::generic_fetch
  Status     : At risk

  Arg  1     : reference to Bio::EnsEMBL::Compara::GenomicAlignTree
  Arg  2     : int $flanking
  Example    : $self->update_neighbourhood_data($node);
  Description: Update the left and right node_ids of a genomic_align_tree
               table in a database
  Returntype : none
  Exceptions : none
  Caller     : none
  Status     : At risk

  Arg 1       : Bio::EnsEMBL::Compara::GenomicAlignTree $root
  Arg[2]      : [optional] bool $skip_left_right_indexes
  Example     : $gata->store($root);
  Description : This method stores the GenomicAlign in the tree,
                the corresponding GenomicAlignBlock(s) and all
                the GenomicAlignTree nodes in this tree. If you set
                the $skip_left_right_indexes flag to any true value,
                the left and right indexes in the tree won't be build
                at this point. This may be useful for production
                purposes as building the indexes requires to lock the
                table and can hamper other processes storing data at
                that time.
                This method expects a structure like this:
                GENOMIC_ALIGN_TREE->
                  - GENOMIC_ALIGN_GROUP->
                      - GENOMIC_ALIGNs...
                  - GENOMIC_ALIGN_TREE->
                      - GENOMIC_ALIGN_GROUP->
                          - GENOMIC_ALIGNs...
                      - GENOMIC_ALIGN_TREE->
                          - GENOMIC_ALIGN_GROUP->
                              - GENOMIC_ALIGNs...
                      - GENOMIC_ALIGN_TREE->
                          - GENOMIC_ALIGN_GROUP->
                              - GENOMIC_ALIGN...
                  - GENOMIC_ALIGN_TREE->
                      - GENOMIC_ALIGN_GROUP->
                          - GENOMIC_ALIGN...

                I.e. each node has 1 GenomicAlignGroup containing 1 or
                more GenomicAligns and optionally 2 GenomicAlignTree objects
                representing the sub_nodes. These will also contain 1
                GenomicAlignGroup containing 1 or more GenomicAligns, etc.
                No GenomicAlignBlock is expected. These will be created
                and stored by this method.

  Exceptions  : throws if any of the nodes of the tree misses its
                GenomicAlign object or this one misses its
                GenomicAlignBlock objects.
  Caller      : general
  Status      : At risk

  Arg  1     : reference to Bio::EnsEMBL::Compara::GenomicAlignTree
  Example    : $genomic_align_tree_adaptor->store_group($genomic_align_tree);
  Description: Method for storing the group_id for a genomic_align_tree. The
               group_id is set as the genomic_align_block_id of the first
               genomic_align object
  Returntype : none
  Exceptions : - cannot lock tables
               - cannot update GenomicAlignBlock object
  Caller     : none
  Status     : At risk

  Arg  1     : reference to Bio::EnsEMBL::Compara::GenomicAlignTree
  Example    : $genomic_align_tree_adaptor->store_node($genomic_align_tree);
  Description: Method for storing a single node. Called recursively.
  Returntype : none
  Exceptions : throw if no genomic_align_group ID has been set
  Caller     : none
  Status     : At risk

  Args       : none
  Example    : $tables = $self->_tables()
  Description: a list of [tablename, alias] pairs for use with generic_fetch
  Returntype : list of [tablename, alias] pairs
  Exceptions : none
  Caller     : NestedSetAdaptor::generic_fetch
  Status     : At risk

  Arg  1     : reference to Bio::EnsEMBL::Compara::GenomicAlignTree
  Arg  2     : boolean $no_recursivity
  Example    : $self->update_neighbourhood_data($node);
  Description: Update the left and right node_ids of a genomic_align_tree
               table in a database
  Returntype : none
  Exceptions : none
  Caller     : none
  Status     : At risk

Methods code

sub _create_GenomicAlignGroup_object_from_rowhash {

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

  return undef if (!$rowhash->{group_id});

  my $genomic_align_group = new Bio::EnsEMBL::Compara::GenomicAlignGroup;
  $genomic_align_group->dbID($rowhash->{group_id});
  $genomic_align_group->adaptor($self->db->get_GenomicAlignGroupAdaptor);
  $genomic_align_group->type($rowhash->{type});

  return $genomic_align_group;

}

sub _create_GenomicAlign_object_from_rowhash {

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

  my $genomic_align = new Bio::EnsEMBL::Compara::GenomicAlign;
  $genomic_align->dbID($rowhash->{genomic_align_id});
  $genomic_align->adaptor($self->db->get_GenomicAlignAdaptor);
  $genomic_align->genomic_align_block_id($rowhash->{genomic_align_block_id});
  $genomic_align->method_link_species_set_id($rowhash->{method_link_species_set_id});
  $genomic_align->dnafrag_id($rowhash->{dnafrag_id});
  $genomic_align->dnafrag_start($rowhash->{dnafrag_start});
  $genomic_align->dnafrag_end($rowhash->{dnafrag_end});
  $genomic_align->dnafrag_strand($rowhash->{dnafrag_strand});
  $genomic_align->cigar_line($rowhash->{cigar_line});
  $genomic_align->level_id($rowhash->{level_id});

  return $genomic_align;
}

1;

}

sub _objs_from_sth {

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

  my $node_list = [];
  my $genomic_align_groups = {};
  my $genomic_aligns = {};
  while(my $rowhash = $sth->fetchrow_hashref) {
    if (!defined($rowhash->{group_id})) {
       my $node = $self->create_instance_from_rowhash($rowhash);
       push @$node_list, $node;
    } else {
       my $genomic_align_group = $genomic_align_groups->{$rowhash->{group_id}};
       if (!defined($genomic_align_group)) {
	  ## This is a new node
	  my $node = $self->create_instance_from_rowhash($rowhash);
	  $genomic_align_group = $node->genomic_align_group;
	  $genomic_align_groups->{$rowhash->{group_id}} = $genomic_align_group;
	  push @$node_list, $node;
       }
       if (!defined($genomic_aligns->{$rowhash->{genomic_align_id}})) {
	 my $genomic_align = $self->_create_GenomicAlign_object_from_rowhash($rowhash);
	 $genomic_align_group->add_GenomicAlign($genomic_align);
	 $genomic_aligns->{$rowhash->{genomic_align_id}} = 1;
       }
     }
  }
  return $node_list;

}

sub columns {

  my $self = shift;
  return ['gat.node_id',
          'gat.parent_id',
          'gat.root_id',
          'gat.left_index',
          'gat.right_index',
          'gat.distance_to_parent',
          'gat.left_node_id',
          'gat.right_node_id',
          'gag.group_id',
          'gag.type',
          'ga.genomic_align_id',
          'ga.genomic_align_block_id',
          'ga.method_link_species_set_id',
          'ga.dnafrag_id',
          'ga.dnafrag_start',
          'ga.dnafrag_end',
          'ga.dnafrag_strand',
          'ga.cigar_line',
          'ga.level_id',
          ];

}

sub create_instance_from_rowhash {

  my $self = shift;
  my $rowhash = shift;

  my $node = new Bio::EnsEMBL::Compara::GenomicAlignTree;

  $self->init_instance_from_rowhash($node, $rowhash);
  my $genomic_align_group = $self->_create_GenomicAlignGroup_object_from_rowhash($rowhash);
  $node->genomic_align_group($genomic_align_group) if ($genomic_align_group);

  return $node;

}

sub default_where_clause {

  return "gat.node_id = gag.group_id AND gag.genomic_align_id = ga.genomic_align_id";
#  return "";

}

sub delete {

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

  if (!$root) {
    throw("Nothing to delete");
  }

  if ($root->root ne $root) {
    warn("Cowardly refusing to delete a subtree only");
    return;
  }

  my $sth = $self->prepare(
      "DELETE
        genomic_align_group.*,
        genomic_align_tree.*,
        genomic_align.*,
        genomic_align_block.*
      FROM
        genomic_align_tree
        LEFT JOIN genomic_align_group ON (node_id = group_id)
        LEFT JOIN genomic_align USING (genomic_align_id)
        LEFT JOIN genomic_align_block USING (genomic_align_block_id)
      WHERE root_id = ?");
  $sth->execute($root->node_id);

}

sub fetch_all_by_MethodLinkSpeciesSet {

  my ($self, $method_link_species_set, $limit_number, $limit_index_start) = @_;
  my $genomic_align_trees = [];

  throw("[$method_link_species_set] is not a Bio::EnsEMBL::Compara::MethodLinkSpeciesSet object")
      unless ($method_link_species_set and ref $method_link_species_set and
          $method_link_species_set->isa("Bio::EnsEMBL::Compara::MethodLinkSpeciesSet"));
  my $method_link_species_set_id = $method_link_species_set->dbID;
  throw("[$method_link_species_set_id] has no dbID") if (!$method_link_species_set_id);

  my $constraint = "WHERE ga.method_link_species_set_id = $method_link_species_set_id AND gat.parent_id = 0";
  my $final_clause = "";
  if ($limit_number) {
    $limit_index_start = 0 if (!$limit_index_start);
    $final_clause = "LIMIT $limit_index_start, $limit_number";
  }
  $genomic_align_trees = $self->_generic_fetch($constraint, undef, $final_clause);

  return $genomic_align_trees;

}

sub fetch_all_by_MethodLinkSpeciesSet_DnaFrag {

  my ($self, $method_link_species_set, $dnafrag, $start, $end, $limit_number, $limit_index_start, $restrict) = @_;

  ## Get internal IDs from the objects
  my $method_link_species_set_id = $method_link_species_set->dbID;
  my $dnafrag_id = $dnafrag->dbID;

  ###########################################################################
  ## FIRST STEP:
  ## The query looks for GenomicAlign entries in the genomic region of interest
  ## and links to the GenomicAlignGroup and GenomicAlignTree entries. We extract
  ## the list of node IDs for the root of the GenomicAlignTrees
  ###########################################################################
  my $constraint = "WHERE ga.method_link_species_set_id = $method_link_species_set_id
      AND ga.dnafrag_id = $dnafrag_id";

  if (defined($start) and defined($end)) {
    my $max_alignment_length = $method_link_species_set->max_alignment_length;
    my $lower_bound = $start - $max_alignment_length;
    $constraint .= qq{
            AND ga.dnafrag_start <= $end
            AND ga.dnafrag_start >= $lower_bound
            AND ga.dnafrag_end >= $start
        };
  }

  my $sql = $self->_construct_sql_query($constraint);
  my $sth = $self->prepare($sql);
  $sth->execute();
  my $ref_to_root_hash = {};
  while(my $rowhash = $sth->fetchrow_hashref) {
    my $root_node_id = $rowhash->{root_id};
    my $reference_genomic_align_id = $rowhash->{genomic_align_id};
    $ref_to_root_hash->{$reference_genomic_align_id} = $root_node_id;
    print "REF $reference_genomic_align_id} = $root_node_id\n";
  }
  $sth->finish();
  return [] if (!%$ref_to_root_hash);

  ###########################################################################
  ## SECOND STEP:
  ## Get all the nodes for the root IDs we got in step 1
  ###########################################################################
  my $genomic_align_trees = [];
  while (my ($reference_genomic_align_id, $root_node_id) = each %$ref_to_root_hash) {
    $constraint = "WHERE gat.root_id = $root_node_id";
    my $genomic_align_nodes = $self->_generic_fetch($constraint);
    my $root = $self->_build_tree_from_nodes($genomic_align_nodes);
    my $all_leaves = $root->get_all_leaves;
    for (my $i = 0; $i < @$all_leaves; $i++) {
      my $this_leaf = $all_leaves->[$i];
      my $all_genomic_aligns = $this_leaf->get_all_GenomicAligns;
      foreach my $this_genomic_align (@$all_genomic_aligns) {
        if ($this_genomic_align->dbID == $reference_genomic_align_id) {
          $root->reference_genomic_align($this_genomic_align);
          $root->reference_genomic_align_node($this_leaf);
          if (@$all_genomic_aligns > 1) {
            ## Reference hits a composite GenomicAlign. We have to restrict the tree
            my $cigar_line = $this_genomic_align->cigar_line;
            my ($start, $end) = (1, $this_genomic_align->length);
            if ($cigar_line =~ /^(\d*)X/) {
              $start += ($1 eq "")?1:$1;
            }
            if ($cigar_line =~ /(\d*)X$/) {
              $end -= ($1 eq "")?1:$1;
            }
            $root = $root->restrict_between_alignment_positions($start, $end, "skip");
          }
          $i += @$all_leaves; # exit external loop as well
          last;
        }
      }
    }
    push(@$genomic_align_trees, $root);
  }

  return $genomic_align_trees;

}

sub fetch_all_by_MethodLinkSpeciesSet_Slice {

  my ($self, $method_link_species_set, $reference_slice, $limit_number, $limit_index_start, $restrict) = @_;
  my $all_genomic_align_trees = []; # Returned value


  ###########################################################################
  ## The strategy here is very much the same as in the corresponging method
  ## of the Bio::EnsEMBL::Compara::DBSQL::GenomicAlignBlockAdaptor
  ###########################################################################
  my $genome_db = $self->db->get_GenomeDBAdaptor->fetch_by_Slice($reference_slice);
  my $dnafrag_adaptor = $self->db->get_DnaFragAdaptor($reference_slice);

  my $projection_segments = $reference_slice->project('toplevel');
  return [] if(!@$projection_segments);

  foreach my $this_projection_segment (@$projection_segments) {
    my $this_slice = $this_projection_segment->to_Slice;
    my $coord_system_name = $this_slice->coord_system->name;
    my $this_dnafrag = $dnafrag_adaptor->fetch_by_GenomeDB_and_name(
            $genome_db, $this_slice->seq_region_name
        );
    next if (!$this_dnafrag);

    my $these_genomic_align_trees = $self->fetch_all_by_MethodLinkSpeciesSet_DnaFrag(
            $method_link_species_set,
            $this_dnafrag,
            $this_slice->start,
            $this_slice->end,
            $limit_number,
            $limit_index_start,
            $restrict
        );

    my $top_slice = $this_slice->seq_region_Slice;
    throw if ($top_slice->name ne $this_slice->seq_region_Slice->name);
    print join("\n", $top_slice->name, $this_slice->seq_region_Slice->name), "\n";

    # need to convert features to requested coord system
    # if it was different then the one we used for fetching

    if($top_slice->name ne $reference_slice->name) {
      foreach my $this_genomic_align_tree (@$these_genomic_align_trees) {
        my $feature = new Bio::EnsEMBL::Feature(
                -slice => $top_slice,
                -start => $this_genomic_align_tree->reference_genomic_align->dnafrag_start,
                -end => $this_genomic_align_tree->reference_genomic_align->dnafrag_end,
                -strand => $this_genomic_align_tree->reference_genomic_align->dnafrag_strand
            );
        $feature = $feature->transfer($reference_slice);
	next if (!$feature);
        $this_genomic_align_tree->reference_slice($reference_slice);
        $this_genomic_align_tree->reference_slice_start($feature->start);
        $this_genomic_align_tree->reference_slice_end($feature->end);
        $this_genomic_align_tree->reference_slice_strand($reference_slice->strand);
        $this_genomic_align_tree->reverse_complement()
            if ($reference_slice->strand != $this_genomic_align_tree->reference_genomic_align->dnafrag_strand);
        push (@$all_genomic_align_trees, $this_genomic_align_tree);
      }
    } else {
#       foreach my $this_genomic_align_block (@$these_genomic_align_blocks) {
#         $this_genomic_align_block->reference_slice($top_slice);
#         $this_genomic_align_block->reference_slice_start(
#             $this_genomic_align_block->reference_genomic_align->dnafrag_start);
#         $this_genomic_align_block->reference_slice_end(
#             $this_genomic_align_block->reference_genomic_align->dnafrag_end);
#         $this_genomic_align_block->reference_slice_strand($reference_slice->strand);
#         $this_genomic_align_block->reverse_complement()
#             if ($reference_slice->strand != $this_genomic_align_block->reference_genomic_align->dnafrag_strand);
#         push (@$all_genomic_align_blocks, $this_genomic_align_block);
#       }
    }
  }

  return $all_genomic_align_trees;

}

sub fetch_all_children_for_node {

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

  unless($node->isa('Bio::EnsEMBL::Compara::NestedSet')) {
    throw("set arg must be a [Bio::EnsEMBL::Compara::NestedSet] not a $node");
  }

  my $sql = "SELECT " . join(",", @{$self->columns}) .  
     " FROM genomic_align_tree gat". " LEFT JOIN genomic_align_group gag ON (gat.node_id = gag.group_id) LEFT JOIN genomic_align ga ON (gag.genomic_align_id = ga.genomic_align_id) WHERE gat.parent_id = " . $node->node_id;

   my $sth = $self->prepare($sql);
   $sth->execute;
   my $kids = $self->_objs_from_sth($sth);
   $sth->finish;

  foreach my $child (@{$kids}) { $node->add_child($child); }

  return $node;

}

sub fetch_by_GenomicAlignBlock {

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

  my $genomic_align_block_id = $genomic_align_block->dbID;

#  my $join = [
#      [["genomic_align_tree","gat2"], "gat2.root_id = gat.node_id", undef],
#      [["genomic_align_group","gag2"], "gag2.group_id = gat2.node_id", undef],
#      [["genomic_align","ga2"], "ga2.genomic_align_id = gag2.genomic_align_id", undef],
#    ];
#  my $constraint = "WHERE ga2.genomic_align_block_id = $genomic_align_block_id";
#  my $genomic_align_trees = $self->_generic_fetch($constraint, $join);

  my $sql = "SELECT root_id FROM genomic_align
    LEFT JOIN genomic_align_group USING (genomic_align_id)
    LEFT JOIN genomic_align_tree ON (group_id = node_id)
    WHERE genomic_align_block_id = $genomic_align_block_id";

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

  #print "root_id $root_id\n";

  #whole tree
  $sql = "SELECT " . join(",", @{$self->columns}) .  
    " FROM genomic_align_tree gat". " LEFT JOIN genomic_align_group gag ON (gat.node_id = gag.group_id) LEFT JOIN genomic_align ga ON (gag.genomic_align_id = ga.genomic_align_id) WHERE gat.root_id = $root_id";

  #root only
  #$sql = "SELECT " . join(",", @{$self->columns}) .
  #  " FROM genomic_align_tree gat LEFT JOIN genomic_align_group gag ON (gat.node_id = gag.group_id) LEFT JOIN genomic_align ga ON (gag.genomic_align_id = ga.genomic_align_id) WHERE gat.node_id = $root_id";

  $sth = $self->prepare($sql);
  $sth->execute;
  my $genomic_align_trees = $self->_objs_from_sth($sth);
  $sth->finish;

  my $root = $self->_build_tree_from_nodes($genomic_align_trees);

  $genomic_align_trees = [$root];

 #my $constraint = "WHERE gat.node_id = $root_id";
 # my $genomic_align_trees = $self->_generic_fetch($constraint);

  if (@$genomic_align_trees > 1) {
    warning("Found more than 1 tree. This shouldn't happen. Returning the first one only");
  }
  if (@$genomic_align_trees == 0) {
    return;
  }
  my $genomic_align_tree = $genomic_align_trees->[0];


  if ($genomic_align_block->reference_genomic_align) {
    my $ref_genomic_align = $genomic_align_block->reference_genomic_align;
    LEAF: foreach my $this_leaf (@{$genomic_align_tree->get_all_leaves}) {
      foreach my $this_genomic_align (@{$this_leaf->get_all_GenomicAligns}) {
        if ($this_genomic_align->genome_db->name eq $ref_genomic_align->genome_db->name and
            $this_genomic_align->dnafrag->name eq $ref_genomic_align->dnafrag->name and
            $this_genomic_align->dnafrag_start eq $ref_genomic_align->dnafrag_start and
            $this_genomic_align->dnafrag_end eq $ref_genomic_align->dnafrag_end) {
          $genomic_align_tree->reference_genomic_align_node($this_leaf);
          $genomic_align_tree->reference_genomic_align($this_genomic_align);
          last LEAF;
        }
      }
    }
  }
  if ($genomic_align_block->reference_slice) {
    $genomic_align_tree->reference_slice($genomic_align_block->reference_slice);
    $genomic_align_tree->reference_slice_start($genomic_align_block->reference_slice_start);
    $genomic_align_tree->reference_slice_end($genomic_align_block->reference_slice_end);
    $genomic_align_tree->reference_slice_strand($genomic_align_block->reference_slice_strand);
  }

  #if the genomic_align_block has been complemented, then complement the tree
  if ($genomic_align_block->get_original_strand == 0) {
      $genomic_align_tree->reverse_complement;
  }

  return $genomic_align_tree;
}

###########################
# STORE methods
###########################

}

sub fetch_node_by_node_id {

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

  #my $table= $self->tables->[0]->[1];
  #my $constraint = "WHERE $table.node_id = $node_id";
  #my ($node) = @{$self->_generic_fetch($constraint)};

  my $sql = "SELECT " . join(",", @{$self->columns}) .  
     " FROM genomic_align_tree gat". " LEFT JOIN genomic_align_group gag ON (gat.node_id = gag.group_id) LEFT JOIN genomic_align ga ON (gag.genomic_align_id = ga.genomic_align_id) WHERE gat.node_id = " . $node_id;

   my $sth = $self->prepare($sql);
   $sth->execute;
   my ($node) = @{$self->_objs_from_sth($sth)};
   $sth->finish;

  return $node;

}

sub fetch_parent_for_node {

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

   unless($node->isa('Bio::EnsEMBL::Compara::NestedSet')) {
     throw("set arg must be a [Bio::EnsEMBL::Compara::NestedSet] not a $node");
   }

   #my $table= $self->tables->[0]->[1];
   #my $constraint = "WHERE $table.node_id = " . $node->_parent_id;
   #my ($parent) = @{$self->_generic_fetch($constraint)};

   my $sql = "SELECT " . join(",", @{$self->columns}) .  
     " FROM genomic_align_tree gat". " LEFT JOIN genomic_align_group gag ON (gat.node_id = gag.group_id) LEFT JOIN genomic_align ga ON (gag.genomic_align_id = ga.genomic_align_id) WHERE gat.node_id = " . $node->_parent_id;

   my $sth = $self->prepare($sql);
   $sth->execute;
   my ($parent) = @{$self->_objs_from_sth($sth)};
   $sth->finish;

   return $parent;

}

sub fetch_root_by_node {

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

   unless(UNIVERSAL::isa($node, 'Bio::EnsEMBL::Compara::NestedSet')) {
     throw("set arg must be a [Bio::EnsEMBL::Compara::NestedSet] not a $node");
   }

   my $alias = $self->tables->[0]->[1];

   my $left_index = $node->left_index;
   my $right_index = $node->right_index;

#   my $constraint = "WHERE $alias.left_index <= $left_index AND $alias.right_index >= $right_index";


#   my $nodes = $self->_generic_fetch($constraint);


   my $sql = "SELECT " . join(",", @{$self->columns}) .  
     " FROM genomic_align_tree gat". " LEFT JOIN genomic_align_group gag ON (gat.node_id = gag.group_id) LEFT JOIN genomic_align ga ON (gag.genomic_align_id = ga.genomic_align_id) WHERE gat.left_index <= $left_index AND gat.right_index >= $right_index";

   my $sth = $self->prepare($sql);
   $sth->execute;
   my $nodes = $self->_objs_from_sth($sth);
   $sth->finish;

   my $root = $self->_build_tree_from_nodes($nodes);

   return $root;

}

sub init_instance_from_rowhash {

  my $self = shift;
  my $node = shift;
  my $rowhash = shift;

  #SUPER is NestedSetAdaptor
  $self->SUPER::init_instance_from_rowhash($node, $rowhash);
  $node->left_node_id($rowhash->{'left_node_id'});
  $node->right_node_id($rowhash->{'right_node_id'});

  $node->adaptor($self);

  return $node;

}

sub left_join_clause {

#  return "LEFT JOIN genomic_align_group gag ON (gat.node_id = gag.group_id)".
#      " LEFT JOIN genomic_align ga ON (gag.genomic_align_id = ga.genomic_align_id)";
  return "";

}

sub set_neighbour_nodes_for_leaf {

  my ($self, $node, $flanking) = @_;
  $flanking = 1000000 if (!$flanking);

  next if (!$node->is_leaf());
  next if (!$node->genomic_align_group);
  my $genomic_aligns = $node->genomic_align_group->get_all_GenomicAligns;

  my $sth = $self->prepare("SELECT group_id, dnafrag_start, dnafrag_end, dnafrag_strand
      FROM genomic_align LEFT JOIN genomic_align_group USING (genomic_align_id)
      WHERE type = 'epo'
        AND dnafrag_id = ?
        AND method_link_species_set_id = ?
        AND dnafrag_start <= ?
        AND dnafrag_start > ?
        AND dnafrag_end >= ?
        ORDER BY dnafrag_start");

  my $genomic_align = $genomic_aligns->[0];
  my $dnafrag_start = $genomic_align->dnafrag_start;
  my $dnafrag_end = $genomic_align->dnafrag_end;

  $sth->execute(
      $genomic_align->dnafrag_id,
      $genomic_align->method_link_species_set_id,
      $dnafrag_end + $flanking,
      $dnafrag_start - $flanking - $genomic_align->method_link_species_set->max_alignment_length,
      $dnafrag_start - $flanking,
      );
  my $table = $sth->fetchall_arrayref;

  if (@$genomic_aligns == 1) {
    for (my $i = 0; $i < @$table; $i++) {
      my ($this_group_id, $this_dnafrag_start, $this_dnafrag_end, $this_dnafrag_strand) = @{$table->[$i]};
      if ($this_dnafrag_start == $dnafrag_start and $this_dnafrag_end == $dnafrag_end) {
        ## $table->[$i] correspond to the query node
        if ($this_dnafrag_strand == 1) {
          $node->left_node_id($table->[$i-1]->[0]) if ($i > 0);
          $node->right_node_id($table->[$i+1]->[0]) if ($i + 1 < @$table);
        } elsif ($this_dnafrag_strand == -1) {
          $node->right_node_id($table->[$i-1]->[0]) if ($i > 0);
          $node->left_node_id($table->[$i+1]->[0]) if ($i + 1 < @$table);
        }
        last;
      }
    }
  } else {
    ## Use the first GenomicAlign to set the LEFT NODE
    for (my $i = 0; $i < @$table; $i++) {
      my ($this_group_id, $this_dnafrag_start, $this_dnafrag_end, $this_dnafrag_strand) = @{$table->[$i]};
      if ($this_dnafrag_start == $dnafrag_start and $this_dnafrag_end == $dnafrag_end) {
        ## $table->[$i] correspond to the query node
        if ($this_dnafrag_strand == 1) {
          $node->left_node_id($table->[$i-1]->[0]) if ($i > 0);
        } elsif ($this_dnafrag_strand == -1) {
          $node->left_node_id($table->[$i+1]->[0]) if ($i + 1 < @$table);
        }
        last;
      }
    }

    ## Use the last GenomicAlign to set the RIGHT NODE
    $genomic_align = $genomic_aligns->[-1];
    $dnafrag_start = $genomic_align->dnafrag_start;
    $dnafrag_end = $genomic_align->dnafrag_end;

    $sth->execute(
        $genomic_align->dnafrag_id,
        $genomic_align->method_link_species_set_id,
        $dnafrag_end + $flanking,
        $dnafrag_start - $flanking - $genomic_align->method_link_species_set->max_alignment_length,
        $dnafrag_start - $flanking,
        );
    $table = $sth->fetchall_arrayref;
    for (my $i = 0; $i < @$table; $i++) {
      my ($this_group_id, $this_dnafrag_start, $this_dnafrag_end, $this_dnafrag_strand) = @{$table->[$i]};
      if ($this_dnafrag_start == $dnafrag_start and $this_dnafrag_end == $dnafrag_end) {
        ## $table->[$i] correspond to the query node
        if ($this_dnafrag_strand == 1) {
          $node->right_node_id($table->[$i+1]->[0]) if ($i + 1 < @$table);
        } elsif ($this_dnafrag_strand == -1) {
          $node->right_node_id($table->[$i-1]->[0]) if ($i > 0);
        }
        last;
      }
    }
  }
  $sth->finish;

  # Store this in the DB
  if ($node->left_node_id or $node->right_node_id) {
    $self->update_neighbourhood_data($node);
  }

  return $node;

}

sub store {

  my ($self, $node, $skip_left_right_indexes) = @_;

  unless($node->isa('Bio::EnsEMBL::Compara::GenomicAlignTree')) {
    throw("set arg must be a [Bio::EnsEMBL::Compara::GenomicAlignTree] not a $node");
  }

  ## Check the tree
   foreach my $this_node (@{$node->get_all_nodes}) {
#     throw "[$this_node] has no GenomicAlignGroup" if (!$this_node->genomic_align_group);
#     throw "[$this_node] has no GenomicAligns" if (!$this_node->get_all_GenomicAligns);
     throw "[$this_node] does not belong to this tree" if ($this_node->root ne $node);
   }

  my $leaves = $node->get_all_leaves;
  my $method_link_species_set = $leaves->[0]->get_all_GenomicAligns->[0]->method_link_species_set;


  ## Create and store all the GenomicAlignBlock objects (this stores the GenomicAlign objects as well)
  my $genomic_align_block_adaptor = $self->db->get_GenomicAlignBlockAdaptor();
  my $ancestral_genomic_align_block = new Bio::EnsEMBL::Compara::GenomicAlignBlock(
      -method_link_species_set => $method_link_species_set,
      -group_id => $node->group_id);
  my $modern_genomic_align_block = new Bio::EnsEMBL::Compara::GenomicAlignBlock(
      -method_link_species_set => $method_link_species_set,
      -group_id => $node->group_id);
  foreach my $genomic_align_node (@{$node->get_all_nodes}) {
    if ($genomic_align_node->is_leaf()) {
      foreach my $this_genomic_align (@{$genomic_align_node->get_all_GenomicAligns}) {
        $modern_genomic_align_block->add_GenomicAlign($this_genomic_align);
      }
    } elsif ($genomic_align_node->genomic_align_group) {
      foreach my $this_genomic_align (@{$genomic_align_node->get_all_GenomicAligns}) {
        $ancestral_genomic_align_block->add_GenomicAlign($this_genomic_align);
      }
    }
  }
  if (@{$ancestral_genomic_align_block->get_all_GenomicAligns} > 0) {
    $genomic_align_block_adaptor->store($ancestral_genomic_align_block);
  }
  $genomic_align_block_adaptor->store($modern_genomic_align_block);
  $node->ancestral_genomic_align_block_id($ancestral_genomic_align_block->dbID);
  $node->modern_genomic_align_block_id($modern_genomic_align_block->dbID);

  ## Store this node and, recursively, all the sub nodes
  $self->store_node($node);

  ## Set and store the left and right indexes unless otherwise stated
  if (!$skip_left_right_indexes) {
      $self->sync_tree_leftright_index($node);
      $self->update_subtree($node);
  }

  return $node->node_id;

}

sub store_group {

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

    #store trees in database
    foreach my $this_node (@$nodes) {
	$self->store($this_node);
    }

    ### Check if this is defined or not!!!
    my $group_id = 
      $nodes->[0]->genomic_align_group->get_all_GenomicAligns->[0]->genomic_align_block_id;
    
    my $genomic_align_blocks = {};
    foreach my $this_node (@$nodes) {
	## Ancestral GAB
	my $ancestral_genomic_align_block_id = $this_node->genomic_align_group->
	  get_all_GenomicAligns->[0]->genomic_align_block_id;
	my $fake_ancestral_gab;
	$fake_ancestral_gab->{dbID} = $ancestral_genomic_align_block_id;
	bless $fake_ancestral_gab, "Bio::EnsEMBL::Compara::GenomicAlignBlock";
	$genomic_align_blocks->{$ancestral_genomic_align_block_id} = 
	  $fake_ancestral_gab;
	
	## Modern GAB
	my $modern_genomic_align_block_id = 
	  $this_node->get_all_leaves->[0]->genomic_align_group->
	    get_all_GenomicAligns->[0]->genomic_align_block_id;
	my $fake_modern_gab;
	$fake_modern_gab->{dbID} = $modern_genomic_align_block_id;
	bless $fake_modern_gab, "Bio::EnsEMBL::Compara::GenomicAlignBlock";
	$genomic_align_blocks->{$modern_genomic_align_block_id} = 
	  $fake_modern_gab;
    }
    my $genomic_align_block_adaptor = 
      $self->db->get_GenomicAlignBlockAdaptor;
    foreach my $gab (values %$genomic_align_blocks) {
	$genomic_align_block_adaptor->store_group_id($gab, $group_id);
    }

}

sub store_node {

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

  unless($node->isa('Bio::EnsEMBL::Compara::GenomicAlignTree')) {
    throw("set arg must be a [Bio::EnsEMBL::Compara::GenomicAlignTree] not a $node");
  }

  my $parent_id = 0;
  my $root_id = 0;
  if($node->parent) {
    $parent_id = $node->parent->node_id ;
    $root_id = $node->root->node_id;
  }

  #printf("inserting parent_id = %d, root_id = %d\n", $parent_id, $root_id);

  my $sth = $self->prepare("INSERT INTO genomic_align_tree 
                             (node_id,
                              parent_id,
                              root_id,
                              left_index,
                              right_index,
                              distance_to_parent)  VALUES (?,?,?,?,?,?)");
  $sth->execute("NULL", $parent_id, $root_id, $node->left_index, $node->right_index, $node->distance_to_parent);
  #print STDERR "LAST ID: ", $sth->{'mysql_insertid'}, "\n";
  $node->node_id($sth->{'mysql_insertid'});
  $sth->finish;

  #set root_id to be node_id for the root node.
  if ($root_id == 0) {
      my $sql = "UPDATE genomic_align_tree SET root_id = node_id WHERE node_id=?";
      my $sth = $self->prepare($sql);
      $sth->execute($node->node_id);
      $sth->finish;
  }

  $node->adaptor($self);

  if ($node->genomic_align_group) {
    my $genomic_align_group_adaptor = $self->db->get_GenomicAlignGroupAdaptor();
    $node->genomic_align_group->dbID($node->node_id);
    $genomic_align_group_adaptor->store($node->genomic_align_group);

    if (!$node->genomic_align_group or !$node->genomic_align_group->dbID) {
      throw("Cannot store before setting the genomic_align_group ID");
    }
    #print STDERR "NODE ", $node->node_id, " ", $node->name, " -- GROUP: ",
    #  $node->genomic_align_group->dbID, "\n";
  } else {
    #print STDERR "NODE ", $node->node_id, " ", $node->name, " -- NO GROUP\n";
  }


  foreach my $this_child (@{$node->children}) {
    $self->store_node($this_child);
  }

  return $node->node_id;

}

sub tables {

  my $self = shift;
  return [
      ['genomic_align_tree', 'gat'],
      ['genomic_align_group', 'gag'],
      ['genomic_align', 'ga'],
      ];

}

sub update_neighbourhood_data {

  my ($self, $node, $no_recursivity) = @_;

  my $sth = $self->prepare("UPDATE genomic_align_tree
      SET left_node_id = ?, right_node_id = ?
      WHERE node_id = ?");
  #print "update_neighbourhood_data " . $node->left_node_id . " "  .$node->right_node_id . " " . $node->node_id . "\n";
  $sth->execute($node->left_node_id, $node->right_node_id, $node->node_id);

  if (!$no_recursivity) {
    foreach my $this_children (@{$node->children}) {
      $self->update_neighbourhood_data($this_children);
    }
  }

  return $node;

}

General documentation

The rest of the documentation details each of the object methods. Internal methods are usually preceded with a _