1 # BEGIN BPS TAGGED BLOCK {{{
5 # This software is Copyright (c) 1996-2009 Best Practical Solutions, LLC
6 # <jesse@bestpractical.com>
8 # (Except where explicitly superseded by other copyright notices)
13 # This work is made available to you under the terms of Version 2 of
14 # the GNU General Public License. A copy of that license should have
15 # been provided with this software, but in any event can be snarfed
18 # This work is distributed in the hope that it will be useful, but
19 # WITHOUT ANY WARRANTY; without even the implied warranty of
20 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 # General Public License for more details.
23 # You should have received a copy of the GNU General Public License
24 # along with this program; if not, write to the Free Software
25 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
26 # 02110-1301 or visit their web page on the internet at
27 # http://www.gnu.org/licenses/old-licenses/gpl-2.0.html.
30 # CONTRIBUTION SUBMISSION POLICY:
32 # (The following paragraph is not intended to limit the rights granted
33 # to you to modify and distribute this software under the terms of
34 # the GNU General Public License and is only of importance to you if
35 # you choose to contribute your changes and enhancements to the
36 # community by submitting them to Best Practical Solutions, LLC.)
38 # By intentionally submitting any modifications, corrections or
39 # derivatives to this work, or any other work intended for use with
40 # Request Tracker, to Best Practical Solutions, LLC, you confirm that
41 # you are the copyright holder for those contributions and you grant
42 # Best Practical Solutions, LLC a nonexclusive, worldwide, irrevocable,
43 # royalty-free, perpetual, license to use, copy, create derivative
44 # works based on those contributions, and sublicense and distribute
45 # those contributions and any derivatives thereof.
47 # END BPS TAGGED BLOCK }}}
56 # Import configuration data from the lexcial scope of __PACKAGE__ (or
57 # at least where those two Subroutines are defined.)
59 our (%FIELD_METADATA, %dispatch, %can_bundle);
61 # Lower Case version of FIELDS, for case insensitivity
62 my %lcfields = map { ( lc($_) => $_ ) } (keys %FIELD_METADATA);
67 # Private Member Variables (which should get cleaned)
68 $self->{'_sql_transalias'} = undef;
69 $self->{'_sql_trattachalias'} = undef;
70 $self->{'_sql_cf_alias'} = undef;
71 $self->{'_sql_object_cfv_alias'} = undef;
72 $self->{'_sql_watcher_join_users_alias'} = undef;
73 $self->{'_sql_query'} = '';
74 $self->{'_sql_looking_at'} = {};
80 if ($args{'FIELD'} eq 'EffectiveId' &&
81 (!$args{'ALIAS'} || $args{'ALIAS'} eq 'main' ) ) {
82 $self->{'looking_at_effective_id'} = 1;
85 if ($args{'FIELD'} eq 'Type' &&
86 (!$args{'ALIAS'} || $args{'ALIAS'} eq 'main' ) ) {
87 $self->{'looking_at_type'} = 1;
90 # All SQL stuff goes into one SB subclause so we can deal with all
92 $self->SUPER::Limit(%args,
93 SUBCLAUSE => 'ticketsql');
97 # All SQL stuff goes into one SB subclause so we can deal with all
101 $this->SUPER::Join(@_,
102 SUBCLAUSE => 'ticketsql');
107 $_[0]->SUPER::_OpenParen( 'ticketsql' );
110 $_[0]->SUPER::_CloseParen( 'ticketsql' );
117 =head2 Robert's Simple SQL Parser
119 Documentation In Progress
121 The Parser/Tokenizer is a relatively simple state machine that scans through a SQL WHERE clause type string extracting a token at a time (where a token is:
123 VALUE -> quoted string or number
124 AGGREGator -> AND or OR
125 KEYWORD -> quoted string or single word
126 OPerator -> =,!=,LIKE,etc..
127 PARENthesis -> open or close.
129 And that stream of tokens is passed through the "machine" in order to build up a structure that looks like:
135 That also deals with parenthesis for nesting. (The parentheses are
136 just handed off the SearchBuilder)
141 my ($self, @bundle) = @_;
142 return unless @bundle;
144 if ( @bundle == 1 ) {
145 $bundle[0]->{'dispatch'}->(
151 ENTRYAGGREGATOR => $bundle[0]->{ea},
152 SUBKEY => $bundle[0]->{subkey},
157 foreach my $chunk (@bundle) {
163 ENTRYAGGREGATOR => $chunk->{ea},
164 SUBKEY => $chunk->{subkey},
167 $bundle[0]->{dispatch}->( $self, \@args );
172 my ($self,$string) = @_;
177 $callback{'OpenParen'} = sub {
178 $self->_close_bundle(@bundle); @bundle = ();
181 $callback{'CloseParen'} = sub {
182 $self->_close_bundle(@bundle); @bundle = ();
185 $callback{'EntryAggregator'} = sub { $ea = $_[0] || '' };
186 $callback{'Condition'} = sub {
187 my ($key, $op, $value) = @_;
189 # key has dot then it's compound variant and we have subkey
191 ($key, $subkey) = ($1, $2) if $key =~ /^([^\.]+)\.(.+)$/;
193 # normalize key and get class (type)
195 if (exists $lcfields{lc $key}) {
196 $key = $lcfields{lc $key};
197 $class = $FIELD_METADATA{$key}->[0];
199 die "Unknown field '$key' in '$string'" unless $class;
201 # replace __CurrentUser__ with id
202 $value = $self->CurrentUser->id if $value eq '__CurrentUser__';
205 unless( $dispatch{ $class } ) {
206 die "No dispatch method for class '$class'"
208 my $sub = $dispatch{ $class };
210 if ( $can_bundle{ $class }
212 || ( $bundle[-1]->{dispatch} == $sub
213 && $bundle[-1]->{key} eq $key
214 && $bundle[-1]->{subkey} eq $subkey
229 $self->_close_bundle(@bundle); @bundle = ();
230 $sub->( $self, $key, $op, $value,
231 SUBCLAUSE => '', # don't need anymore
232 ENTRYAGGREGATOR => $ea,
236 $self->{_sql_looking_at}{lc $key} = 1;
239 RT::SQL::Parse($string, \%callback);
240 $self->_close_bundle(@bundle); @bundle = ();
252 for my $f (keys %{$clauses}) {
256 # Build SQL from the data hash
257 for my $data ( @{ $clauses->{$f} } ) {
258 $sql .= $data->[0] unless $first; $first=0; # ENTRYAGGREGATOR
259 $sql .= " '". $data->[2] . "' "; # FIELD
260 $sql .= $data->[3] . " "; # OPERATOR
261 $sql .= "'". $data->[4] . "' "; # VALUE
264 push @sql, " ( " . $sql . " ) ";
267 return join("AND",@sql);
272 Convert a RT-SQL string into a set of SearchBuilder restrictions.
274 Returns (1, 'Status message') on success and (0, 'Error Message') on
283 my ($self,$query) = @_;
286 # preserve first_row and show_rows across the CleanSlate
287 local ($self->{'first_row'}, $self->{'show_rows'});
292 return (1, $self->loc("No Query")) unless $query;
294 $self->{_sql_query} = $query;
295 eval { $self->_parser( $query ); };
297 $RT::Logger->error( $@ );
301 # We only want to look at EffectiveId's (mostly) for these searches.
302 unless ( exists $self->{_sql_looking_at}{'effectiveid'} ) {
303 #TODO, we shouldn't be hard #coding the tablename to main.
304 $self->SUPER::Limit( FIELD => 'EffectiveId',
306 ENTRYAGGREGATOR => 'AND',
310 # FIXME: Need to bring this logic back in
312 # if ($self->_isLimited && (! $self->{'looking_at_effective_id'})) {
313 # $self->SUPER::Limit( FIELD => 'EffectiveId',
316 # VALUE => 'main.id'); #TODO, we shouldn't be hard coding the tablename to main.
318 # --- This is hardcoded above. This comment block can probably go.
319 # Or, we need to reimplement the looking_at_effective_id toggle.
321 # Unless we've explicitly asked to look at a specific Type, we need
323 unless ( $self->{looking_at_type} ) {
324 $self->SUPER::Limit( FIELD => 'Type', VALUE => 'ticket' );
327 # We don't want deleted tickets unless 'allow_deleted_search' is set
328 unless( $self->{'allow_deleted_search'} ) {
329 $self->SUPER::Limit( FIELD => 'Status',
335 # set SB's dirty flag
336 $self->{'must_redo_search'} = 1;
337 $self->{'RecalcTicketLimits'} = 0;
339 return (1, $self->loc("Valid Query"));
344 Returns the query that this object was initialized with
349 return ($_[0]->{_sql_query});
354 '=' => '!=', '!=' => '=', '<>' => '=',
355 '>' => '<=', '<' => '>=', '>=' => '<', '<=' => '>',
356 'is' => 'IS NOT', 'is not' => 'IS',
357 'like' => 'NOT LIKE', 'not like' => 'LIKE',
358 'matches' => 'NOT MATCHES', 'not matches' => 'MATCHES',
359 'startswith' => 'NOT STARTSWITH', 'not startswith' => 'STARTSWITH',
360 'endswith' => 'NOT ENDSWITH', 'not endswith' => 'ENDSWITH',
363 my %range = map { $_ => 1 } qw(> >= < <=);
365 sub ClassifySQLOperation {
370 if ( $op eq '!=' || $op =~ /\bNOT\b/i ) {
375 if ( 'is not' eq lc($op) || 'is' eq lc($op) ) {
379 return ($is_negative, $is_null, $inv{lc $op}, $range{lc $op});
388 Most of the RT code does not use Exceptions (die/eval) but it is used
389 in the TicketSQL code for simplicity and historical reasons. Lest you
390 be worried that the dies will trigger user visible errors, all are
393 99% of the dies fall in subroutines called via FromSQL and then parse.
394 (This includes all of the _FooLimit routines in Tickets_Overlay.pm.)
395 The other 1% or so are via _ProcessRestrictions.
397 All dies are trapped by eval {}s, and will be logged at the 'error'
398 log level. The general failure mode is to not display any tickets.
404 Legacy LimitFoo routines build up a RestrictionsHash
406 _ProcessRestrictions converts the Restrictions to Clauses
409 Clauses are converted to RT-SQL (TicketSQL)
413 FromSQL calls the parser
415 The parser calls the _FooLimit routines to do DBIx::SearchBuilder
418 And then the normal SearchBuilder/Ticket routines are used for