← Back to branch summary

~ubuntu-branches/ubuntu/trusty/lxr-cvs/trusty

« back to all changes in this revision

Viewing changes to lib/LXR/Index/Oracle.pm

  • Committer: Bazaar Package Importer
  • Author(s): Giacomo Catenazzi
  • Date: 2004-01-27 20:34:44 UTC
  • Revision ID: james.westby@ubuntu.com-20040127203444-kb8xobdp8j1z8owi
Tags: upstream-0.9.2
Import upstream version 0.9.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/LXR/Index/Oracle.pm
 
1
# -*- tab-width: 4 -*- ###############################################
 
2
#
 
3
# $Id: Oracle.pm,v 1.1 2002/02/26 16:18:47 mbox Exp $
 
4
 
 
5
# This program is free software; you can redistribute it and/or modify
 
6
# it under the terms of the GNU General Public License as published by
 
7
# the Free Software Foundation; either version 2 of the License, or
 
8
# (at your option) any later version.
 
9
#
 
10
# This program is distributed in the hope that it will be useful,
 
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
# GNU General Public License for more details.
 
14
# 
 
15
# You should have received a copy of the GNU General Public License
 
16
# along with this program; if not, write to the Free Software
 
17
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
18
 
 
19
package LXR::Index::Oracle;
 
20
 
 
21
$CVSID = '$Id: Oracle.pm,v 1.1 2002/02/26 16:18:47 mbox Exp $ ';
 
22
 
 
23
use strict;
 
24
use DBI;
 
25
use LXR::Common;
 
26
 
 
27
use vars qw(%files %symcache @ISA);
 
28
 
 
29
@ISA = ("LXR::Index");
 
30
 
 
31
sub new {
 
32
        my ($self, $dbname) = @_;
 
33
 
 
34
        $self = bless({}, $self);
 
35
        
 
36
        $self->{dbh} = DBI->connect($dbname, $config->{dbuser}, $config->{dbpass}, { RaiseError => 1, AutoCommit => 1 })
 
37
                        || fatal "Can't open connection to database\n";
 
38
 
 
39
        %files = ();
 
40
        %symcache = ();
 
41
 
 
42
        $self->{files_select} = $self->{dbh}->prepare
 
43
                ("select fileid from files where  filename = ? and  revision = ?");             
 
44
        $self->{files_insert} = $self->{dbh}->prepare
 
45
                ("insert into files values (?, ?, filenum.nextval)");
 
46
 
 
47
        $self->{symbols_byname} = $self->{dbh}->prepare
 
48
                ("select symid from symbols where  symname = ?");
 
49
        $self->{symbols_byid} = $self->{dbh}->prepare
 
50
                ("select symname from symbols where symid = ?");
 
51
        $self->{symbols_insert} = $self->{dbh}->prepare
 
52
                ("insert into symbols values ( ?, symnum.nextval)");
 
53
        $self->{symbols_remove} = $self->{dbh}->prepare
 
54
                ("delete from symbols where symname = ?");
 
55
 
 
56
        $self->{indexes_select} = $self->{dbh}->prepare
 
57
                ("select f.filename, i.line, i.type, i.relsym ".
 
58
                 "from symbols s, indexes i, files f, releases r ".
 
59
                 "where s.symid = i.symid and i.fileid = f.fileid ".
 
60
                 "and f.fileid = r.fileid ".
 
61
                 "and  s.symname = ? and  r.release = ? ");
 
62
        $self->{indexes_insert} = $self->{dbh}->prepare
 
63
                ("insert into indexes values (?, ?, ?, ?, ?)");
 
64
 
 
65
        $self->{releases_select} = $self->{dbh}->prepare
 
66
                ("select * from releases where fileid = ? and  release = ?");
 
67
                
 
68
        $self->{releases_insert} = $self->{dbh}->prepare
 
69
                ("insert into releases values (?, ?)");
 
70
 
 
71
        $self->{status_get} = $self->{dbh}->prepare
 
72
                ("select status from status where fileid = ?");
 
73
 
 
74
        $self->{status_insert} = $self->{dbh}->prepare
 
75
#               ("insert into status select ?, 0 except select fileid, 0 from status");
 
76
                ("insert into status values (?, ?)");
 
77
 
 
78
        $self->{status_update} = $self->{dbh}->prepare
 
79
                ("update status set status = ? where fileid = ? and status <= ?");
 
80
 
 
81
        $self->{usage_insert} = $self->{dbh}->prepare
 
82
                ("insert into usage values (?, ?, ?)");
 
83
        $self->{usage_select} = $self->{dbh}->prepare
 
84
                ("select f.filename, u.line ".
 
85
                 "from symbols s, files f, releases r, usage u ".
 
86
                 "where s.symid = u.symid ".
 
87
                 "and f.fileid = u.fileid ".
 
88
                 "and u.fileid = r.fileid and ".
 
89
                 "s.symname = ? and  r.release = ? ".
 
90
                 "order by f.filename");
 
91
 
 
92
        
 
93
        return $self;
 
94
}
 
