use Scalar::Util ();
use Exporter 'import';
-our @EXPORT_OK = qw(is_plain_value is_literal_value);
+our @EXPORT_OK = qw(is_plain_value is_literal_value is_undef_value);
BEGIN {
if ($] < 5.009_005) {
# 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')),
[ $_[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);
+ });
}
}
}
}
+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 register_op { $_[0]->{is_op}{$_[1]} = 1; $_[0] }
+#sub register_op { $_[0]->{is_op}{$_[1]} = 1; $_[0] }
sub statement_list { sort keys %{$_[0]->{clauses_of}} }
}
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 {
sub _normalize_op {
my ($self, $raw) = @_;
my $op = lc $raw;
- return $op if grep $_->{$op}, @{$self}{qw(is_op expand_op render_op)};
+ return $op if grep $_->{$op}, @{$self}{qw(expand_op render_op)};
s/^-(?=.)//, s/\s+/_/g for $op;
$op;
}
}
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 ]
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_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) = @_;
On failure returns C<undef>, on success returns an B<array> reference
containing the unpacked version of the supplied literal SQL and bind values.
+=head2 is_undef_value
+
+Tests for undef, whether expanded or not.
+
=head1 WHERE CLAUSES
=head2 Introduction
=back
+=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);
+
+=head2 render_statement
+
+Use this if you may be rendering a top level statement so e.g. a SELECT
+query doesn't get wrapped in parens
+
+ my ($sql, @bind) = $sqla->render_statement($expr);
+
+=head2 expand_expr
+
+Expression expansion with optional default for scalars.
+
+ my $aqt = $self->expand_expr($expr);
+ my $aqt = $self->expand_expr($expr, -ident);
+
+=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 $sqla2 = $sqla->clone;
+
+Performs a semi-shallow copy such that extension methods won't leak state
+but excessive depth is avoided.
+
=head2 expander
+=head2 expanders
+
=head2 op_expander
-=head2
+=head2 op_expanders
+
+=head2 clause_expander
+
+=head2 clause_expanders
+
+ $sqla->expander('name' => sub { ... });
+ $sqla->expanders('name1' => sub { ... }, 'name2' => sub { ... });
+
+=head2 expander_list
+
+=head2 op_expander_list
+
+=head2 clause_expander_list
+
+ my @names = $sqla->expander_list;
+
+=head2 wrap_expander
+
+=head2 wrap_expanders
+
+=head2 wrap_op_expander
+
+=head2 wrap_op_expanders
+
+=head2 wrap_clause_expander
+
+=head2 wrap_clause_expanders
+
+ $sqla->wrap_expander('name' => sub { my ($orig) = @_; sub { ... } });
+ $sqla->wrap_expanders(
+ 'name1' => sub { my ($orig1) = @_; sub { ... } },
+ 'name2' => sub { my ($orig2) = @_; sub { ... } },
+ );
+
+=head2 renderer
+
+=head2 renderers
+
+=head2 op_renderer
+
+=head2 op_renderers
+
+=head2 clause_renderer
+
+=head2 clause_renderers
+
+ $sqla->renderer('name' => sub { ... });
+ $sqla->renderers('name1' => sub { ... }, 'name2' => sub { ... });
+
+=head2 renderer_list
+
+=head2 op_renderer_list
+
+=head2 clause_renderer_list
+
+ my @names = $sqla->renderer_list;
+
+=head2 wrap_renderer
+
+=head2 wrap_renderers
+
+=head2 wrap_op_renderer
+
+=head2 wrap_op_renderers
+
+=head2 wrap_clause_renderer
+
+=head2 wrap_clause_renderers
+
+ $sqla->wrap_renderer('name' => sub { my ($orig) = @_; sub { ... } });
+ $sqla->wrap_renderers(
+ 'name1' => sub { my ($orig1) = @_; sub { ... } },
+ 'name2' => sub { my ($orig2) = @_; sub { ... } },
+ );
+
+=head2 clauses_of
+
+ my @clauses = $sqla->clauses_of('select');
+ $sqla->clauses_of(select => \@new_clauses);
+ $sqla->clauses_of(select => sub {
+ my (undef, @old_clauses) = @_;
+ ...
+ return @new_clauses;
+ });
+
+=head2 statement_list
+
+ 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