view release on metacpan or  search on metacpan

lib/EEDB/Tools/MultiLoader.pm  view on Meta::CPAN

    $self->database->execute_sql($sql) if($self->do_store);
    $self->database->do_sql("UNLOCK TABLES");
  }
  
  #
  # now do the expression
  #
  foreach my $feat (@{$self->{'feature_buffer'}}) {
    my $expr_array = $feat->get_expression_array;
    foreach my $express (@$expr_array) {
      if($self->mirror or !defined($express->primary_id)) {
        $express->primary_id(undef);
        $self->store_express($express);
      }
    }
  }  
  $self->store_express();
  #printf("flush the expression buffer\n");

  #
  # do the symbol/metadata linkage now
  #
  $self->build_feature_symbol_links();
  $self->build_feature_metadata_links();
  
  #
  # then do the chunk edges
  #
  $self->build_chunk_links();


  #done now do cleanup and clear out the buffer
  foreach $feature (@{$self->{'feature_buffer'}}) {
    $feature->empty_expression_cache;
  }
  $self->{'feature_buffer'} = [];
}


=head2 update_feature_metadata

  Description  : this method will take a feature which was fetched from a database
                 and which may have new metadata/symbols and it will store that new
                 metadata/symbols and link them to the feature.
  Parameter[1] : feature [EEDB::Feature]
  Returntype   : none
  Exceptions   : none
  Example      :      my $multiLoad = new EEDB::Tools::MultiLoader;
                      $multiLoad->database($eeDB);
                      $multiLoad->do_store(1);
                      foreach my $feature (@feature_array) {
                         #
                         # do some metadata additions here
                         #
                         $multiLoad->update_feature_metadata($feature);
                      }
                      $multiLoad->update_feature_metadata(); #to flush the queues
                      
=cut

sub update_feature_metadata {
  my $self = shift;
  my $feature = shift;
    
  if(defined($feature)) {
    if($feature->database->url ne $self->database->url) { return; }
  
    #first queue up the metadata 
    my $mdata_list = $feature->metadataset->metadata_list;
    my $mdata_count = 0;
    foreach my $mdata (@$mdata_list) {
      if(!defined($mdata->primary_id)) {
        $mdata_count++;
        if($mdata->class eq 'Metadata') { $self->store_metadata($mdata); }
        if($mdata->class eq 'Symbol')   { $self->store_symbol($mdata); }
      }
    }
    if($mdata_count == 0) { return; }
    
    #OK this feature has new mdata, so queue it up for linking
    push @{$self->{'feature_mdata_buffer'}}, $feature; 
    if(scalar(@{$self->{'feature_mdata_buffer'}}) < 500) { return; }
  }
  if(scalar(@{$self->{'feature_mdata_buffer'}}) == 0) { return; }

  # 1st flush the metadata since I need to have the data in the database before I can link
  $self->store_metadata();
  $self->store_symbol();

  # do the symbol/metadata linkage now
  $self->build_feature_symbol_links();
  $self->build_feature_metadata_links();
  
  #done so clear out the buffer
  $self->{'feature_mdata_buffer'} = [];
}


sub build_chunk_links {
  my $self = shift;

  if($self->database->driver eq "sqlite") { return; }

  my $sql = "INSERT ignore INTO feature_2_chunk (feature_id, chrom_chunk_id) VALUES ";
  my $first=1;
  foreach my $feature (@{$self->{'feature_buffer'}}) {
    next unless($feature->chrom and ($feature->chrom_start>0) and ($feature->chrom_end>0));
    my $chunks = EEDB::ChromChunk->fetch_all_by_chrom_range($feature->chrom, $feature->chrom_start, $feature->chrom_end);
    foreach my $chunk (@{$chunks}) {
      if($first) { $first=0; } else { $sql .= ","; }
      $sql .= sprintf("(%s,%s)", $feature->id, $chunk->id);
    }
  }
  if($first) { return; } #no chunks to link
  
  #printf("%s\n", $sql);
  $self->database->execute_sql($sql) if($self->do_store);
  #printf("done\n");
}