File Coverage

blib/lib/SQL/Maker/Condition.pm

Criterion	Covered	Total	%
statement	126	128	98.4
branch	52	56	92.8
condition	21	23	91.3
subroutine	19	19	100.0
pod	0	7	0.0
total	218	233	93.5

package SQL::Maker::Condition;
use strict;
use warnings;
use utf8;
use Scalar::Util ();
use SQL::Maker::Util;
use overload
    '&' => sub { $_[0]->compose_and($_[1]) },
    '|' => sub { $_[0]->compose_or($_[1]) },
    fallback => 1;

sub _quote {
    my ($self, $label) = @_;

    return $$label if ref $label;
    SQL::Maker::Util::quote_identifier($label, $self->{quote_char}, $self->{name_sep})
}

sub new {
    my $class = shift;
    my %args = @_==1 ? %{$_[0]} : @_;
    bless {sql => [], bind => [], strict => 0, %args}, $class;
}

sub _make_term {
    my ($self, $col, $val) = @_;

    if (Scalar::Util::blessed($val)) {
        if ($val->can('as_sql')) {
            return ($val->as_sql($col, sub { $self->_quote(@_) }), [ $val->bind() ]);
        } else {
            return ($self->_quote($col) . " = ?", [ $val ]);
        }
    }

    Carp::croak("cannot pass in an unblessed ref as an argument in strict mode")
        if ref($val) && $self->{strict};

    if ( ref($val) eq 'ARRAY' ) {
        # make_term(foo => {-and => [1,2,3]}) => (foo = 1) AND (foo = 2) AND (foo = 3)
        if ( ref $val->[0] or ( ( $val->[0] || '' ) eq '-and' ) ) {
            my $logic  = 'OR';
            my @values = @$val;
            if ( $val->[0] eq '-and' ) {
                $logic = 'AND';
                shift @values;
            }

            my @bind;
            my @terms;
            for my $v (@values) {
                my ( $term, $bind ) = $self->_make_term( $col, $v );
                push @terms, "($term)";
                push @bind,  @$bind;
            }
            my $term = join " $logic ", @terms;
            return ($term, \@bind);
        }
        else {
            # make_term(foo => [1,2,3]) => foo IN (1,2,3)
            return $self->_make_term_by_arrayref($col, 'IN', $val);
        }
    }
    elsif ( ref($val) eq 'HASH' ) {
        my ( $op, $v ) = ( %{$val} );
        $op = uc($op);
        if ( ( $op eq 'IN' || $op eq 'NOT IN' ) && ref($v) eq 'ARRAY' ) {
            return $self->_make_term_by_arrayref($col, $op, $v);
        }
        elsif ( ( $op eq 'IN' || $op eq 'NOT IN' ) && ref($v) eq 'REF' ) {
            # make_term(foo => +{ 'IN', \['SELECT foo FROM bar'] }) => foo IN (SELECT foo FROM bar)
            my @values = @{$$v};
            my $term = $self->_quote($col) . " $op (" . shift(@values) . ')';
            return ($term, \@values);
        }
        elsif ( ( $op eq 'BETWEEN' ) && ref($v) eq 'ARRAY' ) {
            Carp::croak("USAGE: make_term(foo => {BETWEEN => [\$a, \$b]})") if @$v != 2;
            return ($self->_quote($col) . " BETWEEN ? AND ?", $v);
        }
        else {
            if (ref($v) eq 'SCALAR') {
                # make_term(foo => +{ '<', \"DATE_SUB(NOW(), INTERVAL 3 DAY)"}) => 'foo < DATE_SUB(NOW(), INTERVAL 3 DAY)'
                return ($self->_quote($col) . " $op " . $$v, []);
            }
            else {
                # make_term(foo => +{ '<', 3 }) => foo < 3
                return ($self->_quote($col) . " $op ?", [$v]);
            }
        }
    }
    elsif ( ref($val) eq 'SCALAR' ) {
        # make_term(foo => \"> 3") => foo > 3
        return ($self->_quote($col) . " $$val", []);
    }
    elsif ( ref($val) eq 'REF') {
        my ($query, @v) = @{${$val}};
        return ($self->_quote($col) . " $query", \@v);
    }
    else {
        if (defined $val) {
            # make_term(foo => "3") => foo = 3
            return ($self->_quote($col) . " = ?", [$val]);
        } else {
            # make_term(foo => undef) => foo IS NULL
            return ($self->_quote($col) . " IS NULL", []);
        }
    }
}

sub _make_term_by_arrayref {
    my ($self, $col, $op, $v) = @_;
    if (@$v == 0) {
        if ($op eq 'IN') {
            # make_term(foo => +{'IN' => []}) => 0=1
            return ('0=1', []);
        } else {
            # make_term(foo => +{'NOT IN' => []}) => 1=1
            return ('1=1', []);
        }
    } else {
        # make_term(foo => +{ 'IN', [1,2,3] }) => foo IN (1,2,3)
        my $term = $self->_quote($col) . " $op (" . join( ', ', ('?') x scalar @$v ) . ')';
        return ($term, $v);
    }
}

sub add {
    my ( $self, $col, $val ) = @_;

    my ( $term, $bind ) = $self->_make_term( $col, $val );
    push @{ $self->{sql} }, "($term)";
    push @{ $self->{bind} },  @$bind;

    return $self; # for influent interface
}

sub add_raw {
    my ($self, $term, $bind) = @_;

    push @{ $self->{sql} }, "($term)";
    if ( defined $bind ) {
        push @{ $self->{bind} }, (ref($bind) eq 'ARRAY' ? @$bind : $bind);
    }

    return $self;
}

sub compose_and {
    my ($self, $other) = @_;

    if ( !@{$self->{sql}} ) {
        if ( !@{$other->{sql}} ) {
            return SQL::Maker::Condition->new;
        }
        return SQL::Maker::Condition->new(
            sql => ['(' . $other->as_sql() . ')'],
            bind => [@{$other->{bind}}],
        );
    }
    if ( !@{$other->{sql}} ) {
        return SQL::Maker::Condition->new(
            sql => ['(' . $self->as_sql() . ')'],
            bind => [@{$self->{bind}}],
        );
    }

    return SQL::Maker::Condition->new(
        sql => ['(' . $self->as_sql() . ') AND (' . $other->as_sql() . ')'],
        bind => [@{$self->{bind}}, @{$other->{bind}}],
    );
}

sub compose_or {
    my ($self, $other) = @_;

    if ( !@{$self->{sql}} ) {
        if ( !@{$other->{sql}} ) {
            return SQL::Maker::Condition->new;
        }
        return SQL::Maker::Condition->new(
            sql => ['(' . $other->as_sql() . ')'],
            bind => [@{$other->{bind}}],
        );
    }
    if ( !@{$other->{sql}} ) {
        return SQL::Maker::Condition->new(
            sql => ['(' . $self->as_sql() . ')'],
            bind => [@{$self->{bind}}],
        );
    }

    # return value is enclosed with '()'.
    # because 'OR' operator priority less than 'AND'.
    return SQL::Maker::Condition->new(
        sql => ['((' . $self->as_sql() . ') OR (' . $other->as_sql() . '))'],
        bind => [@{$self->{bind}}, @{$other->{bind}}],
    );
}

sub as_sql {
    my ($self) = @_;
    return join(' AND ', @{$self->{sql}});
}

sub bind {
    my $self = shift;
    return wantarray ? @{$self->{bind}} : $self->{bind};
}

1;
__END__