DensityTypeAdaptor.pm 6.64 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#
# EnsEMBL module for Bio::EnsEMBL::DBSQL::DensityTypeAdaptor
#
#
# Copyright EMBL/EBI
#
# You may distribute this module under the same terms as perl itself

=head1 NAME

Bio::EnsEMBL::DBSQL::DensityTypeAdaptor

=head1 SYNOPSIS

my $density_type_adaptor = $database_adaptor->get_DensityTypeAdaptor();
16
@density_types = @{$density_type_adaptor->fetch_all()};
17

18
my $dt = $density_type_adaptor->fetch_by_dbID(12);
19
20


21
22
23
=head1 DESCRIPTION

DensityTypeAdaptor - Performs database interaction for DensityType objects.
24
25
26
27
28
29
30
31
32

=head1 METHODS

=cut

package Bio::EnsEMBL::DBSQL::DensityTypeAdaptor;
use vars qw(@ISA);
use strict;

33
34
35
use Bio::EnsEMBL::DBSQL::BaseAdaptor;

use Bio::EnsEMBL::DensityType;
36
37
use Bio::EnsEMBL::Utils::Exception qw(throw warning);

38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
@ISA = qw(Bio::EnsEMBL::DBSQL::BaseAdaptor);



=head2 new

  Arg [1]    : see superclass (Bio::EnsEMBL::DBSQL::BaseAdaptor) arguments
  Example    : #use this instead of the constructor directly:
               my $dta = $db_adaptor->get_DensityTypeAdaptor();
  Description: Constructor. Creates a new DensityTypeAdaptor
  Returntype : Bio::EnsEMBL::DBSQL::DensityTypeAdaptor
  Exceptions : none
  Caller     : DBAdaptor

=cut

sub new {
  my $class = shift;

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

  $self->{'dbID_cache'} = {};

  return $self;
}



=head2 fetch_all

  Arg [1]    : none
  Example    : my @density_types = @{$density_type_adaptor->fetch_all};
  Description: Retrieves every density type in the database
  Returntype : reference to list of Bio::EnsEMBL::DensityType objects
  Exceptions : none
  Caller     : general, new

=cut

sub fetch_all {
  my $self = shift;

  my @out;

  my $sth = $self->prepare("SELECT density_type_id, analysis_id, block_size,".
                           "       value_type " .
                           "FROM density_type");

  $sth->execute();

  my($dbID, $analysis_id, $blk_size, $vtype);
  $sth->bind_columns(\$dbID, \$analysis_id, \$blk_size, \$vtype);

  my $analysis_adaptor = $self->db->get_AnalysisAdaptor();

  while($sth->fetch()) {
    my $analysis = $analysis_adaptor->fetch_by_dbID($analysis_id);

96
97
98
99
100
    if($blk_size < 1) {
      warning("density_type table contains invalid block_size=$blk_size.");
      $blk_size = 1;
    }

101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
    my $dt = Bio::EnsEMBL::DensityType->new(-ADAPTOR => $self,
                                            -DBID    => $dbID,
                                            -ANALYSIS => $analysis,
                                            -BLOCK_SIZE => $blk_size,
                                            -VALUE_TYPE => $vtype);

    $self->{'dbID_cache'}->{$dbID} = $dt;

    push @out, $dt;
  }

  return \@out;
}



=head2 fetch_by_dbID

  Arg [1]    : int $dbID
  Example    : my $dt = $density_type_adaptor->fetch_by_dbID($dbID);
  Description: Retrieves a density type object via its internal identifier
  Returntype : Bio::EnsEMBL::DensityType
  Exceptions : throw if dbID argument not defined
  Caller     : general

=cut

sub fetch_by_dbID {
  my $self = shift;
  my $dbID = shift;

  if(!defined($dbID)) {
    throw("dbID argument must be defined");
  }

  if($self->{'dbID_cache'}->{$dbID}) {
    return $self->{'dbID_cache'}->{$dbID};
  }

  # go back to database and refill caches
  $self->fetch_all();

  return $self->{'dbID_cache'}->{$dbID};
}


