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
+ );
+ };
+ }
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} = 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 _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 {
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) {
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.
projects / scpubgit/Q-Branch.git / blobdiff