SQL::Statement::Operation - base class for all operation terms

SQL-Statement documentation Contained in the SQL-Statement distribution.

Index

Code Index:

NAME

Top

SQL::Statement::Operation - base class for all operation terms

SYNOPSIS

Top

  # create an operation with an SQL::Statement object as owner, specifying
  # the operation name (for error purposes), the left and the right
  # operand
  my $term = SQL::Statement::Operation->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation is an abstract base class providing the interface for all operation terms.

INHERITANCE

Top

  SQL::Statement::Operation
  ISA SQL::Statement::Term

METHODS

Top

new

Instantiates new operation term.

value

Return the result of the operation of the term by calling operate

operate

Abstract method which will do the operation of the term. Must be overridden by derived classes.

op

Returns the name of the executed operation.

left

Returns the left operand (if any).

Returns the right operand (if any).

DESTROY

Destroys the term and undefines the weak reference to the owner as well as the stored operation, the left and the right operand.

NAME

Top

SQL::Statement::Operation::Neg - negate operation

SYNOPSIS

Top

  # create an <not> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and B<no> right operand
  my $term = SQL::Statement::Neg->new( $owner, $op, $left, undef );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::Neg

INHERITANCE

Top

  SQL::Statement::Operation::Neg
  ISA SQL::Statement::Operation
    ISA SQL::Statement::Term

METHODS

Top

operate

Return the logical negated value of the left operand.

NAME

Top

SQL::Statement::Operation::And - and operation

SYNOPSIS

Top

  # create an C<and> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::And->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::And implements the logical and operation between two terms.

INHERITANCE

Top

  SQL::Statement::Operation::And
  ISA SQL::Statement::Operation
    ISA SQL::Statement::Term

METHODS

Top

operate

Return the result of the logical and operation for the values of the left and right operand.

NAME

Top

SQL::Statement::Operation::Or - or operation

SYNOPSIS

Top

  # create an C<or> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::Or->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::Or implements the logical or operation between two terms.

INHERITANCE

Top

  SQL::Statement::Operation::Or
  ISA SQL::Statement::Operation
    ISA SQL::Statement::Term

METHODS

Top

operate

Return the result of the logical or operation for the values of the left and right operand.

NAME

Top

SQL::Statement::Operation::Is - is operation

SYNOPSIS

Top

  # create an C<is> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::Is->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::Is supports: IS NULL, IS TRUE and IS FALSE. The right operand is always evaluated in boolean context in case of IS TRUE and IS FALSE. IS NULL returns true even if the left term is an empty string ('').

INHERITANCE

Top

  SQL::Statement::Operation::Is
  ISA SQL::Statement::Operation
    ISA SQL::Statement::Term

METHODS

Top

operate

Returns true when the left term is null, true or false - based on the requested right value.

NAME

Top

SQL::Statement::Operation::ANSI::Is - is operation

SYNOPSIS

Top

  # create an C<is> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::Is->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::ANSI::Is supports: IS NULL, IS TRUE and IS FALSE. The right operand is always evaluated in boolean context in case of IS TRUE and IS FALSE. IS NULL returns true if the right term is not defined, false otherwise.

INHERITANCE

Top

  SQL::Statement::Operation::Is
  ISA SQL::Statement::Operation
    ISA SQL::Statement::Term

METHODS

Top

operate

Returns true when the left term is null, true or false - based on the requested right value.

NAME

Top

SQL::Statement::Operation::Contains - in operation

SYNOPSIS

Top

  # create an C<in> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::Contains->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::Contains expects the right operand is an array of SQL::Statement::Term instances. It checks whether the left operand is in the list of the right operands or not like:

  $left->value($eval) ~~ map { $_->value($eval) } @{$right}

INHERITANCE

Top

  SQL::Statement::Operation::Contains
  ISA SQL::Statement::Operation
    ISA SQL::Statement::Term

METHODS

Top

operate

Returns true when the left term is equal to any of the right terms

NAME

Top

SQL::Statement::Operation::Between - between operation

SYNOPSIS

Top

  # create an C<between> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::Between->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::Between expects the right operand is an array of 2 SQL::Statement::Term instances. It checks whether the left operand is between the right operands like:

     ( $left->value($eval) >= $right[0]->value($eval) )
  && ( $left->value($eval) <= $right[1]->value($eval) )

INHERITANCE

Top

  SQL::Statement::Operation::Between
  ISA SQL::Statement::Operation
    ISA SQL::Statement::Term

METHODS

Top

operate

Returns true when the left term is between both right terms

NAME

Top

SQL::Statement::Operation::Equality - abstract base class for comparisons

SYNOPSIS

