our %Defaults = (
expand => {
- not => '_expand_not',
bool => '_expand_bool',
- and => '_expand_op_andor',
- or => '_expand_op_andor',
- nest => '_expand_nest',
- bind => '_expand_bind',
- in => '_expand_in',
- not_in => '_expand_in',
row => '_expand_row',
- between => '_expand_between',
- not_between => '_expand_between',
op => '_expand_op',
- (map +($_ => '_expand_op_is'), ('is', 'is_not')),
- ident => '_expand_ident',
- value => '_expand_value',
func => '_expand_func',
values => '_expand_values',
+ bind => '_expand_noop',
+ literal => '_expand_noop',
},
expand_op => {
'between' => '_expand_between',
delete => [ qw(target where returning) ],
update => [ qw(target set where returning) ],
insert => [ qw(target fields from returning) ],
+ select => [ qw(select from where order_by) ],
},
expand_clause => {
'delete.from' => '_expand_delete_clause_target',
# special operators
$opt{special_ops} ||= [];
- if ($class->isa('DBIx::Class::SQLMaker')) {
- $opt{warn_once_on_nest} = 1;
- $opt{disable_old_special_ops} = 1;
- }
-
# unary operators
$opt{unary_ops} ||= [];
$opt{expand_unary} = {};
foreach my $name (sort keys %Defaults) {
- $opt{$name} = { %{$Defaults{$name}} };
+ $opt{$name} = { %{$Defaults{$name}}, %{$opt{$name}||{}} };
+ }
+
+ if ($class ne __PACKAGE__) {
+
+ # check for overriden methods
+
+ foreach my $type (qw(insert update delete)) {
+ my $method = "_${type}_returning";
+ if (__PACKAGE__->can($method) ne $class->can($method)) {
+ my $clause = "${type}.returning";
+ $opt{expand_clause}{$clause} = sub { $_[2] },
+ $opt{render_clause}{$clause}
+ = sub { [ $_[0]->$method($_[3]) ] };
+ }
+ }
+ if (__PACKAGE__->can('_table') ne $class->can('_table')) {
+ $opt{expand_clause}{'select.from'} = sub {
+ return +{ -literal => [ $_[0]->_table($_[2]) ] };
+ };
+ }
+ if (__PACKAGE__->can('_order_by') ne $class->can('_order_by')) {
+ $opt{expand_clause}{'select.order_by'} = sub { $_[2] };
+ $opt{render_clause}{'select.order_by'} = sub {
+ [ $_[0]->_order_by($_[2]) ];
+ };
+ }
+ if ($class->isa('DBIx::Class::SQLMaker')) {
+ $opt{warn_once_on_nest} = 1;
+ $opt{disable_old_special_ops} = 1;
+ $opt{render_clause}{'select.where'} = sub {
+ my ($sql, @bind) = $_[0]->where($_[2]);
+ s/\A\s+//, s/\s+\Z// for $sql;
+ return [ $sql, @bind ];
+ };
+ }
}
if ($opt{lazy_join_sql_parts}) {
return bless \%opt, $class;
}
+sub _ext_rw {
+ my ($self, $name, $key, $value) = @_;
+ return $self->{$name}{$key} unless @_ > 3;
+ $self->{$name}{$key} = $value;
+ 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->_ext_rw($name => \@_) }; 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)
+ );
+ }; 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)) {
+ \$self->_ext_rw('${name}', \$this_key, \$this_value);
+ }
+ return \$self;
+ }; 1 } or die "Method builder failed for ${singular}s: $@";
+ eval qq{sub wrap_${singular}s {
+ my (\$self, \@args) = \@_;
+ while (my (\$this_key, \$this_builder) = splice(\@args, 0, 2)) {
+ my \$orig = \$self->_ext_rw('${name}', \$this_key);
+ \$self->_ext_rw(
+ '${name}', \$this_key,
+ \$this_builder->(\$orig, '${name}', \$this_key),
+ );
+ }
+ return \$self;
+ }; 1 } or die "Method builder failed for wrap_${singular}s: $@";
+ eval qq{sub ${singular}_list { sort keys %{\$_[0]->{\$name}} }; 1; }
+ or die "Method builder failed for ${singular}_list: $@";
+ }
+}
+
+sub register_op { $_[0]->{is_op}{$_[1]} = 1; $_[0] }
+
+sub statement_list { sort keys %{$_[0]->{clauses_of}} }
+
+sub clauses_of {
+ my ($self, $of, @clauses) = @_;
+ unless (@clauses) {
+ return @{$self->{clauses_of}{$of}||[]};
+ }
+ if (ref($clauses[0]) eq 'CODE') {
+ @clauses = $self->${\($clauses[0])}(@{$self->{clauses_of}{$of}||[]});
+ }
+ $self->{clauses_of}{$of} = \@clauses;
+ return $self;
+}
+
+sub clone {
+ my ($self) = @_;
+ bless(
+ {
+ (map +($_ => (
+ ref($self->{$_}) eq 'HASH'
+ ? { %{$self->{$_}} }
+ : $self->{$_}
+ )), keys %$self),
+ },
+ ref($self)
+ );
+}
+
sub sqltrue { +{ -literal => [ $_[0]->{sqltrue} ] } }
sub sqlfalse { +{ -literal => [ $_[0]->{sqlfalse} ] } }
}
sub _expand_insert_clause_target {
- +(target => $_[0]->_expand_maybe_list_expr($_[2], -ident));
+ +(target => $_[0]->expand_maybe_list_expr($_[2], -ident));
}
sub _expand_insert_clause_fields {
return +{ -row => [
- $_[0]->_expand_maybe_list_expr($_[2], -ident)
+ $_[0]->expand_maybe_list_expr($_[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_maybe_list_expr($_[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_maybe_list_expr($f, -ident)
) };
return ($self->_sqlcase(' returning ').$sql, @bind);
}
sub _expand_update_set_values {
my ($self, undef, $data) = @_;
- $self->_expand_maybe_list_expr( [
+ $self->expand_maybe_list_expr( [
map {
my ($k, $set) = @$_;
$set = { -bind => $_ } unless defined $set;
sub _expand_update_clause_target {
my ($self, undef, $target) = @_;
- +(target => $self->_expand_maybe_list_expr($target, -ident));
+ +(target => $self->expand_maybe_list_expr($target, -ident));
}
sub _expand_update_clause_set {
}
sub _expand_update_clause_returning {
- +(returning => $_[0]->_expand_maybe_list_expr($_[2], -ident));
+ +(returning => $_[0]->expand_maybe_list_expr($_[2], -ident));
}
# So that subclasses can override UPDATE ... RETURNING separately from
# SELECT
#======================================================================
-
sub select {
- my $self = shift;
- my $table = $self->_table(shift);
- my $fields = shift || '*';
- my $where = shift;
- my $order = shift;
+ my ($self, @args) = @_;
+ my $stmt = do {
+ if (ref(my $sel = $args[0]) eq 'HASH') {
+ $sel
+ } else {
+ my %clauses;
+ @clauses{qw(from select where order_by)} = @args;
- my ($fields_sql, @bind) = $self->_select_fields($fields);
+ # This oddity is to literalify since historically SQLA doesn't quote
+ # a single identifier argument, so we convert it into a literal
- my ($where_sql, @where_bind) = $self->where($where, $order);
- push @bind, @where_bind;
+ $clauses{select} = { -literal => [ $clauses{select}||'*' ] }
+ unless ref($clauses{select});
+ \%clauses;
+ }
+ };
- my $sql = join(' ', $self->_sqlcase('select'), $fields_sql,
- $self->_sqlcase('from'), $table)
- . $where_sql;
+ my @rendered = $self->render_statement({ -select => $stmt });
+ return wantarray ? @rendered : $rendered[0];
+}
- return wantarray ? ($sql, @bind) : $sql;
+sub _expand_select_clause_select {
+ my ($self, undef, $select) = @_;
+ +(select => $self->expand_maybe_list_expr($select, -ident));
+}
+
+sub _expand_select_clause_from {
+ my ($self, undef, $from) = @_;
+ +(from => $self->expand_maybe_list_expr($from, -ident));
+}
+
+sub _expand_select_clause_where {
+ my ($self, undef, $where) = @_;
+
+ my $sqla = do {
+ if (my $conv = $self->{convert}) {
+ my $_wrap = sub {
+ my $orig = shift;
+ sub {
+ my $self = shift;
+ +{ -func => [
+ $conv,
+ $self->$orig(@_)
+ ] };
+ };
+ };
+ $self->clone
+ ->wrap_expander(bind => $_wrap)
+ ->wrap_op_expanders(map +($_ => $_wrap), qw(ident value))
+ ->wrap_expander(func => sub {
+ my $orig = shift;
+ sub {
+ my ($self, $type, $thing) = @_;
+ if (ref($thing) eq 'ARRAY' and $thing->[0] eq $conv
+ and @$thing == 2 and ref($thing->[1]) eq 'HASH'
+ and (
+ $thing->[1]{-ident}
+ or $thing->[1]{-value}
+ or $thing->[1]{-bind})
+ ) {
+ return { -func => $thing }; # already went through our expander
+ }
+ return $self->$orig($type, $thing);
+ }
+ });
+ } else {
+ $self;
+ }
+ };
+
+ return +(where => $sqla->expand_expr($where));
+}
+
+sub _expand_select_clause_order_by {
+ my ($self, undef, $order_by) = @_;
+ +(order_by => $self->_expand_order_by($order_by));
}
sub _select_fields {
my ($self, $fields) = @_;
return $fields unless ref($fields);
return @{ $self->render_aqt(
- $self->_expand_maybe_list_expr($fields, '-ident')
+ $self->expand_maybe_list_expr($fields, '-ident')
) };
}
sub _delete_returning { shift->_returning(@_) }
sub _expand_delete_clause_target {
- +(target => $_[0]->_expand_maybe_list_expr($_[2], -ident));
+ +(target => $_[0]->expand_maybe_list_expr($_[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_maybe_list_expr($_[2], -ident));
}
sub _render_delete_clause_target {
$args = { %$args };
$args->{$type} = delete $args->{_}
}
+ my %has_clause = map +($_ => 1), @{$self->{clauses_of}{$type}};
return +{ "-${type}" => +{
map {
my $val = $args->{$_};
} else {
@exp
}
- } else {
+ } elsif ($has_clause{$_}) {
($_ => $self->expand_expr($val))
+ } else {
+ ($_ => $val)
}
} sort keys %$args
} };
next unless my $clause_expr = $args->{$clause};
my $part = do {
if (my $rdr = $self->{render_clause}{"${type}.${clause}"}) {
- $self->$rdr($clause, $clause_expr);
+ $self->$rdr($clause, $clause_expr, $args);
} else {
my $r = $self->render_aqt($clause_expr, 1);
next unless defined $r->[0] and length $r->[0];
}
}
- if (my $exp = $self->{expand}{$op}) {
+ if (my $exp = $self->{expand}{$op}||$self->{expand_op}{$op}) {
return $self->$exp($op, $v);
}
}
}
- # an explicit node type is currently assumed to be expanded (this is almost
- # certainly wrong and there should be expansion anyway)
-
- if ($self->{render}{$op}) {
- return { $k => $v };
- }
-
- my $type = $self->{unknown_unop_always_func} ? -func : -op;
+ my $type = (
+ $self->{unknown_unop_always_func} && !$self->{render_op}{$op}
+ ? -func
+ : -op
+ );
{ # Old SQLA compat
and (keys %$v)[0] =~ /^-/
) {
$type = (
- (List::Util::first { $op =~ $_->{regex} } @{$self->{special_ops}})
+ (
+ (List::Util::first { $op =~ $_->{regex} } @{$self->{special_ops}})
+ or $self->{render_op}{$op}
+ )
? -op
: -func
)
}
}
- return +{ $type => [
- $op,
- ($type eq -func and ref($v) eq 'ARRAY')
- ? map $self->_expand_expr($_), @$v
- : $self->_expand_expr($v)
- ] };
+ if ($type eq -func and ref($v) eq 'ARRAY') {
+ return $self->_expand_expr({ -func => [ $op, @$v ] });
+ }
+
+ return $self->_expand_expr({ $type => [ $op, $v ] });
}
sub _expand_hashpair_cmp {
+{ -bind => [ our $Cur_Col_Meta, $_[2] ] };
}
-sub _expand_not {
- +{ -op => [ 'not', $_[0]->_expand_expr($_[2]) ] };
-}
-
sub _expand_row {
my ($self, undef, $args) = @_;
+{ -row => [ map $self->expand_expr($_), @$args ] };
return $self->_expand_expr($v);
}
-sub _expand_bind {
- my ($self, undef, $bind) = @_;
- return { -bind => $bind };
+sub _expand_noop {
+ my ($self, $type, $v) = @_;
+ return { "-${type}" => $v };
}
sub _expand_values {
: ((ref($_) eq 'ARRAY') ? $_ : [ $_ ])
), @parts;
return [
- $self->{join_sql_parts}->($join, grep defined, map $_->[0], @final),
+ $self->{join_sql_parts}->(
+ $join, grep defined && length, map $_->[0], @final
+ ),
(map @{$_}[1..$#$_], @final),
];
}
return unless defined($arg) and not (ref($arg) eq 'ARRAY' and !@$arg);
- return $self->_expand_maybe_list_expr($arg)
+ return $self->expand_maybe_list_expr($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_maybe_list_expr($from, -ident)
)->[0];
}
# UTILITY FUNCTIONS
#======================================================================
-sub _expand_maybe_list_expr {
+sub expand_maybe_list_expr {
my ($self, $expr, $default) = @_;
return { -op => [
',', map $self->expand_expr($_, $default),
projects / scpubgit/Q-Branch.git / blobdiff