use Carp ();
use List::Util ();
use Scalar::Util ();
-use Data::Query::Constants qw(
- DQ_IDENTIFIER DQ_OPERATOR DQ_VALUE DQ_LITERAL DQ_JOIN DQ_SELECT DQ_ORDER
- DQ_WHERE DQ_DELETE DQ_UPDATE DQ_INSERT
-);
use Data::Query::ExprHelpers;
use Moo;
use namespace::clean;
my ($self, $literal) = @_;
my @bind;
($literal, @bind) = @$literal if ref($literal) eq 'ARRAY';
- +{
- subtype => 'SQL',
- %{ Literal($literal, [ $self->_bind_to_dq(@bind) ]) }
- };
+ Literal('SQL', $literal, [ $self->_bind_to_dq(@bind) ]);
}
sub _bind_to_dq {
my ($self, $ident) = @_;
$self->_assert_pass_injection_guard($ident)
unless $self->renderer_will_quote;
- $self->_maybe_convert_dq(Identifier(split /\Q${\$self->identifier_sep}/, $ident));
+ $self->_maybe_convert_dq(
+ Identifier(do {
+ if (my $sep = $self->identifier_sep) {
+ split /\Q$sep/, $ident
+ } else {
+ $ident
+ }
+ })
+ );
}
sub _maybe_convert_dq {
my ($self, $dq) = @_;
if (my $c = $self->{where_convert}) {
Operator({ 'SQL.Naive' => 'apply' }, [
- { type => DQ_IDENTIFIER, elements => [ $self->_sqlcase($c) ] },
+ Identifier($self->_sqlcase($c)),
$dq
]
);
my $ordered_dq = do {
if ($order) {
- $self->_order_by_to_dq($order, undef, $source_dq);
+ $self->_order_by_to_dq($order, undef, undef, $source_dq);
} else {
$source_dq
}
return $self->_expr_to_dq($where, $logic);
}
+my %op_conversions = (
+ '==' => '=',
+ 'eq' => '=',
+ 'ne' => '!=',
+ '!' => 'NOT',
+ 'gt' => '>',
+ 'ge' => '>=',
+ 'lt' => '<',
+ 'le' => '<=',
+ 'defined' => 'IS NOT NULL',
+);
+
sub _expr_to_dq {
my ($self, $where, $logic) = @_;
) {
return $self->_literal_to_dq($$where);
} elsif (ref($where) eq 'REF' and ref($$where) eq 'HASH') {
- return $$where;
+ return map_dq_tree {
+ if (
+ is_Operator
+ and not $_->{operator}{'SQL.Naive'}
+ and my $op = $_->{operator}{'Perl'}
+ ) {
+ my $sql_op = $op_conversions{$op} || uc($op);
+ return +{
+ %{$_},
+ operator => { 'SQL.Naive' => $sql_op }
+ };
+ }
+ return $_;
+ } $$where;
} elsif (!ref($where) or Scalar::Util::blessed($where)) {
return $self->_value_to_dq($where);
}
foreach my $arg (@args) {
if (
- $arg->{type} eq DQ_OPERATOR and $arg->{operator}{'SQL.Naive'} eq 'apply'
- and @{$arg->{args}} == 2 and $arg->{args}[1]{type} ne DQ_OPERATOR
+ is_Operator($arg) and $arg->{operator}{'SQL.Naive'} eq 'apply'
+ and @{$arg->{args}} == 2 and !is_Operator($arg->{args}[1])
+
) {
$arg->{operator}{'SQL.Naive'} = (shift @{$arg->{args}})->{elements}->[0];
}
map +{ $k => $_ }, @$v
], $logic);
} elsif (ref($v) eq 'SCALAR' or (ref($v) eq 'REF' and ref($$v) eq 'ARRAY')) {
- return +{
- subtype => 'SQL',
- %{ Literal([ $self->_ident_to_dq($k), $self->_literal_to_dq($$v) ]) },
- };
+ return Literal('SQL', [ $self->_ident_to_dq($k), $self->_literal_to_dq($$v) ]);
}
my ($op, $rhs) = do {
if (ref($v) eq 'HASH') {
}
};
if ($op eq 'BETWEEN' or $op eq 'IN' or $op eq 'NOT IN' or $op eq 'NOT BETWEEN') {
+ $rhs = [$rhs] unless ref $rhs;
if (ref($rhs) ne 'ARRAY') {
if ($op =~ /IN$/) {
# have to add parens if none present because -in => \"SELECT ..."
my $x = $$rhs;
1 while ($x =~ s/\A\s*\((.*)\)\s*\Z/$1/s);
$rhs = \$x;
- } else {
- my ($x, @rest) = @{$$rhs};
- 1 while ($x =~ s/\A\s*\((.*)\)\s*\Z/$1/s);
- $rhs = \[ $x, @rest ];
+ } elsif (ref($rhs) eq 'REF') {
+ if (ref($$rhs) eq 'ARRAY') {
+ my ($x, @rest) = @{$$rhs};
+ 1 while ($x =~ s/\A\s*\((.*)\)\s*\Z/$1/s);
+ $rhs = \[ $x, @rest ];
+ } elsif (ref($$rhs) eq 'HASH') {
+ return $self->_op_to_dq($op, $self->_ident_to_dq($k), $$rhs);
+ }
}
}
return $self->_op_to_dq(
$op, $self->_ident_to_dq($k), $self->_literal_to_dq($$rhs)
);
}
- return $self->_literal_to_dq($self->{sqlfalse}) unless @$rhs;
+ if (grep !defined, @$rhs) {
+ my ($inop, $logic, $nullop) = $op =~ /^NOT/
+ ? (-not_in => AND => { '!=' => undef })
+ : (-in => OR => undef);
+ if (my @defined = grep defined, @$rhs) {
+ return $self->_expr_to_dq_ARRAYREF([
+ { $k => { $inop => \@defined } },
+ { $k => $nullop },
+ ], $logic);
+ }
+ return $self->_expr_to_dq_HASHREF({ $k => $nullop });
+ }
+ return $self->_literal_to_dq(
+ $op =~ /^NOT/ ? $self->{sqltrue} : $self->{sqlfalse}
+ ) unless @$rhs;
return $self->_op_to_dq(
$op, $self->_ident_to_dq($k), map $self->_expr_to_dq($_), @$rhs
)
);
} elsif (!defined($rhs)) {
my $null_op = do {
- if ($op eq '=' or $op eq 'LIKE') {
+ if ($op eq '=' or $op eq 'LIKE' or $op eq 'IS') {
'IS NULL'
- } elsif ($op eq '!=') {
+ } elsif ($op eq '!=' or $op eq 'NOT LIKE' or $op eq 'IS NOT') {
'IS NOT NULL'
} else {
die "Can't do undef -> NULL transform for operator ${op}";
}
sub _order_by_to_dq {
- my ($self, $arg, $dir, $from) = @_;
+ my ($self, $arg, $dir, $nulls, $from) = @_;
return unless $arg;
my $dq = Order(
undef,
(defined($dir) ? (!!($dir =~ /desc/i)) : undef),
+ $nulls,
($from ? ($from) : undef),
);
my ($outer, $inner);
foreach my $member (@$arg) {
local $Order_Inner;
- my $next = $self->_order_by_to_dq($member, $dir, $from);
+ my $next = $self->_order_by_to_dq($member, $dir, $nulls, $from);
$outer ||= $next;
$inner->{from} = $next if $inner;
$inner = $Order_Inner || $next;
return $outer;
} elsif (ref($arg) eq 'REF' and ref($$arg) eq 'ARRAY') {
$dq->{by} = $self->_literal_to_dq($$arg);
+ } elsif (ref($arg) eq 'REF' and ref($$arg) eq 'HASH') {
+ $dq->{by} = $$arg;
} elsif (ref($arg) eq 'SCALAR') {
# < mst> right, but if it doesn't match that, it goes "ok, right, not sure,
# dbihacks crack combined with old literal order_by crack
# < ribasushi> heh :)
- if (my ($ident, $dir) = $$arg =~ /^(\w+)(?:\s+(desc|asc))?$/i) {
+ # this should take into account our quote char and name sep
+
+ my $match_ident = '\w+(?:\.\w+)*';
+
+ if (my ($ident, $dir) = $$arg =~ /^(${match_ident})(?:\s+(desc|asc))?$/i) {
$dq->{by} = $self->_ident_to_dq($ident);
$dq->{reverse} = 1 if $dir and lc($dir) eq 'desc';
} else {
$dq->{by} = $self->_literal_to_dq($$arg);
}
} elsif (ref($arg) eq 'HASH') {
- my ($key, $val, @rest) = %$arg;
+ return () unless %$arg;
+
+ my ($direction, $val);
+ foreach my $key (keys %$arg) {
+ if ( $key =~ /^-(desc|asc)/i ) {
+ die "hash passed to _order_by_to_dq must have exactly one of -desc or -asc"
+ if defined $direction;
+ $direction = $1;
+ $val = $arg->{$key};
+ } elsif ($key =~ /^-nulls$/i) {
+ $nulls = $arg->{$key};
+ die "invalid value for -nulls" unless $nulls =~ /^(?:first|last|none)$/i;
+ } else {
+ die "invalid key ${key} in hash passed to _order_by_to_dq";
+ }
+ }
- return unless $key;
+ die "hash passed to _order_by_to_dq must have exactly one of -desc or -asc"
+ unless defined $direction;
- if (@rest or not $key =~ /^-(desc|asc)/i) {
- die "hash passed to _order_by must have exactly one key (-desc or -asc)";
- }
- my $dir = uc $1;
- return $self->_order_by_to_dq($val, $dir, $from);
+ return $self->_order_by_to_dq($val, $direction, $nulls, $from);
} else {
die "Can't handle $arg in _order_by_to_dq";
}
projects / dbsrgits/SQL-Abstract.git / blobdiff