use strict;
use warnings;
-use Module::Runtime ();
use Carp ();
use List::Util ();
use Scalar::Util ();
# GLOBALS
#======================================================================
-our $VERSION = '1.90_02';
+our $VERSION = '2.000001';
# This would confuse some packagers
$VERSION = eval $VERSION if $VERSION =~ /_/; # numify for warning-free dev releases
(map +($_ => '_expand_op_is'), ('is', 'is_not')),
(map +($_ => __PACKAGE__->make_unop_expander("_expand_${_}")),
qw(ident value nest)),
+ bind => __PACKAGE__->make_unop_expander(sub { +{ -bind => $_[2] } }),
},
render => {
(map +($_, "_render_$_"),
$self->_expand_ident(ident => $body);
});
}
+ if ($class->isa('SQL::Abstract::More')) {
+ my $orig = $opt{expand_op}{or};
+ $opt{expand_op}{or} = sub {
+ my ($self, $logop, $v, $k) = @_;
+ if ($k and ref($v) eq 'ARRAY') {
+ my ($type, $val) = @$v;
+ my $op;
+ if (
+ ref($type) eq 'HASH' and ref($val) eq 'HASH'
+ and keys %$type == 1 and keys %$val == 1
+ and (keys %$type)[0] eq (keys %$val)[0]
+ ) {
+ ($op) = keys %$type;
+ ($type) = values %$type;
+ ($val) = values %$val;
+ }
+ if ($self->is_bind_value_with_type(my $v = [ $type, $val ])) {
+ return $self->expand_expr(
+ { $k, map +($op ? { $op => $_ } : $_), { -bind => $v } }
+ );
+ }
+ }
+ return $self->$orig($logop, $v, $k);
+ };
+ $opt{render}{bind} = sub {
+ return [ '?', map +(ref($_->[0]) ? $_ : $_->[1]), $_[2] ]
+ };
+ }
}
if ($opt{lazy_join_sql_parts}) {
- my $mod = Module::Runtime::use_module('SQL::Abstract::Parts');
- $opt{join_sql_parts} ||= sub { $mod->new(@_) };
+ require SQL::Abstract::Parts;
+ $opt{join_sql_parts} ||= sub { SQL::Abstract::Parts->new(@_) };
}
$opt{join_sql_parts} ||= sub { join $_[0], @_[1..$#_] };
die "Not a node type: $k" unless $k =~ s/^-//;
if (my $meth = $self->{render}{$k}) {
local our $Render_Top_Level = $top_level;
- return $self->$meth($k, $v);
+ return $self->$meth($k, $v)||[];
}
die "notreached: $k";
}
return $self->sqlfalse unless @$v;
$self->_debug("ARRAY($k) means distribute over elements");
my $logic = lc(
- $v->[0] =~ /^-(and|or)$/i
+ ($v->[0]||'') =~ /^-(and|or)$/i
? (shift(@{$v = [ @$v ]}), $1)
: lc($self->{logic} || 'OR')
);
unless (defined($body) or (ref($body) and ref($body) eq 'ARRAY')) {
puke "-ident requires a single plain scalar argument (a quotable identifier) or an arrayref of identifier parts";
}
- my @parts = map split(/\Q${\($self->{name_sep}||'.')}\E/, $_),
- ref($body) ? @$body : $body;
+ my ($sep) = map +(defined() ? $_ : '.') , $self->{name_sep};
+ my @parts = map +($sep
+ ? map split(/\Q${sep}\E/, $_), @$_
+ : @$_
+ ), ref($body) ? $body : [ $body ];
return { -ident => $parts[-1] } if $self->{_dequalify_idents};
unless ($self->{quote_char}) {
$self->_assert_pass_injection_guard($_) for @parts;
To get an OR instead, you can combine it with the arrayref idea:
- my %where => (
+ my %where = (
user => 'nwiger',
priority => [ { '=', 2 }, { '>', 5 } ]
);