Top

  # create an C<equality> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::Equality->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::Equality implements compare operations between two terms - choosing either numerical comparison or string comparison, depending whether both operands are numeric or not.

INHERITANCE

Top

  SQL::Statement::Operation::Equality
  ISA SQL::Statement::Operation
    ISA SQL::Statement::Term

METHODS

Top

operate

Return the result of the comparison.

numcmp

Abstract method which will do the numeric comparison of both terms. Must be overridden by derived classes.

strcmp

Abstract method which will do the string comparison of both terms. Must be overridden by derived classes.

NAME

Top

SQL::Statement::Operation::Equal - implements equal operation

SYNOPSIS

Top

  # create an C<equal> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::Equal->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::Equal implements compare operations between two numbers and two strings.

INHERITANCE

Top

  SQL::Statement::Operation::Equal
  ISA SQL::Statement::Operation::Equality
    ISA SQL::Statement::Operation
      ISA SQL::Statement::Term

METHODS

Top

numcmp

Return true when $left == $right

strcmp

Return true when $left eq $right

NAME

Top

SQL::Statement::Operation::NotEqual - implements not equal operation

SYNOPSIS

Top

  # create an C<not equal> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::NotEqual->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::NotEqual implements negated compare operations between two numbers and two strings.

INHERITANCE

Top

  SQL::Statement::Operation::NotEqual
  ISA SQL::Statement::Operation::Equality
    ISA SQL::Statement::Operation
      ISA SQL::Statement::Term

METHODS

Top

numcmp

Return true when $left != $right

strcmp

Return true when $left ne $right

NAME

Top

SQL::Statement::Operation::Lower - implements lower than operation

SYNOPSIS

Top

  # create an C<lower than> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::Lower->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::Lower implements lower than compare operations between two numbers and two strings.

INHERITANCE

Top

  SQL::Statement::Operation::Lower
  ISA SQL::Statement::Operation::Equality
    ISA SQL::Statement::Operation
      ISA SQL::Statement::Term

METHODS

Top

numcmp

Return true when $left < $right

strcmp

Return true when $left lt $right

NAME

Top

SQL::Statement::Operation::Greater - implements greater than operation

SYNOPSIS

Top

  # create an C<greater than> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::Greater->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::Greater implements greater than compare operations between two numbers and two strings.

INHERITANCE

Top

  SQL::Statement::Operation::Greater
  ISA SQL::Statement::Operation::Equality
    ISA SQL::Statement::Operation
      ISA SQL::Statement::Term

METHODS

Top

numcmp

Return true when $left $right>

strcmp

Return true when $left gt $right

NAME

Top

SQL::Statement::Operation::LowerEqual - implements lower equal operation

SYNOPSIS

Top

  # create an C<lower equal> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::LowerEqual->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::LowerEqual implements lower equal compare operations between two numbers and two strings.

INHERITANCE

Top

  SQL::Statement::Operation::LowerEqual
  ISA SQL::Statement::Operation::Equality
    ISA SQL::Statement::Operation
      ISA SQL::Statement::Term

METHODS

Top

numcmp

Return true when $left <= $right

strcmp

Return true when $left le $right

NAME

Top

SQL::Statement::Operation::GreaterEqual - implements greater equal operation

SYNOPSIS

Top

  # create an C<greater equal> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::GreaterEqual->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::GreaterEqual implements greater equal compare operations between two numbers and two strings.

INHERITANCE

Top

  SQL::Statement::Operation::GreaterEqual
  ISA SQL::Statement::Operation::Equality
    ISA SQL::Statement::Operation
      ISA SQL::Statement::Term

METHODS

Top

numcmp

Return true when $left = $right>

strcmp

Return true when $left ge $right

NAME

Top

SQL::Statement::Operation::Regexp - abstract base class for comparisons based on regular expressions

SYNOPSIS

Top

  # create an C<regexp> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::Regexp->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::Regexp implements the comparisons for the LIKE operation family.

INHERITANCE

Top

  SQL::Statement::Operation::Regexp
  ISA SQL::Statement::Operation
    ISA SQL::Statement::Term

METHODS

Top

operate

Return the result of the comparison.

right

Returns the regular expression based on the right term. The right term is expected to be constant - so a LIKE b in not supported.

regexp

