# GLOBALS
#======================================================================
-our $VERSION = '1.86';
+our $VERSION = '1.90_02';
# This would confuse some packagers
$VERSION = eval $VERSION if $VERSION =~ /_/; # numify for warning-free dev releases
op => '_expand_op',
func => '_expand_func',
values => '_expand_values',
+ list => '_expand_list',
},
expand_op => {
(map +($_ => __PACKAGE__->make_binop_expander('_expand_between')),
(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_$_"),
[ $_[0]->_order_by($_[2]) ];
};
}
+ if (__PACKAGE__->can('_select_fields') ne $class->can('_select_fields')) {
+ $opt{expand_clause}{'select.select'} = sub { $_[2] };
+ $opt{render_clause}{'select.select'} = sub {
+ my @super = $_[0]->_select_fields($_[2]);
+ my $effort = [
+ ref($super[0]) eq 'HASH'
+ ? $_[0]->render_expr($super[0])
+ : @super
+ ];
+ return $_[0]->join_query_parts(
+ ' ', { -keyword => 'select' }, $effort
+ );
+ };
+ }
+ foreach my $type (qw(in between)) {
+ my $meth = "_where_field_".uc($type);
+ if (__PACKAGE__->can($meth) ne $class->can($meth)) {
+ my $exp = sub {
+ my ($self, $op, $v, $k) = @_;
+ $op = join ' ', split '_', $op;
+ return +{ -literal => [
+ $self->$meth($k, $op, $v)
+ ] };
+ };
+ $opt{expand_op}{$_} = $exp for $type, "not_${type}";
+ }
+ }
if ($class->isa('DBIx::Class::SQLMaker')) {
$opt{warn_once_on_nest} = 1;
$opt{disable_old_special_ops} = 1;
s/\A\s+//, s/\s+\Z// for $sql;
return [ $sql, @bind ];
};
+ $opt{expand_op}{ident} = $class->make_unop_expander(sub {
+ my ($self, undef, $body) = @_;
+ $body = $body->from if Scalar::Util::blessed($body);
+ $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] ]
+ };
}
}
}
}
+sub plugin {
+ my ($self, $plugin, @args) = @_;
+ unless (ref $plugin) {
+ $plugin =~ s/\A\+/${\__PACKAGE__}::Plugin::/;
+ require(join('/', split '::', $plugin).'.pm');
+ }
+ $plugin->apply_to($self, @args);
+ return $self;
+}
+
BEGIN {
foreach my $type (qw(
expand op_expand render op_render clause_expand clause_render
my $name = join '_', reverse split '_', $type;
my $singular = "${type}er";
- eval qq{sub ${singular} { shift->${singular}s(\@_) }; 1 }
- or die "Method builder failed for ${singular}: $@";
+ eval qq{sub ${singular} {
+ my \$self = shift;
+ return \$self->_ext_rw('${name}', \@_) if \@_ == 1;
+ return \$self->${singular}s(\@_)
+ }; 1 } or die "Method builder failed for ${singular}: $@";
eval qq{sub wrap_${singular} {
shift->wrap_${singular}s(\@_)
}; 1 } or die "Method builder failed for wrap_${singular}: $@";
}
sub _expand_insert_clause_target {
- +(target => $_[0]->expand_maybe_list_expr($_[2], -ident));
+ +(target => $_[0]->expand_expr($_[2], -ident));
}
sub _expand_insert_clause_fields {
return +{ -row => [
- $_[0]->expand_maybe_list_expr($_[2], -ident)
+ $_[0]->expand_expr({ -list => $_[2] }, -ident)
] } if ref($_[2]) eq 'ARRAY';
return $_[2]; # should maybe still expand somewhat?
}
}
sub _expand_insert_clause_returning {
- +(returning => $_[0]->expand_maybe_list_expr($_[2], -ident));
+ +(returning => $_[0]->expand_expr({ -list => $_[2] }, -ident));
}
sub _expand_insert_values {
my $f = $options->{returning};
my ($sql, @bind) = @{ $self->render_aqt(
- $self->expand_maybe_list_expr($f, -ident)
+ $self->expand_expr({ -list => $f }, -ident)
) };
- return ($self->_sqlcase(' returning ').$sql, @bind);
+ my $rsql = $self->_sqlcase(' returning ').$sql;
+ return wantarray ? ($rsql, @bind) : $rsql;
}
sub _expand_insert_value {
sub _expand_update_set_values {
my ($self, undef, $data) = @_;
- $self->expand_maybe_list_expr( [
+ $self->expand_expr({ -list => [
map {
my ($k, $set) = @$_;
$set = { -bind => $_ } unless defined $set;
}
);
} sort keys %$data
- ] );
+ ] });
}
sub _expand_update_clause_target {
my ($self, undef, $target) = @_;
- +(target => $self->expand_maybe_list_expr($target, -ident));
+ +(target => $self->expand_expr({ -list => $target }, -ident));
}
sub _expand_update_clause_set {
}
sub _expand_update_clause_returning {
- +(returning => $_[0]->expand_maybe_list_expr($_[2], -ident));
+ +(returning => $_[0]->expand_expr({ -list => $_[2] }, -ident));
}
# So that subclasses can override UPDATE ... RETURNING separately from
sub _expand_select_clause_select {
my ($self, undef, $select) = @_;
- +(select => $self->expand_maybe_list_expr($select, -ident));
+ +(select => $self->expand_expr({ -list => $select }, -ident));
}
sub _expand_select_clause_from {
my ($self, undef, $from) = @_;
- +(from => $self->expand_maybe_list_expr($from, -ident));
+ +(from => $self->expand_expr({ -list => $from }, -ident));
}
sub _expand_select_clause_where {
sub _select_fields {
my ($self, $fields) = @_;
return $fields unless ref($fields);
- return @{ $self->render_aqt(
- $self->expand_maybe_list_expr($fields, '-ident')
+ my ($sql, @bind) = @{ $self->render_aqt(
+ $self->expand_expr({ -list => $fields }, '-ident')
) };
+ return wantarray ? ($sql, @bind) : $sql;
}
#======================================================================
sub _delete_returning { shift->_returning(@_) }
sub _expand_delete_clause_target {
- +(target => $_[0]->expand_maybe_list_expr($_[2], -ident));
+ +(target => $_[0]->expand_expr({ -list => $_[2] }, -ident));
}
sub _expand_delete_clause_where { +(where => $_[0]->expand_expr($_[2])); }
sub _expand_delete_clause_returning {
- +(returning => $_[0]->expand_maybe_list_expr($_[2], -ident));
+ +(returning => $_[0]->expand_expr({ -list => $_[2] }, -ident));
}
sub _render_delete_clause_target {
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";
}
if (ref($expr) eq 'HASH') {
return undef unless my $kc = keys %$expr;
if ($kc > 1) {
- return $self->_expand_op_andor(and => $expr);
+ return $self->_expand_logop(and => $expr);
}
my ($key, $value) = %$expr;
if ($key =~ /^-/ and $key =~ s/ [_\s]? \d+ $//x ) {
return $self->_expand_hashpair($key, $value);
}
if (ref($expr) eq 'ARRAY') {
- return $self->_expand_op_andor(lc($self->{logic}), $expr);
+ return $self->_expand_logop(lc($self->{logic}), $expr);
}
if (my $literal = is_literal_value($expr)) {
return +{ -literal => $literal };
}
if ($k =~ /^-./) {
return $self->_expand_hashpair_op($k, $v);
- } elsif ($k =~ /^[^\w]/i) {
+ } elsif ($k =~ /^\W+$/) {
my ($lhs, @rhs) = ref($v) eq 'ARRAY' ? @$v : $v;
return $self->_expand_op(
-op, [ $k, $self->expand_expr($lhs, -ident), @rhs ]
# hash with multiple or no elements is andor
if (ref($v) eq 'HASH' and keys %$v != 1) {
- return $self->_expand_op_andor(and => $v, $k);
+ return $self->_expand_logop(and => $v, $k);
}
# undef needs to be re-sent with cmp to achieve IS/IS NOT NULL
? (shift(@{$v = [ @$v ]}), $1)
: lc($self->{logic} || 'OR')
);
- return $self->_expand_op_andor(
+ return $self->_expand_logop(
$logic => $v, $k
);
}
"operator '%s' applied on an empty array (field '$k')"
) ? $self->sqlfalse : $self->sqltrue);
}
- return $self->_expand_op_andor($logic => \@values, $k);
+ return $self->_expand_logop($logic => \@values, $k);
}
if (is_undef_value($vv)) {
my $is = ($self->_dwim_op_to_is($op,
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;
if (my $exp = $self->{expand_op}{$op}) {
return $self->$exp($op, \@opargs);
}
+ if (List::Util::first { $op =~ $_->{regex} } @{$self->{unary_ops}}) {
+ return { -op => [ $op, @opargs ] };
+ }
+{ -op => [ $op, map $self->expand_expr($_), @opargs ] };
}
return $self->_expand_expr({ -ident => $v });
}
+sub _expand_list {
+ my ($self, undef, $expr) = @_;
+ return { -op => [
+ ',', map $self->expand_expr($_),
+ @{$expr->{-op}}[1..$#{$expr->{-op}}]
+ ] } if ref($expr) eq 'HASH' and ($expr->{-op}||[''])->[0] eq ',';
+ return +{ -op => [ ',',
+ map $self->expand_expr($_),
+ ref($expr) eq 'ARRAY' ? @$expr : $expr
+ ] };
+}
+
+sub _expand_logop {
+ my ($self, $logop, $v, $k) = @_;
+ $self->${\$self->{expand_op}{$logop}}($logop, $v, $k);
+}
+
sub _expand_op_andor {
my ($self, $logop, $v, $k) = @_;
if (defined $k) {
$sql;
}
+sub _where_field_IN {
+ my ($self, $k, $op, $vals) = @_;
+ @{$self->_render_op_in(
+ $op,
+ [
+ $self->expand_expr($k, -ident),
+ map $self->expand_expr($_, -value),
+ ref($vals) eq 'ARRAY' ? @$vals : $vals
+ ]
+ )};
+}
+
+sub _where_field_BETWEEN {
+ my ($self, $k, $op, $vals) = @_;
+ @{$self->_render_op_between(
+ $op,
+ [ $self->expand_expr($k, -ident), ref($vals) eq 'ARRAY' ? @$vals : $vals ]
+ )};
+}
#======================================================================
# ORDER BY
return unless defined($arg) and not (ref($arg) eq 'ARRAY' and !@$arg);
- return $self->expand_maybe_list_expr($arg)
+ return $self->expand_expr({ -list => $arg })
if ref($arg) eq 'HASH' and ($arg->{-op}||[''])->[0] eq ',';
my $expander = sub {
my $final_sql = $self->_sqlcase(' order by ').$sql;
+ return $final_sql unless wantarray;
+
return ($final_sql, @bind);
}
my $self = shift;
my $from = shift;
$self->render_aqt(
- $self->expand_maybe_list_expr($from, -ident)
+ $self->expand_expr({ -list => $from }, -ident)
)->[0];
}
# UTILITY FUNCTIONS
#======================================================================
-sub expand_maybe_list_expr {
- my ($self, $expr, $default) = @_;
- return { -op => [
- ',', map $self->expand_expr($_, $default),
- @{$expr->{-op}}[1..$#{$expr->{-op}}]
- ] } if ref($expr) eq 'HASH' and ($expr->{-op}||[''])->[0] eq ',';
- return +{ -op => [ ',',
- map $self->expand_expr($_, $default),
- ref($expr) eq 'ARRAY' ? @$expr : $expr
- ] };
-}
-
# highly optimized, as it's called way too often
sub _quote {
# my ($self, $label) = @_;
=back
-=head1 NEW METHODS
+=head1 NEW METHODS (EXPERIMENTAL)
See L<SQL::Abstract::Reference> for the C<expr> versus C<aqt> concept and
an explanation of what the below extensions are extending.
+=head2 plugin
+
+ $sqla->plugin('+Foo');
+
+Enables plugin SQL::Abstract::Plugin::Foo.
+
=head2 render_expr
my ($sql, @bind) = $sqla->render_expr($expr);
my $aqt = $self->expand_expr($expr);
my $aqt = $self->expand_expr($expr, -ident);
-=head2 expand_maybe_list_expr
-
-expand_expr but with commas if there's more than one entry.
-
- my $aqt = $self->expand_maybe_list_expr([ @exprs ], $default?);
-
=head2 render_aqt
Top level means avoid parens on statement AQT.
my $res = $self->render_aqt($aqt, $top_level);
my ($sql, @bind) = @$res;
+=head2 join_query_parts
+
+Similar to join() but will render hashrefs as nodes for both join and parts,
+and treats arrayref as a nested C<[ $join, @parts ]> structure.
+
+ my $part = $self->join_query_parts($join, @parts);
+
=head1 NEW EXTENSION SYSTEM
=head2 clone
my @list = $sqla->statement_list;
+=head2 make_unop_expander
+
+ my $exp = $sqla->make_unop_expander(sub { ... });
+
+If the op is found as a binop, assumes it wants a default comparison, so
+the inner expander sub can reliably operate as
+
+ sub { my ($self, $name, $body) = @_; ... }
+
+=head2 make_binop_expander
+
+ my $exp = $sqla->make_binop_expander(sub { ... });
+
+If the op is found as a unop, assumes the value will be an arrayref with the
+LHS as the first entry, and converts that to an ident node if it's a simple
+scalar. So the inner expander sub looks like
+
+ sub {
+ my ($self, $name, $body, $k) = @_;
+ { -blah => [ map $self->expand_expr($_), $k, $body ] }
+ }
+
+=head2 unop_expander
+
+=head2 unop_expanders
+
+=head2 binop_expander
+
+=head2 binop_expanders
+
+The above methods operate exactly like the op_ versions but wrap the coderef
+using the appropriate make_ method first.
+
=head1 PERFORMANCE
Thanks to some benchmarking by Mark Stosberg, it turns out that