DensityTypeAdaptor.pm 7.07 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
@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
51
  Status     : Stable
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

=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
75
  Status     : Stable
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

=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);

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

103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
    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
127
  Status     : Stable
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

=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
158
  Status     : Stable
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

=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()) {
187
188
189
190
191
192

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

193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
    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;
}


208
209
210
211
=head2 store

  Arg [1]    : list of Bio::EnsEMBL::DensityType @dt
               the density types to store in the database
212
  Example    : $density_type->store(@density_types);
213
214
215
216
217
  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
218
  Status     : Stable
219
220

=cut
221
222

sub store {
223
224
225
226
227
228
229
  my ($self,@dt) = @_;

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

  my $sth = $self->prepare
230
    ("INSERT IGNORE INTO density_type (analysis_id,".
231
232
233
234
235
236
237
238
239
240
241
                                  "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)."]");
    }
242

243
244
245
    if($dt->is_stored($db)) {
      next FEATURE;
    }
246
247

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

251
252
    #store the analysis if it has not been stored yet
    if(!$dt->analysis->is_stored($db)) {
253
      $analysis_adaptor->store($dt->analysis());
254
255
    }
	
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
    my $inserted = $sth->execute($dt->analysis->dbID(), $dt->block_size(),
                                 $dt->value_type());

    my $dbID;

    # $inserted can be 0E0 which is true but equal to 0
    if(!$inserted || $inserted == 0) {
      # insert failed, presumably because was already stored in database

      my @dts=@{$self->fetch_all_by_logic_name($dt->analysis()->logic_name())};
      my ($stored_dt) = grep {$_->block_size() == $dt->block_size()} @dts;
      if(!$stored_dt) {
        throw("Could not retrieve or store DensityType from database.\n" .
              "Incorrect db permissions or missing density_type table?\n");
      }
      $dbID = $stored_dt->dbID();
    } else {
      $dbID = $sth->{'mysql_insertid'};
    }
275
276

    # next two lines are to set the density type as stored
277
    $dt->dbID($dbID);
278
    $dt->adaptor($self);
279
280

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

284
1;