95
 
 
96
sub index {
 
97
        my ($self, $symname, $fileid, $line, $type, $relsym) = @_;
 
98
 
 
99
        $self->{indexes_insert}->execute($self->symid($symname),
 
100
                                                         $fileid,
 
101
                                                         $line,
 
102
                                                         $type,
 
103
                                                         $relsym ? $self->symid($relsym) : undef);
 
104
}
 
105
 
 
106
sub reference {
 
107
        my ($self, $symname, $fileid, $line) = @_;
 
108
 
 
109
        $self->{usage_insert}->execute($fileid,
 
110
                                                   $line,
 
111
                                                   $self->symid($symname));
 
112
 
 
113
}
 
114
 
 
115
sub getindex {  # Hinzugef�gt von Variable @row, While-Schleife
 
116
        my ($self, $symname, $release) = @_;
 
117
        my ($rows, @ret, @row);
 
118
 
 
119
        $rows = $self->{indexes_select}->execute("$symname", "$release");
 
120
        
 
121
        while (@row = $self->{indexes_select}->fetchrow_array){
 
122
            push (@ret,[@row]);
 
123
        }
 
124
        
 
125
        #while ($rows-- > 0) {
 
126
        #       push(@ret, [ $self->{indexes_select}->fetchrow_array ]);
 
127
        #}
 
128
 
 
129
        $self->{indexes_select}->finish();
 
130
 
 
131
        map { $$_[3] &&= $self->symname($$_[3]) } @ret;
 
132
 
 
133
        return @ret;
 
134
}
 
135
 
 
136
sub getreference {
 
137
        my ($self, $symname, $release) = @_;
 
138
        my ($rows, @ret, @row);
 
139
        
 
140
        $rows = $self->{usage_select}->execute("$symname", "$release"); 
 
141
 
 
142
        while (@row = $self->{usage_select}->fetchrow_array){
 
143
            push (@ret,[@row]);
 
144
        }
 
145
        
 
146
        #while ($rows-- > 0) {
 
147
        #       push(@ret, [ $self->{usage_select}->fetchrow_array ]);
 
148
        #}
 
149
 
 
150
        $self->{usage_select}->finish();                
 
151
 
 
152
        return @ret;
 
153
}
 
154
 
 
155
sub fileid {
 
156
        my ($self, $filename, $revision) = @_;
 
157
        my ($fileid);
 
158
 
 
159
        # CAUTION: $revision is not $release!
 
160
        unless (defined($fileid = $files{"$filename\t$revision"})) {
 
161
                $self->{files_select}->execute($filename, $revision);
 
162
                ($fileid) = $self->{files_select}->fetchrow_array();
 
163
                unless ($fileid) {                      
 
164
                        $self->{files_insert}->execute($filename, $revision);
 
165
                        $self->{files_select}->execute($filename, $revision);
 
166
                        ($fileid) = $self->{files_select}->fetchrow_array();
 
167
                        
 
168
                }
 
169
                
 
170
                $files{"$filename\t$revision"} = $fileid;
 
171
                $self->{files_select}->finish();
 
172
        }
 
173
        return $fileid;
 
174
}
 
175
 
 
176
# Indicate that this filerevision is part of this release
 