Abstract method which must return a regular expression (qr//) from the given string. Must be overridden by derived classes.

NAME

Top

SQL::Statement::Operation::Like - implements the like operation

SYNOPSIS

Top

  # create an C<like> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::Like->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::Like is used to to the comparisons for the LIKE operation.

INHERITANCE

Top

  SQL::Statement::Operation::Like
  ISA SQL::Statement::Operation::Regexp
    ISA SQL::Statement::Operation
      ISA SQL::Statement::Term

METHODS

Top

regexp

Returns qr/^$right$/s

NAME

Top

SQL::Statement::Operation::Clike - implements the clike operation

SYNOPSIS

Top

  # create an C<clike> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::Clike->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::Clike is used to to the comparisons for the CLIKE operation.

INHERITANCE

Top

  SQL::Statement::Operation::Clike
  ISA SQL::Statement::Operation::Regexp
    ISA SQL::Statement::Operation
      ISA SQL::Statement::Term

METHODS

Top

regexp

Returns qr/^$right$/si

NAME

Top

SQL::Statement::Operation::RLike - implements the rlike operation

SYNOPSIS

Top

  # create an C<rlike> operation with an SQL::Statement object as owner,
  # specifying the operation name, the left and the right operand
  my $term = SQL::Statement::RLike->new( $owner, $op, $left, $right );
  # access the result of that operation
  $term->value( $eval );

DESCRIPTION

Top

SQL::Statement::Operation::RLike is used to to the comparisons for the RLIKE operation.

INHERITANCE

Top

  SQL::Statement::Operation::RLike
  ISA SQL::Statement::Operation::Regexp
    ISA SQL::Statement::Operation
      ISA SQL::Statement::Term

METHODS

Top

regexp

Returns qr/$right$/s

AUTHOR AND COPYRIGHT

Top

Copyright (c) 2009,2010 by Jens Rehsack: rehsackATcpan.org

All rights reserved.

You may distribute this module under the terms of either the GNU General Public License or the Artistic License, as specified in the Perl README file.

SQL-Statement documentation Contained in the SQL-Statement distribution. 
package SQL::Statement::Operation;

use strict;
use warnings;

use vars qw(@ISA);
require Carp;

require SQL::Statement::Term;

our $VERSION = '1.33';

@ISA = qw(SQL::Statement::Term);


sub new
{
    my ( $class, $owner, $operation, $leftTerm, $rightTerm ) = @_;

    my $self = $class->SUPER::new($owner);
    $self->{OP}    = $operation;
    $self->{LEFT}  = $leftTerm;
    $self->{RIGHT} = $rightTerm;

    return $self;
}

sub op    { return $_[0]->{OP}; }
sub left  { return $_[0]->{LEFT}; }
sub right { return $_[0]->{RIGHT}; }

sub operate($)
{
    Carp::confess(
                   sprintf(
                            q{pure virtual function 'operate' called on %s for %s},
                            ref( $_[0] ) || __PACKAGE__,
                            $_[0]->{OP}
                          )
                 );
}

sub DESTROY
{
    my $self = $_[0];

    undef $self->{OP};
    undef $self->{LEFT};
    undef $self->{RIGHT};

    $self->SUPER::DESTROY();
}

sub value($) { return $_[0]->operate( $_[1] ); }

package SQL::Statement::Operation::Neg;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation);


sub operate($)
{
    return !$_[0]->{LEFT}->value( $_[1] );
}

package SQL::Statement::Operation::And;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation);


sub operate($) { return $_[0]->{LEFT}->value( $_[1] ) && $_[0]->{RIGHT}->value( $_[1] ); }

package SQL::Statement::Operation::Or;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation);


sub operate($) { return $_[0]->{LEFT}->value( $_[1] ) || $_[0]->{RIGHT}->value( $_[1] ); }

package SQL::Statement::Operation::Is;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation);


sub operate($)
{
    my $self  = $_[0];
    my $left  = $self->{LEFT}->value( $_[1] );
    my $right = $self->{RIGHT}->value( $_[1] );
    my $expr;

    if ( defined($right) )
    {
        $expr = defined($left) ? $left && $right : 0;    # is true / is false
    }
    else
    {
        $expr = !defined($left) || ( $left eq '' );      # FIXME I don't like that '' IS NULL
    }

    return $expr;
}

package SQL::Statement::Operation::ANSI::Is;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation);


sub operate($)
{
    my $self  = $_[0];
    my $left  = $self->{LEFT}->value( $_[1] );
    my $right = $self->{RIGHT}->value( $_[1] );
    my $expr;

    if ( defined($right) )
    {
        $expr = defined($left) ? $left && $right : 0;    # is true / is false
    }
    else
    {
        $expr = !defined($left);
    }

    return $expr;
}

package SQL::Statement::Operation::Contains;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation);
use Scalar::Util qw(looks_like_number);


sub operate($)
{
    my ( $self, $eval ) = @_;
    my $left  = $self->{LEFT}->value($eval);
    my @right = map { $_->value($eval); } @{ $self->{RIGHT} };
    my $expr  = 0;

    foreach my $r (@right)
    {
        last
          if $expr |=
              ( looks_like_number($left) && looks_like_number($r) ) ? $left == $r : $left eq $r;
    }

    return $expr;
}

