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) {
op => '_expand_op',
func => '_expand_func',
values => '_expand_values',
+ list => '_expand_list',
},
expand_op => {
(map +($_ => __PACKAGE__->make_binop_expander('_expand_between')),
qw(between not_between)),
- #(map +($_ => __PACKAGE__->make_binop_expander('_expand_in')),
- # qw(in not_in)),
- in => '_expand_in',
- not_in => '_expand_in',
- 'nest' => '_expand_nest',
+ (map +($_ => __PACKAGE__->make_binop_expander('_expand_in')),
+ qw(in not_in)),
(map +($_ => '_expand_op_andor'), ('and', 'or')),
(map +($_ => '_expand_op_is'), ('is', 'is_not')),
- 'ident' => '_expand_ident',
- 'value' => '_expand_value',
+ (map +($_ => __PACKAGE__->make_unop_expander("_expand_${_}")),
+ qw(ident value nest)),
},
render => {
(map +($_, "_render_$_"),
}
}
+sub plugin {
+ my ($self, $plugin, @args) = @_;
+ unless (ref $plugin) {
+ $plugin =~ s/\A\+/${\ref($self)}::Plugin::/;
+ require(join('/', split '::', $plugin).'.pm');
+ }
+ $plugin->apply_to($self, @args);
+}
+
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->_ext_rw($name => \@_) }; 1 }
+
+ eval qq{sub ${singular} { shift->${singular}s(\@_) }; 1 }
or die "Method builder failed for ${singular}: $@";
eval qq{sub wrap_${singular} {
- my (\$self, \$key, \$builder) = \@_;
- my \$orig = \$self->_ext_rw('${name}', \$key);
- \$self->_ext_rw(
- '${name}', \$key,
- \$builder->(\$orig, '${name}', \$key)
- );
+ shift->wrap_${singular}s(\@_)
}; 1 } or die "Method builder failed for wrap_${singular}: $@";
+
eval qq{sub ${singular}s {
my (\$self, \@args) = \@_;
while (my (\$this_key, \$this_value) = splice(\@args, 0, 2)) {
eval qq{sub ${singular}_list { sort keys %{\$_[0]->{\$name}} }; 1; }
or die "Method builder failed for ${singular}_list: $@";
}
+ foreach my $singular (qw(unop_expander binop_expander)) {
+ eval qq{sub ${singular} { shift->${singular}s(\@_) }; 1 }
+ or die "Method builder failed for ${singular}: $@";
+ eval qq{sub ${singular}s {
+ my (\$self, \@args) = \@_;
+ while (my (\$this_key, \$this_value) = splice(\@args, 0, 2)) {
+ \$self->_ext_rw(
+ expand_op => \$this_key,
+ \$self->make_${singular}(\$this_value),
+ );
+ }
+ return \$self;
+ }; 1 } or die "Method builder failed for ${singular}s: $@";
+ }
}
-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);
}
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 {
my ($self, $fields) = @_;
return $fields unless ref($fields);
return @{ $self->render_aqt(
- $self->expand_maybe_list_expr($fields, '-ident')
+ $self->expand_expr({ -list => $fields }, '-ident')
) };
}
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;
}
}
sub _expand_ident {
- my ($self, undef, $body, $k) = @_;
- return $self->_expand_hashpair_cmp(
- $k, { -ident => $body }
- ) if defined($k);
+ my ($self, undef, $body) = @_;
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";
}
}
sub _expand_value {
- return $_[0]->_expand_hashpair_cmp(
- $_[3], { -value => $_[2] },
- ) if defined($_[3]);
+{ -bind => [ our $Cur_Col_Meta, $_[2] ] };
}
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) {
sub _expand_in {
my ($self, $op, $vv, $k) = @_;
- $k = shift @{$vv = [ @$vv ]} unless defined $k;
if (my $literal = is_literal_value($vv)) {
my ($sql, @bind) = @$literal;
my $opened_sql = $self->_open_outer_paren($sql);
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 $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
-=head1 SPECIAL OPERATORS
+=head1 OLD EXTENSION SYSTEM
+
+=head2 SPECIAL OPERATORS
my $sqlmaker = SQL::Abstract->new(special_ops => [
{
]);
-=head1 UNARY OPERATORS
+=head2 UNARY OPERATORS
my $sqlmaker = SQL::Abstract->new(unary_ops => [
{
=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 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