$self->_expand_maybe_list_expr( [
map {
my ($k, $set) = @$_;
+ $set = { -bind => $_ } unless defined $set;
+{ -op => [ '=', { -ident => $k }, $set ] };
}
map {
sub _select_fields {
my ($self, $fields) = @_;
+ return $fields unless ref($fields);
return $self->_render_expr(
$self->_expand_maybe_list_expr($fields, undef, '-ident')
);
sub _expand_expr {
my ($self, $expr, $logic, $default_scalar_to) = @_;
local our $Default_Scalar_To = $default_scalar_to if $default_scalar_to;
+ our $Expand_Depth ||= 0; local $Expand_Depth = $Expand_Depth + 1;
return undef unless defined($expr);
if (ref($expr) eq 'HASH') {
if (keys %$expr > 1) {
die "notreached";
}
+my $Nest_Warned = 0;
+
sub _expand_expr_hashpair {
my ($self, $k, $v, $logic) = @_;
unless (defined($k) and length($k)) {
. "You probably wanted ...-and => [ $k => COND1, $k => COND2 ... ]";
}
if ($k eq '-nest') {
+ # DBIx::Class requires a nest warning to be emitted once but the private
+ # method it overrode to do so no longer exists
+ if (ref($self) =~ /^DBIx::Class::SQLMaker/) {
+ unless ($Nest_Warned) {
+ belch(
+ "-nest in search conditions is deprecated, you most probably wanted:\n"
+ .q|{..., -and => [ \%cond0, \@cond1, \'cond2', \[ 'cond3', [ col => bind ] ], etc. ], ... }|
+ );
+ $Nest_Warned = 1;
+ }
+ }
return $self->_expand_expr($v);
}
if ($k eq '-bool') {
$op =~ s/^-// if length($op) > 1;
# top level special ops are illegal in general
- puke "Illegal use of top-level '-$op'"
- if List::Util::first { $op =~ $_->{regex} } @{$self->{special_ops}};
+ # note that, arguably, if it makes no sense at top level, it also
+ # makes no sense on the other side of an = sign or similar but DBIC
+ # gets disappointingly upset if I disallow it
+ if (
+ (our $Expand_Depth) == 1
+ and List::Util::first { $op =~ $_->{regex} } @{$self->{special_ops}}
+ ) {
+ puke "Illegal use of top-level '-$op'"
+ }
if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{unary_ops}}) {
return { -op => [ $op, $v ] };
}
and (keys %$v)[0] =~ /^-/
) {
my ($func) = $k =~ /^-(.*)$/;
+ if (List::Util::first { $func =~ $_->{regex} } @{$self->{special_ops}}) {
+ return +{ -op => [ $func, $self->_expand_expr($v) ] };
+ }
return +{ -func => [ $func, $self->_expand_expr($v) ] };
}
if (!ref($v) or is_literal_value($v)) {
#print STDERR Data::Dumper::Concise::Dumper([ $where, $logic ]);
- my $where_exp = $self->_expand_expr($where, $logic);
+ # Special case: top level simple string treated as literal
+
+ my $where_exp = (ref($where)
+ ? $self->_expand_expr($where, $logic)
+ : { -literal => [ $where ] });
#print STDERR Data::Dumper::Concise::Dumper([ EXP => $where_exp ]);
if (my $h = $special{$op}) {
return $self->$h(\@args);
}
- if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{special_ops}}) {
+ my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{special_ops}};
+ if ($us and @args > 1) {
puke "Special op '${op}' requires first value to be identifier"
unless my ($k) = map $_->{-ident}, grep ref($_) eq 'HASH', $args[0];
return $self->${\($us->{handler})}($k, $op, $args[1]);
? "${expr_sql} ${op_sql}"
: "${op_sql} ${expr_sql}"
);
- return (($op eq 'not' ? '('.$final_sql.')' : $final_sql), @bind);
+ return (($op eq 'not' || $us ? '('.$final_sql.')' : $final_sql), @bind);
} else {
my @parts = map [ $self->_render_expr($_) ], @args;
- my ($final_sql) = map +($op =~ /^(and|or)$/ ? "(${_})" : $_), join(
+ my ($final_sql) = map +($op =~ /^(and|or)$/ ? "( ${_} )" : $_), join(
($final_op eq ',' ? '' : ' ').$self->_sqlcase($final_op).' ',
map $_->[0], @parts
);
# ORDER BY
#======================================================================
-sub _order_by {
+sub _expand_order_by {
my ($self, $arg) = @_;
- return '' unless defined($arg) and not (ref($arg) eq 'ARRAY' and !@$arg);
+ return unless defined($arg) and not (ref($arg) eq 'ARRAY' and !@$arg);
my $expander = sub {
my ($self, $dir, $expr) = @_;
+ my @to_expand = ref($expr) eq 'ARRAY' ? @$expr : $expr;
+ foreach my $arg (@to_expand) {
+ if (
+ ref($arg) eq 'HASH'
+ and keys %$arg > 1
+ and grep /^-(asc|desc)$/, keys %$arg
+ ) {
+ puke "ordering direction hash passed to order by must have exactly one key (-asc or -desc)";
+ }
+ }
my @exp = map +(defined($dir) ? { -op => [ $dir => $_ ] } : $_),
map $self->_expand_expr($_, undef, -ident),
- ref($expr) eq 'ARRAY' ? @$expr : $expr;
+ map ref($_) eq 'ARRAY' ? @$_ : $_, @to_expand;
return (@exp > 1 ? { -op => [ ',', @exp ] } : $exp[0]);
};
- if (
- ref($arg) eq 'HASH'
- and keys %$arg > 1
- and grep /^-(asc|desc)$/, keys %$arg
- ) {
- puke "ordering direction hash passed to order by must have exactly one key (-asc or -desc)";
- }
-
local @{$self->{expand_unary}}{qw(-asc -desc)} = (
sub { shift->$expander(asc => @_) },
sub { shift->$expander(desc => @_) },
);
- my $expanded = $self->$expander(undef, $arg);
+ return $self->$expander(undef, $arg);
+}
+
+sub _order_by {
+ my ($self, $arg) = @_;
+
+ return '' unless defined(my $expanded = $self->_expand_order_by($arg));
my ($sql, @bind) = $self->_render_expr($expanded);
return wantarray ? ($final_sql, @bind) : $final_sql;
}
+# _order_by no longer needs to call this so doesn't but DBIC uses it.
+
+sub _order_by_chunks {
+ my ($self, $arg) = @_;
+
+ return () unless defined(my $expanded = $self->_expand_order_by($arg));
+
+ return $self->_chunkify_order_by($expanded);
+}
+
+sub _chunkify_order_by {
+ my ($self, $expanded) = @_;
+ for ($expanded) {
+ if (ref() eq 'HASH' and my $op = $_->{-op}) {
+ if ($op->[0] eq ',') {
+ return map $self->_chunkify_order_by($_), @{$op}[1..$#$op];
+ }
+ }
+ return [ $self->_render_expr($_) ];
+ }
+}
+
#======================================================================
# DATASOURCE (FOR NOW, JUST PLAIN TABLE OR LIST OF TABLES)
#======================================================================
projects / dbsrgits/SQL-Abstract.git / blobdiff