package SQL::Statement::Operation::Between;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation);
use Scalar::Util qw(looks_like_number);


sub operate($)
{
    my ( $self, $eval ) = @_;
    my $left  = $self->{LEFT}->value($eval);
    my @right = map { $_->value($eval); } @{ $self->{RIGHT} };
    my $expr  = 0;

    if (    looks_like_number($left)
         && looks_like_number( $right[0] )
         && looks_like_number( $right[1] ) )
    {
        $expr = ( $left >= $right[0] ) && ( $left <= $right[1] );
    }
    else
    {
        $expr = ( $left ge $right[0] ) && ( $left le $right[1] );
    }

    return $expr;
}

package SQL::Statement::Operation::Equality;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation);

require Carp;
use Scalar::Util qw(looks_like_number);


sub operate($)
{
    my $self  = $_[0];
    my $left  = $self->{LEFT}->value( $_[1] );
    my $right = $self->{RIGHT}->value( $_[1] );
    return 0 unless ( defined($left) && defined($right) );
    return ( looks_like_number($left) && looks_like_number($right) )
      ? $self->numcmp( $left, $right )
      : $self->strcmp( $left, $right );
}

sub numcmp($)
{
    Carp::confess(
                   sprintf(
                            q{pure virtual function 'numcmp' called on %s for %s},
                            ref( $_[0] ) || __PACKAGE__,
                            $_[0]->{OP}
                          )
                 );
}

sub strcmp($)
{
    Carp::confess(
                   sprintf(
                            q{pure virtual function 'strcmp' called on %s for %s},
                            ref( $_[0] ) || __PACKAGE__,
                            $_[0]->{OP}
                          )
                 );
}

package SQL::Statement::Operation::Equal;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation::Equality);


sub numcmp($$) { return $_[1] == $_[2]; }
sub strcmp($$) { return $_[1] eq $_[2]; }

package SQL::Statement::Operation::NotEqual;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation::Equality);


sub numcmp($$) { return $_[1] != $_[2]; }
sub strcmp($$) { return $_[1] ne $_[2]; }

package SQL::Statement::Operation::Lower;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation::Equality);


sub numcmp($$) { return $_[1] < $_[2]; }
sub strcmp($$) { return $_[1] lt $_[2]; }

package SQL::Statement::Operation::Greater;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation::Equality);


sub numcmp($$) { return $_[1] > $_[2]; }
sub strcmp($$) { return $_[1] gt $_[2]; }

package SQL::Statement::Operation::LowerEqual;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation::Equality);


sub numcmp($$) { return $_[1] <= $_[2]; }
sub strcmp($$) { return $_[1] le $_[2]; }

package SQL::Statement::Operation::GreaterEqual;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation::Equality);


sub numcmp($$) { return $_[1] >= $_[2]; }
sub strcmp($$) { return $_[1] ge $_[2]; }

package SQL::Statement::Operation::Regexp;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation);


sub right($)
{
    my $self  = $_[0];
    my $right = $self->{RIGHT}->value( $_[1] );

    unless ( defined( $self->{PATTERNS}->{$right} ) )
    {
        $self->{PATTERNS}->{$right} = $right;
        $self->{PATTERNS}->{$right} =~ s/%/.*/g;
        $self->{PATTERNS}->{$right} = $self->regexp( $self->{PATTERNS}->{$right} );
    }

    return $self->{PATTERNS}->{$right};
}

sub regexp($)
{
    Carp::confess(
                   sprintf(
                            q{pure virtual function 'regexp' called on %s for %s},
                            ref( $_[0] ) || __PACKAGE__,
                            $_[0]->{OP}
                          )
                 );
}

sub operate($)
{
    my $self  = $_[0];
    my $left  = $self->{LEFT}->value( $_[1] );
    my $right = $self->right( $_[1] );

    return 0 unless ( defined($left) && defined($right) );
    return $left =~ m/^$right$/s;
}

package SQL::Statement::Operation::Like;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation::Regexp);


sub regexp($)
{
    my $right = $_[1];
    return qr/^$right$/s;
}

package SQL::Statement::Operation::Clike;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation::Regexp);


sub regexp($)
{
    my $right = $_[1];
    return qr/^$right$/si;
}

package SQL::Statement::Operation::Rlike;

use vars qw(@ISA);
@ISA = qw(SQL::Statement::Operation::Regexp);


sub regexp($)
{
    my $right = $_[1];
    return qr/$right$/;
}


1;