=head2 fetch_all_by_logic_name

  Arg [1]    : string $logic_name
  Example    : my @dts = @{$dtype_adaptor->fetch_all('repeat_coverage')};
  Description: Retrieves all density types with a given logic name
  Returntype : reference to list of Bio::EnsEMBL::DensityTypes
  Exceptions : thrown if logic_name argument is not provided
  Caller     : general

=cut

sub fetch_all_by_logic_name {
  my $self = shift;
  my $logic_name = shift;

  if(!defined($logic_name)) {
    throw("logic_name argument is required.");
  }

  my $analysis_adaptor = $self->db()->get_AnalysisAdaptor();
  my $analysis = $analysis_adaptor->fetch_by_logic_name($logic_name);

  return [] if(!$analysis);

  my $sth = $self->prepare("SELECT density_type_id, block_size,".
                           "       value_type " .
                           "FROM density_type " .
                           "WHERE analysis_id = ?");
  $sth->execute($analysis->dbID());

  my($dbID, $blk_size, $vtype);
  $sth->bind_columns(\$dbID, \$blk_size, \$vtype);

  my @out;

  while($sth->fetch()) {
183
184
185
186
187
188

    if($blk_size < 1) {
      warning("density_type table contains invalid block_size=$blk_size.");
      $blk_size = 1;
    }

189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
    my $dt = Bio::EnsEMBL::DensityType->new(-ADAPTOR => $self,
                                            -DBID    => $dbID,
                                            -ANALYSIS => $analysis,
                                            -BLOCK_SIZE => $blk_size,
                                            -VALUE_TYPE => $vtype);

    $self->{'dbID_cache'}->{$dbID} = $dt;

    push @out, $dt;
  }

  return \@out;
}


#
# garbage collection method, automatically called when DBAdaptor is cleaned up
#
sub deleteObj {
  my $self = shift;

  delete $self->{'dbID_cache'};

  $self->SUPER::deleteObj;
}
214
215
216
217
218
219
220
221
222
223
224
225
226
227


=head2 store

  Arg [1]    : list of Bio::EnsEMBL::DensityType @dt
               the density types to store in the database
  Example    : $density_type->store(1234, @density_types);
  Description: Stores a list of density type objects in the database
  Returntype : none
  Exceptions : thrown if @dt is not defined
               or if any elements of @dt are not Bio::EnsEMBL::DensityType 
  Caller     : general

=cut
228
229

sub store {
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
  my ($self,@dt) = @_;

  if( scalar(@dt) == 0 ) {
    throw("Must call store with list of Density Types");
  }

  my $sth = $self->prepare
    ("INSERT INTO density_type (analysis_id,".
                                  "block_size, value_type) ". 
    "VALUES (?,?,?)");

  my $db = $self->db();
  my $analysis_adaptor = $db->get_AnalysisAdaptor();

 FEATURE: foreach my $dt ( @dt ) {
    if( !ref $dt || !$dt->isa("Bio::EnsEMBL::DensityType") ) {
      throw("Density Type must be an Ensembl DensityType, " .
            "not a [".ref($dt)."]");
    }
249

250
251
252
253
254
    if($dt->is_stored($db)) {
      warning("DensityType [".$dt->density_type_id."] is already stored" .
              " in this database.");
      next FEATURE;
    }
255
256

    if(!defined($dt->analysis())) {
257
258
      throw("An analysis must be attached to the density type to be stored.");
    }
259

260
261
    #store the analysis if it has not been stored yet
    if(!$dt->analysis->is_stored($db)) {
262
      $analysis_adaptor->store($dt->analysis());
263
264
    }
	
265
    $sth->execute($dt->analysis->dbID(), $dt->block_size(), $dt->value_type());
266

267
    my $dbID = $sth->{'mysql_insertid'};
268
269

    # next two lines are to set the density type as stored
270
    $dt->dbID($dbID);
271
    $dt->adaptor($self);
272
273

    $self->{'dbID_cache'}->{$dbID} = $dt;
274
275
276
  }
}

277
1;