177
sub release {
 
178
        my ($self, $fileid, $release) = @_;
 
179
        my (@row);
 
180
        my $rows = $self->{releases_select}->execute($fileid+0, $release);
 
181
        while (@row = $self->{releases_select}->fetchrow_array){
 
182
                    $rows=1;
 
183
        }       
 
184
        $self->{releases_select}->finish();
 
185
 
 
186
        unless ($rows > 0) {
 
187
                $self->{releases_insert}->execute($fileid+0, $release);
 
188
                $self->{releases_insert}->finish();
 
189
        }
 
190
}
 
191
 
 
192
sub symid {
 
193
        my ($self, $symname) = @_;
 
194
        my ($symid);
 
195
 
 
196
        $symid = $symcache{$symname};
 
197
        unless (defined($symid)) {
 
198
                $self->{symbols_byname}->execute($symname);
 
199
                ($symid) = $self->{symbols_byname}->fetchrow_array();
 
200
                $self->{symbols_byname}->finish();
 
201
                unless ($symid) {
 
202
                        $self->{symbols_insert}->execute($symname);
 
203
                        # Get the id of the new symbol
 
204
                        $self->{symbols_byname}->execute($symname);
 
205
                        ($symid) = $self->{symbols_byname}->fetchrow_array();
 
206
                        $self->{symbols_byname}->finish();
 
207
                }
 
208
                $symcache{$symname} = $symid;
 
209
        }
 
210
 
 
211
        return $symid;
 
212
}
 
213
 
 
214
sub symname {
 
215
        my ($self, $symid) = @_;
 
216
        my ($symname);
 
217
 
 
218
        $self->{symbols_byid}->execute($symid+0);
 
219
        ($symname) = $self->{symbols_byid}->fetchrow_array();
 
220
        $self->{symbols_byid}->finish();
 
221
 
 
222
        return $symname;
 
223
}
 
224
 
 
225
sub issymbol {
 
226
        my ($self, $symname) = @_;
 
227
        my ($symid);
 
228
 
 
229
        $symid = $symcache{$symname};
 
230
        unless (defined($symid)) {
 
231
                $self->{symbols_byname}->execute($symname);
 
232
                ($symid) = $self->{symbols_byname}->fetchrow_array();
 
233
                $self->{symbols_byname}->finish();
 
234
                $symcache{$symname} = $symid;
 
235
        }
 
236
 
 
237
        return $symid;
 
238
}
 
239
 
 
240
# If this file has not been indexed earlier, mark it as being indexed
 
241
# now and return true.  Return false if already indexed.
 
242
sub toindex {
 
243
        my ($self, $fileid) = @_;
 
244
        my ($status);
 
245
 
 
246
        $self->{status_get}->execute($fileid);
 
247
        $status = $self->{status_get}->fetchrow_array();
 
248
        $self->{status_get}->finish();
 
249
 
 
250
        if(!defined($status)) {
 
251
                $self->{status_insert}->execute($fileid+0, 0);
 
252
        }
 
253
        return $self->{status_update}->execute(1, $fileid, 0) > 0;
 
254
}
 
255
 
 
256
sub toreference {
 
257
        my ($self, $fileid) = @_;
 
258
        my ($rv);
 
259
 
 
260
        return $self->{status_update}->execute(2, $fileid, 1) > 0;
 
261
}
 
262
 
 
263
# This function should be called before parsing each new file, 
 
264
# if this is not done the too much memory will be used and
 
265
# tings will become very slow. 
 
266
sub empty_cache {
 
267
        %symcache = ();
 
268
}
 
269
 
 
270
sub DESTROY {
 
271
        my ($self) = @_;
 
272
        $self->{files_select} = undef;
 
273
        $self->{files_insert} = undef;
 
274
        $self->{symbols_byname} = undef;
 
275
        $self->{symbols_byid} = undef;
 
276
        $self->{symbols_insert} = undef;
 
277
        $self->{indexes_insert} = undef;
 
278
        $self->{releases_insert} = undef;
 
279
        $self->{status_insert} = undef;
 
280
        $self->{status_update} = undef;
 
281
        $self->{usage_insert} = undef;
 
282
        $self->{usage_select} = undef;
 
283
 
 
284
        if($self->{dbh}) {
 
285
                $self->{dbh}->disconnect();
 
286
                $self->{dbh} = undef;
 
287
        }
 
288
}
 
289
 
 
290
 
 
291
1;