use strict;
use warnings;
+use Module::Runtime ();
use Carp ();
use List::Util ();
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) {
# See section WHERE: BUILTIN SPECIAL OPERATORS below for implementation
my @BUILTIN_SPECIAL_OPS = (
{regex => qr/^ (?: not \s )? between $/ix, handler => sub { die "NOPE" }},
- {regex => qr/^ (?: not \s )? in $/ix, handler => sub { die "NOPE" }},
{regex => qr/^ is (?: \s+ not )? $/ix, handler => sub { die "NOPE" }},
+ {regex => qr/^ (?: not \s )? in $/ix, handler => sub { die "NOPE" }},
+ {regex => qr/^ ident $/ix, handler => sub { die "NOPE" }},
+ {regex => qr/^ value $/ix, handler => sub { die "NOPE" }},
);
#======================================================================
: undef;
}
+sub is_undef_value ($) {
+ !defined($_[0])
+ or (
+ ref($_[0]) eq 'HASH'
+ and exists $_[0]->{-value}
+ and not defined $_[0]->{-value}
+ );
+}
+
# FIXME XSify - this can be done so much more efficiently
sub is_plain_value ($) {
no strict 'refs';
# NEW
#======================================================================
+our %Defaults = (
+ expand => {
+ bool => '_expand_bool',
+ row => '_expand_row',
+ op => '_expand_op',
+ func => '_expand_func',
+ values => '_expand_values',
+ },
+ expand_op => {
+ (map +($_ => __PACKAGE__->make_binop_expander('_expand_between')),
+ qw(between not_between)),
+ (map +($_ => __PACKAGE__->make_binop_expander('_expand_in')),
+ qw(in not_in)),
+ (map +($_ => '_expand_op_andor'), ('and', 'or')),
+ (map +($_ => '_expand_op_is'), ('is', 'is_not')),
+ (map +($_ => __PACKAGE__->make_unop_expander("_expand_${_}")),
+ qw(ident value nest)),
+ },
+ render => {
+ (map +($_, "_render_$_"),
+ qw(op func bind ident literal row values keyword)),
+ },
+ render_op => {
+ (map +($_ => '_render_op_between'), 'between', 'not_between'),
+ (map +($_ => '_render_op_in'), 'in', 'not_in'),
+ (map +($_ => '_render_unop_postfix'),
+ 'is_null', 'is_not_null', 'asc', 'desc',
+ ),
+ (not => '_render_unop_paren'),
+ (map +($_ => '_render_op_andor'), qw(and or)),
+ ',' => '_render_op_multop',
+ },
+ clauses_of => {
+ 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',
+ 'update.update' => '_expand_update_clause_target',
+ 'insert.into' => '_expand_insert_clause_target',
+ 'insert.values' => '_expand_insert_clause_from',
+ },
+ render_clause => {
+ 'delete.target' => '_render_delete_clause_target',
+ 'update.target' => '_render_update_clause_target',
+ 'insert.target' => '_render_insert_clause_target',
+ 'insert.fields' => '_render_insert_clause_fields',
+ 'insert.from' => '_render_insert_clause_from',
+ },
+);
+
+foreach my $stmt (keys %{$Defaults{clauses_of}}) {
+ $Defaults{expand}{$stmt} = '_expand_statement';
+ $Defaults{render}{$stmt} = '_render_statement';
+ foreach my $clause (@{$Defaults{clauses_of}{$stmt}}) {
+ $Defaults{expand_clause}{"${stmt}.${clause}"}
+ = "_expand_${stmt}_clause_${clause}";
+ }
+}
+
sub new {
my $self = shift;
my $class = ref($self) || $self;
$opt{equality_op} = qr/^( \Q$opt{cmp}\E | \= )$/ix;
$opt{inequality_op} = qr/^( != | <> )$/ix;
- $opt{like_op} = qr/^ (is\s+)? r?like $/xi;
- $opt{not_like_op} = qr/^ (is\s+)? not \s+ r?like $/xi;
+ $opt{like_op} = qr/^ (is_)?r?like $/xi;
+ $opt{not_like_op} = qr/^ (is_)?not_r?like $/xi;
# SQL booleans
$opt{sqltrue} ||= '1=1';
# special operators
$opt{special_ops} ||= [];
- # regexes are applied in order, thus push after user-defines
- push @{$opt{special_ops}}, @BUILTIN_SPECIAL_OPS;
-
- if ($class->isa('DBIx::Class::SQLMaker')) {
- push @{$opt{special_ops}}, our $DBIC_Compat_Op ||= {
- regex => qr/^(?:ident|value)$/i, handler => sub { die "NOPE" }
- };
- $opt{is_dbic_sqlmaker} = 1;
- }
-
# unary operators
$opt{unary_ops} ||= [];
$opt{expand_unary} = {};
- $opt{expand} = {
- -not => '_expand_not',
- -bool => '_expand_bool',
- -and => '_expand_op_andor',
- -or => '_expand_op_andor',
- -nest => '_expand_nest',
- };
+ foreach my $name (sort keys %Defaults) {
+ $opt{$name} = { %{$Defaults{$name}}, %{$opt{$name}||{}} };
+ }
- $opt{expand_op} = {
- 'between' => '_expand_between',
- 'not between' => '_expand_between',
- 'in' => '_expand_in',
- 'not in' => '_expand_in',
- 'nest' => '_expand_nest',
- (map +($_ => '_expand_op_andor'),
- qw(and or)),
- };
+ if ($class ne __PACKAGE__) {
+
+ # check for overriden methods
- # placeholder for _expand_unop system
- {
- my %unops = (-ident => '_expand_ident', -value => '_expand_value');
- foreach my $name (keys %unops) {
- $opt{expand}{$name} = $unops{$name};
- my ($op) = $name =~ /^-(.*)$/;
- $opt{expand_op}{$op} = sub {
- my ($self, $op, $arg, $k) = @_;
- return +{ -op => [
- $self->{cmp},
- $self->_expand_ident(-ident => $k),
- $self->_expand_expr({ '-'.$op => $arg }),
- ] };
+ 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 ];
};
}
}
- $opt{render} = {
- (map +("-$_", "_render_$_"), qw(op func bind ident literal list)),
- %{$opt{render}||{}}
- };
+ if ($opt{lazy_join_sql_parts}) {
+ my $mod = Module::Runtime::use_module('SQL::Abstract::Parts');
+ $opt{join_sql_parts} ||= sub { $mod->new(@_) };
+ }
- $opt{render_op} = {
- (map +($_ => '_render_op_between'), 'between', 'not between'),
- (map +($_ => '_render_op_in'), 'in', 'not in'),
- (map +($_ => '_render_unop_postfix'),
- 'is null', 'is not null', 'asc', 'desc',
- ),
- (not => '_render_op_not'),
- (map +($_ => '_render_op_andor'), qw(and or)),
- };
+ $opt{join_sql_parts} ||= sub { join $_[0], @_[1..$#_] };
return bless \%opt, $class;
}
+sub _ext_rw {
+ my ($self, $name, $key, $value) = @_;
+ return $self->{$name}{$key} unless @_ > 3;
+ $self->{$name}{$key} = $value;
+ return $self;
+}
+
+sub make_unop_expander {
+ my (undef, $exp) = @_;
+ sub {
+ my ($self, $name, $body, $k) = @_;
+ return $self->_expand_hashpair_cmp($k, { "-${name}" => $body })
+ if defined($k);
+ return $self->$exp($name, $body);
+ }
+}
+
+sub make_binop_expander {
+ my (undef, $exp) = @_;
+ sub {
+ my ($self, $name, $body, $k) = @_;
+ $k = shift @{$body = [ @$body ]} unless defined $k;
+ $k = ref($k) ? $k : { -ident => $k };
+ return $self->$exp($name, $body, $k);
+ }
+}
+
+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 wrap_${singular} {
+ 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)) {
+ \$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: $@";
+ }
+ 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 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 insert {
- my $self = shift;
- my $table = $self->_table(shift);
- my $data = shift || return;
- my $options = shift;
-
- my $method = $self->_METHOD_FOR_refkind("_insert", $data);
- my ($sql, @bind) = $self->$method($data);
- $sql = join " ", $self->_sqlcase('insert into'), $table, $sql;
-
- if ($options->{returning}) {
- my ($s, @b) = $self->_insert_returning($options);
- $sql .= $s;
- push @bind, @b;
- }
+ my ($self, $table, $data, $options) = @_;
- return wantarray ? ($sql, @bind) : $sql;
+ my $stmt = do {
+ if (ref($table) eq 'HASH') {
+ $table;
+ } else {
+ my %clauses = (target => $table, values => $data, %{$options||{}});
+ \%clauses;
+ }
+ };
+ my @rendered = $self->render_statement({ -insert => $stmt });
+ return wantarray ? @rendered : $rendered[0];
}
-# So that subclasses can override INSERT ... RETURNING separately from
-# UPDATE and DELETE (e.g. DBIx::Class::SQLMaker::Oracle does this)
-sub _insert_returning { shift->_returning(@_) }
-
-sub _returning {
- my ($self, $options) = @_;
+sub _expand_insert_clause_target {
+ +(target => $_[0]->expand_maybe_list_expr($_[2], -ident));
+}
- my $f = $options->{returning};
+sub _expand_insert_clause_fields {
+ return +{ -row => [
+ $_[0]->expand_maybe_list_expr($_[2], -ident)
+ ] } if ref($_[2]) eq 'ARRAY';
+ return $_[2]; # should maybe still expand somewhat?
+}
- my ($sql, @bind) = $self->render_aqt(
- $self->_expand_maybe_list_expr($f, undef, -ident)
+sub _expand_insert_clause_from {
+ my ($self, undef, $data) = @_;
+ if (ref($data) eq 'HASH' and (keys(%$data))[0] =~ /^-/) {
+ return $self->expand_expr($data);
+ }
+ my ($f_aqt, $v_aqt) = $self->_expand_insert_values($data);
+ return (
+ from => { -values => [ $v_aqt ] },
+ ($f_aqt ? (fields => $f_aqt) : ()),
);
- return wantarray
- ? $self->_sqlcase(' returning ') . $sql
- : ($self->_sqlcase(' returning ').$sql, @bind);
}
-sub _insert_HASHREF { # explicit list of fields and then values
- my ($self, $data) = @_;
-
- my @fields = sort keys %$data;
-
- my ($sql, @bind) = $self->_insert_values($data);
-
- # assemble SQL
- $_ = $self->_quote($_) foreach @fields;
- $sql = "( ".join(", ", @fields).") ".$sql;
-
- return ($sql, @bind);
+sub _expand_insert_clause_returning {
+ +(returning => $_[0]->expand_maybe_list_expr($_[2], -ident));
}
-sub _insert_ARRAYREF { # just generate values(?,?) part (no list of fields)
+sub _expand_insert_values {
my ($self, $data) = @_;
+ if (is_literal_value($data)) {
+ (undef, $self->expand_expr($data));
+ } else {
+ my ($fields, $values) = (
+ ref($data) eq 'HASH' ?
+ ([ sort keys %$data ], [ @{$data}{sort keys %$data} ])
+ : ([], $data)
+ );
- # no names (arrayref) so can't generate bindtype
- $self->{bindtype} ne 'columns'
- or belch "can't do 'columns' bindtype when called with arrayref";
-
- my (@values, @all_bind);
- foreach my $value (@$data) {
- my ($values, @bind) = $self->_insert_value(undef, $value);
- push @values, $values;
- push @all_bind, @bind;
+ # no names (arrayref) means can't generate bindtype
+ !($fields) && $self->{bindtype} eq 'columns'
+ && belch "can't do 'columns' bindtype when called with arrayref";
+
+ +(
+ (@$fields
+ ? $self->expand_expr({ -row => $fields }, -ident)
+ : undef
+ ),
+ +{ -row => [
+ map {
+ local our $Cur_Col_Meta = $fields->[$_];
+ $self->_expand_insert_value($values->[$_])
+ } 0..$#$values
+ ] },
+ );
}
- my $sql = $self->_sqlcase('values')." ( ".join(", ", @values)." )";
- return ($sql, @all_bind);
}
-sub _insert_ARRAYREFREF { # literal SQL with bind
- my ($self, $data) = @_;
-
- my ($sql, @bind) = @${$data};
- $self->_assert_bindval_matches_bindtype(@bind);
-
- return ($sql, @bind);
+sub _render_insert_clause_fields {
+ return $_[0]->render_aqt($_[2]);
}
+sub _render_insert_clause_target {
+ my ($self, undef, $from) = @_;
+ $self->join_query_parts(' ', { -keyword => 'insert into' }, $from);
+}
-sub _insert_SCALARREF { # literal SQL without bind
- my ($self, $data) = @_;
-
- return ($$data);
+sub _render_insert_clause_from {
+ return $_[0]->render_aqt($_[2], 1);
}
-sub _insert_values {
- my ($self, $data) = @_;
+# So that subclasses can override INSERT ... RETURNING separately from
+# UPDATE and DELETE (e.g. DBIx::Class::SQLMaker::Oracle does this)
+sub _insert_returning { shift->_returning(@_) }
- my (@values, @all_bind);
- foreach my $column (sort keys %$data) {
- my ($values, @bind) = $self->_insert_value($column, $data->{$column});
- push @values, $values;
- push @all_bind, @bind;
- }
- my $sql = $self->_sqlcase('values')." ( ".join(", ", @values)." )";
- return ($sql, @all_bind);
+sub _redispatch_returning {
+ my ($self, $type, undef, $returning) = @_;
+ [ $self->${\"_${type}_returning"}({ returning => $returning }) ];
}
-sub _insert_value {
- my ($self, $column, $v) = @_;
+sub _returning {
+ my ($self, $options) = @_;
- return $self->render_aqt(
- $self->_expand_insert_value($column, $v)
- );
+ my $f = $options->{returning};
+
+ my ($sql, @bind) = @{ $self->render_aqt(
+ $self->expand_maybe_list_expr($f, -ident)
+ ) };
+ return ($self->_sqlcase(' returning ').$sql, @bind);
}
sub _expand_insert_value {
- my ($self, $column, $v) = @_;
+ my ($self, $v) = @_;
+
+ my $k = our $Cur_Col_Meta;
if (ref($v) eq 'ARRAY') {
if ($self->{array_datatypes}) {
- return +{ -bind => [ $column, $v ] };
+ return +{ -bind => [ $k, $v ] };
}
my ($sql, @bind) = @$v;
$self->_assert_bindval_matches_bindtype(@bind);
if (ref($v) eq 'HASH') {
if (grep !/^-/, keys %$v) {
belch "HASH ref as bind value in insert is not supported";
- return +{ -bind => [ $column, $v ] };
+ return +{ -bind => [ $k, $v ] };
}
}
if (!defined($v)) {
- return +{ -bind => [ $column, undef ] };
+ return +{ -bind => [ $k, undef ] };
}
- local our $Cur_Col_Meta = $column;
return $self->expand_expr($v);
}
# UPDATE methods
#======================================================================
-
sub update {
- my $self = shift;
- my $table = $self->_table(shift);
- my $data = shift || return;
- my $where = shift;
- my $options = shift;
+ my ($self, $table, $set, $where, $options) = @_;
- # first build the 'SET' part of the sql statement
- puke "Unsupported data type specified to \$sql->update"
- unless ref $data eq 'HASH';
-
- my ($sql, @all_bind) = $self->_update_set_values($data);
- $sql = $self->_sqlcase('update ') . $table . $self->_sqlcase(' set ')
- . $sql;
-
- if ($where) {
- my($where_sql, @where_bind) = $self->where($where);
- $sql .= $where_sql;
- push @all_bind, @where_bind;
- }
-
- if ($options->{returning}) {
- my ($returning_sql, @returning_bind) = $self->_update_returning($options);
- $sql .= $returning_sql;
- push @all_bind, @returning_bind;
- }
+ my $stmt = do {
+ if (ref($table) eq 'HASH') {
+ $table
+ } else {
+ my %clauses;
+ @clauses{qw(target set where)} = ($table, $set, $where);
+ puke "Unsupported data type specified to \$sql->update"
+ unless ref($clauses{set}) eq 'HASH';
+ @clauses{keys %$options} = values %$options;
+ \%clauses;
+ }
+ };
+ my @rendered = $self->render_statement({ -update => $stmt });
+ return wantarray ? @rendered : $rendered[0];
+}
- return wantarray ? ($sql, @all_bind) : $sql;
+sub _render_update_clause_target {
+ my ($self, undef, $target) = @_;
+ $self->join_query_parts(' ', { -keyword => 'update' }, $target);
}
sub _update_set_values {
my ($self, $data) = @_;
- return $self->render_aqt(
- $self->_expand_update_set_values($data),
- );
+ return @{ $self->render_aqt(
+ $self->_expand_update_set_values(undef, $data),
+ ) };
}
sub _expand_update_set_values {
- my ($self, $data) = @_;
- $self->_expand_maybe_list_expr( [
+ my ($self, undef, $data) = @_;
+ $self->expand_maybe_list_expr( [
map {
my ($k, $set) = @$_;
$set = { -bind => $_ } unless defined $set;
- +{ -op => [ '=', $self->_expand_ident(-ident => $k), $set ] };
+ +{ -op => [ '=', { -ident => $k }, $set ] };
}
map {
my $k = $_;
] );
}
+sub _expand_update_clause_target {
+ my ($self, undef, $target) = @_;
+ +(target => $self->expand_maybe_list_expr($target, -ident));
+}
+
+sub _expand_update_clause_set {
+ return $_[2] if ref($_[2]) eq 'HASH' and ($_[2]->{-op}||[''])->[0] eq ',';
+ +(set => $_[0]->_expand_update_set_values($_[1], $_[2]));
+}
+
+sub _expand_update_clause_where {
+ +(where => $_[0]->expand_expr($_[2]));
+}
+
+sub _expand_update_clause_returning {
+ +(returning => $_[0]->expand_maybe_list_expr($_[2], -ident));
+}
+
# So that subclasses can override UPDATE ... RETURNING separately from
# INSERT and DELETE
sub _update_returning { shift->_returning(@_) }
# 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, undef, '-ident')
- );
+ return @{ $self->render_aqt(
+ $self->expand_maybe_list_expr($fields, '-ident')
+ ) };
}
#======================================================================
# DELETE
#======================================================================
-
sub delete {
- my $self = shift;
- my $table = $self->_table(shift);
- my $where = shift;
- my $options = shift;
+ my ($self, $table, $where, $options) = @_;
- my($where_sql, @bind) = $self->where($where);
- my $sql = $self->_sqlcase('delete from ') . $table . $where_sql;
-
- if ($options->{returning}) {
- my ($returning_sql, @returning_bind) = $self->_delete_returning($options);
- $sql .= $returning_sql;
- push @bind, @returning_bind;
- }
-
- return wantarray ? ($sql, @bind) : $sql;
+ my $stmt = do {
+ if (ref($table) eq 'HASH') {
+ $table;
+ } else {
+ my %clauses = (target => $table, where => $where, %{$options||{}});
+ \%clauses;
+ }
+ };
+ my @rendered = $self->render_statement({ -delete => $stmt });
+ return wantarray ? @rendered : $rendered[0];
}
# So that subclasses can override DELETE ... RETURNING separately from
# INSERT and UPDATE
sub _delete_returning { shift->_returning(@_) }
+sub _expand_delete_clause_target {
+ +(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));
+}
+
+sub _render_delete_clause_target {
+ my ($self, undef, $from) = @_;
+ $self->join_query_parts(' ', { -keyword => 'delete from' }, $from);
+}
#======================================================================
# WHERE: entry point
return wantarray ? ($sql, @bind) : $sql;
}
+{ our $Default_Scalar_To = -value }
+
sub expand_expr {
my ($self, $expr, $default_scalar_to) = @_;
local our $Default_Scalar_To = $default_scalar_to if $default_scalar_to;
}
sub render_aqt {
- my ($self, $aqt) = @_;
+ my ($self, $aqt, $top_level) = @_;
my ($k, $v, @rest) = %$aqt;
die "No" if @rest;
+ die "Not a node type: $k" unless $k =~ s/^-//;
if (my $meth = $self->{render}{$k}) {
- return $self->$meth($v);
+ local our $Render_Top_Level = $top_level;
+ return $self->$meth($k, $v);
}
die "notreached: $k";
}
sub render_expr {
- my ($self, $expr) = @_;
- $self->render_aqt($self->expand_expr($expr));
+ my ($self, $expr, $default_scalar_to) = @_;
+ return @{ $self->render_aqt(
+ $self->expand_expr($expr, $default_scalar_to)
+ ) };
+}
+
+sub render_statement {
+ my ($self, $expr, $default_scalar_to) = @_;
+ @{$self->render_aqt(
+ $self->expand_expr($expr, $default_scalar_to), 1
+ )};
+}
+
+sub _expand_statement {
+ my ($self, $type, $args) = @_;
+ my $ec = $self->{expand_clause};
+ if ($args->{_}) {
+ $args = { %$args };
+ $args->{$type} = delete $args->{_}
+ }
+ my %has_clause = map +($_ => 1), @{$self->{clauses_of}{$type}};
+ return +{ "-${type}" => +{
+ map {
+ my $val = $args->{$_};
+ if (defined($val) and my $exp = $ec->{"${type}.$_"}) {
+ if ((my (@exp) = $self->$exp($_ => $val)) == 1) {
+ ($_ => $exp[0])
+ } else {
+ @exp
+ }
+ } elsif ($has_clause{$_}) {
+ ($_ => $self->expand_expr($val))
+ } else {
+ ($_ => $val)
+ }
+ } sort keys %$args
+ } };
+}
+
+sub _render_statement {
+ my ($self, $type, $args) = @_;
+ my @parts;
+ foreach my $clause (@{$self->{clauses_of}{$type}}) {
+ next unless my $clause_expr = $args->{$clause};
+ my $part = do {
+ if (my $rdr = $self->{render_clause}{"${type}.${clause}"}) {
+ $self->$rdr($clause, $clause_expr, $args);
+ } else {
+ my $r = $self->render_aqt($clause_expr, 1);
+ next unless defined $r->[0] and length $r->[0];
+ $self->join_query_parts(' ',
+ { -keyword => $clause },
+ $r
+ );
+ }
+ };
+ push @parts, $part;
+ }
+ my $q = $self->join_query_parts(' ', @parts);
+ return $self->join_query_parts('',
+ (our $Render_Top_Level ? $q : ('(', $q, ')'))
+ );
+}
+
+sub _normalize_op {
+ my ($self, $raw) = @_;
+ my $op = lc $raw;
+ return $op if grep $_->{$op}, @{$self}{qw(expand_op render_op)};
+ s/^-(?=.)//, s/\s+/_/g for $op;
+ $op;
}
sub _expand_expr {
if (ref($expr) eq 'HASH') {
return undef unless my $kc = keys %$expr;
if ($kc > 1) {
- return $self->_expand_op_andor(-and => $expr);
+ return $self->_expand_op_andor(and => $expr);
}
my ($key, $value) = %$expr;
if ($key =~ /^-/ and $key =~ s/ [_\s]? \d+ $//x ) {
belch 'Use of [and|or|nest]_N modifiers is deprecated and will be removed in SQLA v2.0. '
. "You probably wanted ...-and => [ $key => COND1, $key => COND2 ... ]";
}
- if (my $exp = $self->{expand}{$key}) {
- return $self->$exp($key, $value);
- }
- return $self->_expand_expr_hashpair($key, $value);
+ return $self->_expand_hashpair($key, $value);
}
if (ref($expr) eq 'ARRAY') {
- my $logic = '-'.lc($self->{logic});
- return $self->_expand_op_andor($logic, $expr);
+ return $self->_expand_op_andor(lc($self->{logic}), $expr);
}
if (my $literal = is_literal_value($expr)) {
return +{ -literal => $literal };
}
if (!ref($expr) or Scalar::Util::blessed($expr)) {
- if (my $d = our $Default_Scalar_To) {
- return $self->_expand_expr({ $d => $expr });
- }
- return $self->_expand_value(-value => $expr);
+ return $self->_expand_scalar($expr);
}
die "notreached";
}
-sub _expand_expr_hashpair {
+sub _expand_hashpair {
my ($self, $k, $v) = @_;
unless (defined($k) and length($k)) {
if (defined($k) and my $literal = is_literal_value($v)) {
}
puke "Supplying an empty left hand side argument is not supported";
}
- if ($k =~ /^-/) {
- return $self->_expand_expr_hashpair_op($k, $v);
+ if ($k =~ /^-./) {
+ return $self->_expand_hashpair_op($k, $v);
+ } elsif ($k =~ /^[^\w]/i) {
+ my ($lhs, @rhs) = ref($v) eq 'ARRAY' ? @$v : $v;
+ return $self->_expand_op(
+ -op, [ $k, $self->expand_expr($lhs, -ident), @rhs ]
+ );
}
- return $self->_expand_expr_hashpair_ident($k, $v);
+ return $self->_expand_hashpair_ident($k, $v);
}
-sub _expand_expr_hashpair_ident {
+sub _expand_hashpair_ident {
my ($self, $k, $v) = @_;
- # undef needs to be re-sent with cmp to achieve IS/IS NOT NULL
+ local our $Cur_Col_Meta = $k;
- if (
- !defined($v)
- or (
- ref($v) eq 'HASH'
- and exists $v->{-value}
- and not defined $v->{-value}
- )
- ) {
- return $self->_expand_expr({ $k => { $self->{cmp} => undef } });
+ # hash with multiple or no elements is andor
+
+ if (ref($v) eq 'HASH' and keys %$v != 1) {
+ return $self->_expand_op_andor(and => $v, $k);
}
- my $ik = $self->_expand_ident(-ident => $k);
+ # undef needs to be re-sent with cmp to achieve IS/IS NOT NULL
+
+ if (is_undef_value($v)) {
+ return $self->_expand_hashpair_cmp($k => undef);
+ }
# scalars and objects get expanded as whatever requested or values
if (!ref($v) or Scalar::Util::blessed($v)) {
- my $d = our $Default_Scalar_To;
- local our $Cur_Col_Meta = $k;
- return $self->_expand_expr_hashpair_ident(
- $k,
- ($d
- ? $self->_expand_expr($d => $v)
- : { -value => $v }
- )
- );
+ return $self->_expand_hashpair_scalar($k, $v);
}
+
+ # single key hashref is a hashtriple
+
if (ref($v) eq 'HASH') {
- if (keys %$v > 1) {
- return $self->_expand_op_andor(-and => $v, $k);
- }
- return undef unless keys %$v;
- my ($vk, $vv) = %$v;
- my $op = join ' ', split '_', (map lc, $vk =~ /^-?(.*)$/)[0];
- $self->_assert_pass_injection_guard($op);
- if ($op =~ s/ [_\s]? \d+ $//x ) {
- return $self->_expand_expr($k, $v);
- }
- if (my $x = $self->{expand_op}{$op}) {
- local our $Cur_Col_Meta = $k;
- return $self->$x($op, $vv, $k);
- }
- if ($op =~ /^is(?: not)?$/) {
- puke "$op can only take undef as argument"
- if defined($vv)
- and not (
- ref($vv) eq 'HASH'
- and exists($vv->{-value})
- and !defined($vv->{-value})
- );
- return +{ -op => [ $op.' null', $ik ] };
- }
- if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{special_ops}}) {
- return { -op => [ $op, $ik, $vv ] };
- }
- if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{unary_ops}}) {
- return { -op => [
- $self->{cmp},
- $ik,
- { -op => [ $op, $vv ] }
- ] };
- }
- if (ref($vv) eq 'ARRAY') {
- my @raw = @$vv;
- my $logic = (defined($raw[0]) and $raw[0] =~ /^-(and|or)$/i)
- ? shift @raw : '-or';
- my @values = map +{ $vk => $_ }, @raw;
- if (
- $op =~ $self->{inequality_op}
- or $op =~ $self->{not_like_op}
- ) {
- if (lc($logic) eq '-or' and @values > 1) {
- belch "A multi-element arrayref as an argument to the inequality op '${\uc($op)}' "
- . 'is technically equivalent to an always-true 1=1 (you probably wanted '
- . "to say ...{ \$inequality_op => [ -and => \@values ] }... instead)"
- ;
- }
- }
- unless (@values) {
- # try to DWIM on equality operators
- return
- $op =~ $self->{equality_op} ? $self->sqlfalse
- : $op =~ $self->{like_op} ? belch("Supplying an empty arrayref to '@{[ uc $op]}' is deprecated") && $self->sqlfalse
- : $op =~ $self->{inequality_op} ? $self->sqltrue
- : $op =~ $self->{not_like_op} ? belch("Supplying an empty arrayref to '@{[ uc $op]}' is deprecated") && $self->sqltrue
- : puke "operator '$op' applied on an empty array (field '$k')";
- }
- return $self->_expand_op_andor($logic => \@values, $k);
- }
- if (
- !defined($vv)
- or (
- ref($vv) eq 'HASH'
- and exists $vv->{-value}
- and not defined $vv->{-value}
- )
- ) {
- my $is =
- $op =~ /^not$/i ? 'is not' # legacy
- : $op =~ $self->{equality_op} ? 'is'
- : $op =~ $self->{like_op} ? belch("Supplying an undefined argument to '@{[ uc $op]}' is deprecated") && 'is'
- : $op =~ $self->{inequality_op} ? 'is not'
- : $op =~ $self->{not_like_op} ? belch("Supplying an undefined argument to '@{[ uc $op]}' is deprecated") && 'is not'
- : puke "unexpected operator '$op' with undef operand";
- return +{ -op => [ $is.' null', $ik ] };
- }
- local our $Cur_Col_Meta = $k;
- return +{ -op => [
- $op,
- $ik,
- $self->_expand_expr($vv)
- ] };
+ return $self->_expand_hashtriple($k, %$v);
}
+
+ # arrayref needs re-engineering over the elements
+
if (ref($v) eq 'ARRAY') {
return $self->sqlfalse unless @$v;
$self->_debug("ARRAY($k) means distribute over elements");
my $logic = lc(
$v->[0] =~ /^-(and|or)$/i
- ? shift(@{$v = [ @$v ]})
- : '-'.lc($self->{logic} || 'OR')
+ ? (shift(@{$v = [ @$v ]}), $1)
+ : lc($self->{logic} || 'OR')
);
return $self->_expand_op_andor(
$logic => $v, $k
);
}
+
if (my $literal = is_literal_value($v)) {
unless (length $k) {
belch 'Hash-pairs consisting of an empty string with a literal are deprecated, and will be removed in 2.0: use -and => [ $literal ] instead';
die "notreached";
}
-sub _expand_expr_hashpair_op {
+sub _expand_scalar {
+ my ($self, $expr) = @_;
+
+ return $self->_expand_expr({ (our $Default_Scalar_To) => $expr });
+}
+
+sub _expand_hashpair_scalar {
my ($self, $k, $v) = @_;
- my $op = $k;
- $op =~ s/^-// if length($op) > 1;
- $self->_assert_pass_injection_guard($op);
+ return $self->_expand_hashpair_cmp(
+ $k, $self->_expand_scalar($v),
+ );
+}
+
+sub _expand_hashpair_op {
+ my ($self, $k, $v) = @_;
+
+ $self->_assert_pass_injection_guard($k =~ /\A-(.*)\Z/s);
+
+ my $op = $self->_normalize_op($k);
+
+ my $wsop = join(' ', split '_', $op);
+
+ my $is_special = List::Util::first { $wsop =~ $_->{regex} }
+ @{$self->{special_ops}};
+
+ { # Old SQLA compat
+
+ # the old special op system requires illegality for top-level use
+
+ if (
+ (our $Expand_Depth) == 1
+ and (
+ $is_special
+ or (
+ $self->{disable_old_special_ops}
+ and List::Util::first { $wsop =~ $_->{regex} } @BUILTIN_SPECIAL_OPS
+ )
+ )
+ ) {
+ puke "Illegal use of top-level '-$wsop'"
+ }
+ }
+
+ if (my $exp = $self->{expand}{$op}||$self->{expand_op}{$op}) {
+ return $self->$exp($op, $v);
+ }
+
+ if ($self->{render}{$op}) {
+ return { "-${op}" => $v };
+ }
# Ops prefixed with -not_ get converted
- if (my ($rest) = $op =~/^not[_ ](.*)$/) {
+ if (my ($rest) = $op =~/^not_(.*)$/) {
return +{ -op => [
'not',
$self->_expand_expr({ "-${rest}", $v })
- ] };
+ ] };
}
- # the old special op system requires illegality for top-level use
+ { # Old SQLA compat
- if (
- (our $Expand_Depth) == 1
- and List::Util::first { $op =~ $_->{regex} } @{$self->{special_ops}}
- ) {
- puke "Illegal use of top-level '-$op'"
+ # the old unary op system means we should touch nothing and let it work
+
+ my $op = join(' ', split '_', $op);
+
+ if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{unary_ops}}) {
+ return { -op => [ $op, $v ] };
+ }
}
- # the old unary op system means we should touch nothing and let it work
+ my $type = $is_special || $self->{render_op}{$op} ? -op : -func;
+
+ if ($self->{restore_old_unop_handling}) {
- if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{unary_ops}}) {
- return { -op => [ $op, $v ] };
+ # Old SQLA compat
+
+ if (
+ ref($v) eq 'HASH'
+ and keys %$v == 1
+ and (keys %$v)[0] =~ /^-/
+ and not $self->{render_op}{$op}
+ and not $is_special
+ ) {
+ $type = -func;
+ } else {
+ $type = -op;
+ }
}
- # an explicit node type is currently assumed to be expanded (this is almost
- # certainly wrong and there should be expansion anyway)
+ if ($type eq -func and ref($v) eq 'ARRAY') {
+ return $self->_expand_expr({ -func => [ $op, @$v ] });
+ }
- if ($self->{render}{$k}) {
- return { $k => $v };
+ return $self->_expand_expr({ $type => [ $op, $v ] });
+}
+
+sub _expand_hashpair_cmp {
+ my ($self, $k, $v) = @_;
+ $self->_expand_hashtriple($k, $self->{cmp}, $v);
+}
+
+sub _expand_hashtriple {
+ my ($self, $k, $vk, $vv) = @_;
+
+ my $ik = $self->_expand_expr({ -ident => $k });
+
+ my $op = $self->_normalize_op($vk);
+ $self->_assert_pass_injection_guard($op);
+
+ if ($op =~ s/ _? \d+ $//x ) {
+ return $self->_expand_expr($k, { $vk, $vv });
+ }
+ if (my $x = $self->{expand_op}{$op}) {
+ local our $Cur_Col_Meta = $k;
+ return $self->$x($op, $vv, $k);
}
+ { # Old SQLA compat
- # hashref RHS values get expanded and used as op/func args
+ my $op = join(' ', split '_', $op);
- if (
- ref($v) eq 'HASH'
- and keys %$v == 1
- and (keys %$v)[0] =~ /^-/
- ) {
- my ($func) = $k =~ /^-(.*)$/;
- if (List::Util::first { $func =~ $_->{regex} } @{$self->{special_ops}}) {
- return +{ -op => [ $func, $self->_expand_expr($v) ] };
+ if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{special_ops}}) {
+ return { -op => [ $op, $ik, $vv ] };
}
- return +{ -func => [ $func, $self->_expand_expr($v) ] };
+ if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{unary_ops}}) {
+ return { -op => [
+ $self->{cmp},
+ $ik,
+ { -op => [ $op, $vv ] }
+ ] };
+ }
+ }
+ if (ref($vv) eq 'ARRAY') {
+ my @raw = @$vv;
+ my $logic = (defined($raw[0]) and $raw[0] =~ /^-(and|or)$/i)
+ ? (shift(@raw), lc $1) : 'or';
+ my @values = map +{ $vk => $_ }, @raw;
+ if (
+ $op =~ $self->{inequality_op}
+ or $op =~ $self->{not_like_op}
+ ) {
+ if (lc($logic) eq 'or' and @values > 1) {
+ belch "A multi-element arrayref as an argument to the inequality op '${\uc(join ' ', split '_', $op)}' "
+ . 'is technically equivalent to an always-true 1=1 (you probably wanted '
+ . "to say ...{ \$inequality_op => [ -and => \@values ] }... instead)"
+ ;
+ }
+ }
+ unless (@values) {
+ # try to DWIM on equality operators
+ return ($self->_dwim_op_to_is($op,
+ "Supplying an empty arrayref to '%s' is deprecated",
+ "operator '%s' applied on an empty array (field '$k')"
+ ) ? $self->sqlfalse : $self->sqltrue);
+ }
+ return $self->_expand_op_andor($logic => \@values, $k);
}
+ if (is_undef_value($vv)) {
+ my $is = ($self->_dwim_op_to_is($op,
+ "Supplying an undefined argument to '%s' is deprecated",
+ "unexpected operator '%s' with undef operand",
+ ) ? 'is' : 'is not');
- # scalars and literals get simply expanded
+ return $self->_expand_hashpair($k => { $is, undef });
+ }
+ local our $Cur_Col_Meta = $k;
+ return +{ -op => [
+ $op,
+ $ik,
+ $self->_expand_expr($vv)
+ ] };
+}
- if (!ref($v) or is_literal_value($v)) {
- return +{ -op => [ $op, $self->_expand_expr($v) ] };
+sub _dwim_op_to_is {
+ my ($self, $raw, $empty, $fail) = @_;
+
+ my $op = $self->_normalize_op($raw);
+
+ if ($op =~ /^not$/i) {
+ return 0;
+ }
+ if ($op =~ $self->{equality_op}) {
+ return 1;
+ }
+ if ($op =~ $self->{like_op}) {
+ belch(sprintf $empty, uc(join ' ', split '_', $op));
+ return 1;
}
+ if ($op =~ $self->{inequality_op}) {
+ return 0;
+ }
+ if ($op =~ $self->{not_like_op}) {
+ belch(sprintf $empty, uc(join ' ', split '_', $op));
+ return 0;
+ }
+ puke(sprintf $fail, $op);
+}
- die "notreached";
+sub _expand_func {
+ my ($self, undef, $args) = @_;
+ my ($func, @args) = @$args;
+ return +{ -func => [ $func, map $self->expand_expr($_), @args ] };
}
sub _expand_ident {
- my ($self, $op, $body) = @_;
+ my ($self, undef, $body) = @_;
unless (defined($body) or (ref($body) and ref($body) eq 'ARRAY')) {
- puke "$op requires a single plain scalar argument (a quotable identifier) or an arrayref of identifier parts";
+ puke "-ident requires a single plain scalar argument (a quotable identifier) or an arrayref of identifier parts";
}
my @parts = map split(/\Q${\($self->{name_sep}||'.')}\E/, $_),
ref($body) ? @$body : $body;
+{ -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 ] };
+}
+
+sub _expand_op {
+ my ($self, undef, $args) = @_;
+ my ($op, @opargs) = @$args;
+ if (my $exp = $self->{expand_op}{$op}) {
+ return $self->$exp($op, \@opargs);
+ }
+ +{ -op => [ $op, map $self->expand_expr($_), @opargs ] };
}
sub _expand_bool {
return $self->_expand_expr($v);
}
puke "-bool => undef not supported" unless defined($v);
- return $self->_expand_ident(-ident => $v);
+ return $self->_expand_expr({ -ident => $v });
}
sub _expand_op_andor {
- my ($self, $logic, $v, $k) = @_;
+ my ($self, $logop, $v, $k) = @_;
if (defined $k) {
$v = [ map +{ $k, $_ },
(ref($v) eq 'HASH')
: @$v,
];
}
- my ($logop) = $logic =~ /^-?(.*)$/;
if (ref($v) eq 'HASH') {
+ return undef unless keys %$v;
return +{ -op => [
$logop,
map $self->_expand_expr({ $_ => $v->{$_} }),
die "notreached";
}
+sub _expand_op_is {
+ my ($self, $op, $vv, $k) = @_;
+ ($k, $vv) = @$vv unless defined $k;
+ puke "$op can only take undef as argument"
+ if defined($vv)
+ and not (
+ ref($vv) eq 'HASH'
+ and exists($vv->{-value})
+ and !defined($vv->{-value})
+ );
+ return +{ -op => [ $op.'_null', $self->expand_expr($k, -ident) ] };
+}
+
sub _expand_between {
my ($self, $op, $vv, $k) = @_;
- local our $Cur_Col_Meta = $k;
my @rhs = map $self->_expand_expr($_),
ref($vv) eq 'ARRAY' ? @$vv : $vv;
unless (
}
return +{ -op => [
$op,
- $self->_expand_ident(-ident => $k),
- @rhs
+ $self->expand_expr($k),
+ map $self->expand_expr($_, -value), @rhs
] }
}
my ($sql, @bind) = @$literal;
my $opened_sql = $self->_open_outer_paren($sql);
return +{ -op => [
- $op, $self->_expand_ident(-ident => $k),
- [ { -literal => [ $opened_sql, @bind ] } ]
+ $op, $self->expand_expr($k, -ident),
+ { -literal => [ $opened_sql, @bind ] }
] };
}
my $undef_err =
;
puke("Argument passed to the '${\uc($op)}' operator can not be undefined")
if !defined($vv);
- my @rhs = map $self->_expand_expr($_),
- map { ref($_) ? $_ : { -bind => [ $k, $_ ] } }
+ my @rhs = map $self->expand_expr($_, -value),
map { defined($_) ? $_: puke($undef_err) }
(ref($vv) eq 'ARRAY' ? @$vv : $vv);
return $self->${\($op =~ /^not/ ? 'sqltrue' : 'sqlfalse')} unless @rhs;
return +{ -op => [
$op,
- $self->_expand_ident(-ident => $k),
- \@rhs
+ $self->expand_expr($k, -ident),
+ @rhs
] };
}
sub _expand_nest {
- my ($self, $op, $v) = @_;
+ my ($self, undef, $v) = @_;
# DBIx::Class requires a nest warning to be emitted once but the private
# method it overrode to do so no longer exists
- if ($self->{is_dbic_sqlmaker}) {
+ if ($self->{warn_once_on_nest}) {
unless (our $Nest_Warned) {
belch(
"-nest in search conditions is deprecated, you most probably wanted:\n"
return $self->_expand_expr($v);
}
+sub _expand_values {
+ my ($self, undef, $values) = @_;
+ return { -values => [
+ map +(
+ ref($_) eq 'HASH'
+ ? $self->expand_expr($_)
+ : +{ -row => [ map $self->expand_expr($_), @$_ ] }
+ ), ref($values) eq 'ARRAY' ? @$values : $values
+ ] };
+}
+
sub _recurse_where {
- my ($self, $where, $logic) = @_;
+ my ($self, $where) = @_;
# Special case: top level simple string treated as literal
my $where_exp = (ref($where)
- ? $self->_expand_expr($where, $logic)
+ ? $self->_expand_select_clause_where(undef, $where)
: { -literal => [ $where ] });
# dispatch expanded expression
- my ($sql, @bind) = defined($where_exp) ? $self->render_aqt($where_exp) : (undef);
+ my ($sql, @bind) = defined($where_exp) ? @{ $self->render_aqt($where_exp) || [] } : ();
# DBIx::Class used to call _recurse_where in scalar context
# something else might too...
if (wantarray) {
}
sub _render_ident {
- my ($self, $ident) = @_;
+ my ($self, undef, $ident) = @_;
- return $self->_convert($self->_quote($ident));
+ return [ $self->_quote($ident) ];
}
-sub _render_list {
- my ($self, $list) = @_;
- my @parts = grep length($_->[0]), map [ $self->render_aqt($_) ], @$list;
- return join(', ', map $_->[0], @parts), map @{$_}[1..$#$_], @parts;
+sub _render_row {
+ my ($self, undef, $values) = @_;
+ return $self->join_query_parts('',
+ '(',
+ $self->_render_op(undef, [ ',', @$values ]),
+ ')'
+ );
}
sub _render_func {
- my ($self, $rest) = @_;
+ my ($self, undef, $rest) = @_;
my ($func, @args) = @$rest;
- my @arg_sql;
- my @bind = map {
- my @x = @$_;
- push @arg_sql, shift @x;
- @x
- } map [ $self->render_aqt($_) ], @args;
- return ($self->_sqlcase($func).'('.join(', ', @arg_sql).')', @bind);
+ return $self->join_query_parts('',
+ $self->_sqlcase($func),
+ $self->join_query_parts('',
+ '(',
+ $self->join_query_parts(', ', @args),
+ ')'
+ ),
+ );
}
sub _render_bind {
- my ($self, $bind) = @_;
- return ($self->_convert('?'), $self->_bindtype(@$bind));
+ my ($self, undef, $bind) = @_;
+ return [ '?', $self->_bindtype(@$bind) ];
}
sub _render_literal {
- my ($self, $literal) = @_;
+ my ($self, undef, $literal) = @_;
$self->_assert_bindval_matches_bindtype(@{$literal}[1..$#$literal]);
- return @$literal;
+ return $literal;
+}
+
+sub _render_keyword {
+ my ($self, undef, $keyword) = @_;
+ return [ $self->_sqlcase(
+ ref($keyword) ? $$keyword : join ' ', split '_', $keyword
+ ) ];
}
+sub _render_op {
+ my ($self, undef, $v) = @_;
+ my ($op, @args) = @$v;
+ if (my $r = $self->{render_op}{$op}) {
+ return $self->$r($op, \@args);
+ }
+
+ { # Old SQLA compat
+
+ my $op = join(' ', split '_', $op);
+
+ my $ss = List::Util::first { $op =~ $_->{regex} } @{$self->{special_ops}};
+ if ($ss and @args > 1) {
+ puke "Special op '${op}' requires first value to be identifier"
+ unless my ($ident) = map $_->{-ident}, grep ref($_) eq 'HASH', $args[0];
+ my $k = join(($self->{name_sep}||'.'), @$ident);
+ local our $Expand_Depth = 1;
+ return [ $self->${\($ss->{handler})}($k, $op, $args[1]) ];
+ }
+ if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{unary_ops}}) {
+ return [ $self->${\($us->{handler})}($op, $args[0]) ];
+ }
+ if ($ss) {
+ return $self->_render_unop_paren($op, \@args);
+ }
+ }
+ if (@args == 1) {
+ return $self->_render_unop_prefix($op, \@args);
+ } else {
+ return $self->_render_op_multop($op, \@args);
+ }
+ die "notreached";
+}
+
+
sub _render_op_between {
my ($self, $op, $args) = @_;
my ($left, $low, $high) = @$args;
- my ($rhsql, @rhbind) = do {
+ my @rh = do {
if (@$args == 2) {
puke "Single arg to between must be a literal"
unless $low->{-literal};
- @{$low->{-literal}}
+ $low;
} else {
- my ($l, $h) = map [ $self->render_aqt($_) ], $low, $high;
- (join(' ', $l->[0], $self->_sqlcase('and'), $h->[0]),
- @{$l}[1..$#$l], @{$h}[1..$#$h])
+ +($low, { -keyword => 'and' }, $high);
}
};
- my ($lhsql, @lhbind) = $self->render_aqt($left);
- return (
- join(' ', '(', $lhsql, $self->_sqlcase($op), $rhsql, ')'),
- @lhbind, @rhbind
+ return $self->join_query_parts(' ',
+ '(', $left, { -keyword => $op }, @rh, ')',
);
}
sub _render_op_in {
my ($self, $op, $args) = @_;
- my ($lhs, $rhs) = @$args;
- my @in_bind;
- my @in_sql = map {
- my ($sql, @bind) = $self->render_aqt($_);
- push @in_bind, @bind;
- $sql;
- } @$rhs;
- my ($lhsql, @lbind) = $self->render_aqt($lhs);
- return (
- $lhsql.' '.$self->_sqlcase($op).' ( '
- .join(', ', @in_sql)
- .' )',
- @lbind, @in_bind
+ my ($lhs, @rhs) = @$args;
+
+ return $self->join_query_parts(' ',
+ $lhs,
+ { -keyword => $op },
+ $self->join_query_parts(' ',
+ '(',
+ $self->join_query_parts(', ', @rhs),
+ ')'
+ ),
);
}
sub _render_op_andor {
my ($self, $op, $args) = @_;
- my @parts = grep length($_->[0]), map [ $self->render_aqt($_) ], @$args;
- return '' unless @parts;
- return @{$parts[0]} if @parts == 1;
- my ($final_sql) = join(
- ' '.$self->_sqlcase($op).' ',
- map $_->[0], @parts
+ return undef unless @$args;
+ return $self->join_query_parts('', $args->[0]) if @$args == 1;
+ my $inner = $self->_render_op_multop($op, $args);
+ return undef unless defined($inner->[0]) and length($inner->[0]);
+ return $self->join_query_parts(' ',
+ '(', $inner, ')'
);
- return (
- '('.$final_sql.')',
- map @{$_}[1..$#$_], @parts
+}
+
+sub _render_op_multop {
+ my ($self, $op, $args) = @_;
+ my @parts = @$args;
+ return undef unless @parts;
+ return $self->render_aqt($parts[0]) if @parts == 1;
+ my $join = ($op eq ','
+ ? ', '
+ : { -keyword => " ${op} " }
+ );
+ return $self->join_query_parts($join, @parts);
+}
+
+sub _render_values {
+ my ($self, undef, $values) = @_;
+ my $inner = $self->join_query_parts(' ',
+ { -keyword => 'values' },
+ $self->join_query_parts(', ',
+ ref($values) eq 'ARRAY' ? @$values : $values
+ ),
+ );
+ return $self->join_query_parts('',
+ (our $Render_Top_Level ? $inner : ('(', $inner, ')'))
);
}
-sub _render_op {
- my ($self, $v) = @_;
- my ($op, @args) = @$v;
- if (my $r = $self->{render_op}{$op}) {
- return $self->$r($op, \@args);
- }
- 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 ($ident) = map $_->{-ident}, grep ref($_) eq 'HASH', $args[0];
- my $k = join(($self->{name_sep}||'.'), @$ident);
- local our $Expand_Depth = 1;
- return $self->${\($us->{handler})}($k, $op, $args[1]);
- }
- if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{unary_ops}}) {
- return $self->${\($us->{handler})}($op, $args[0]);
- }
- if (@args == 1) {
- return $self->_render_unop_prefix($op, \@args);
- } else {
- my @parts = grep length($_->[0]), map [ $self->render_aqt($_) ], @args;
- return '' unless @parts;
- my ($final_sql) = join(
- ' '.$self->_sqlcase($op).' ',
- map $_->[0], @parts
- );
- return (
- $final_sql,
- map @{$_}[1..$#$_], @parts
- );
+sub join_query_parts {
+ my ($self, $join, @parts) = @_;
+ if (ref($join) eq 'HASH') {
+ $join = $self->render_aqt($join)->[0];
}
- die "unhandled";
+ my @final = map +(
+ ref($_) eq 'HASH'
+ ? $self->render_aqt($_)
+ : ((ref($_) eq 'ARRAY') ? $_ : [ $_ ])
+ ), @parts;
+ return [
+ $self->{join_sql_parts}->(
+ $join, grep defined && length, map $_->[0], @final
+ ),
+ (map @{$_}[1..$#$_], @final),
+ ];
}
-sub _render_op_not {
+sub _render_unop_paren {
my ($self, $op, $v) = @_;
- my ($sql, @bind) = $self->_render_unop_prefix($op, $v);
- return "(${sql})", @bind;
+ return $self->join_query_parts('',
+ '(', $self->_render_unop_prefix($op, $v), ')'
+ );
}
sub _render_unop_prefix {
my ($self, $op, $v) = @_;
- my ($expr_sql, @bind) = $self->render_aqt($v->[0]);
- my $op_sql = $self->_sqlcase($op);
- return ("${op_sql} ${expr_sql}", @bind);
+ my $op_sql = $self->{restore_old_unop_handling}
+ ? $self->_sqlcase($op)
+ : { -keyword => $op };
+ return $self->join_query_parts(' ',
+ ($self->{restore_old_unop_handling}
+ ? $self->_sqlcase($op)
+ : { -keyword => \$op }),
+ $v->[0]
+ );
}
sub _render_unop_postfix {
my ($self, $op, $v) = @_;
- my ($expr_sql, @bind) = $self->render_aqt($v->[0]);
- my $op_sql = $self->_sqlcase($op);
- return ($expr_sql.' '.$op_sql, @bind);
+ return $self->join_query_parts(' ',
+ $v->[0], { -keyword => $op },
+ );
}
# Some databases (SQLite) treat col IN (1, 2) different from
return unless defined($arg) and not (ref($arg) eq 'ARRAY' and !@$arg);
+ return $self->expand_maybe_list_expr($arg)
+ if ref($arg) eq 'HASH' and ($arg->{-op}||[''])->[0] eq ',';
+
my $expander = sub {
my ($self, $dir, $expr) = @_;
my @to_expand = ref($expr) eq 'ARRAY' ? @$expr : $expr;
),
map $self->expand_expr($_, -ident),
map ref($_) eq 'ARRAY' ? @$_ : $_, @to_expand;
- return (@exp > 1 ? { -list => \@exp } : $exp[0]);
+ return undef unless @exp;
+ return undef if @exp == 1 and not defined($exp[0]);
+ return +{ -op => [ ',', @exp ] };
};
- local @{$self->{expand}}{qw(-asc -desc)} = (($expander) x 2);
+ local @{$self->{expand}}{qw(asc desc)} = (($expander) x 2);
return $self->$expander(undef, $arg);
}
return '' unless defined(my $expanded = $self->_expand_order_by($arg));
- my ($sql, @bind) = $self->render_aqt($expanded);
+ my ($sql, @bind) = @{ $self->render_aqt($expanded) };
return '' unless length($sql);
my $final_sql = $self->_sqlcase(' order by ').$sql;
- return wantarray ? ($final_sql, @bind) : $final_sql;
+ return ($final_sql, @bind);
}
# _order_by no longer needs to call this so doesn't but DBIC uses it.
return () unless defined(my $expanded = $self->_expand_order_by($arg));
- return $self->_chunkify_order_by($expanded);
+ my @res = $self->_chunkify_order_by($expanded);
+ (ref() ? $_->[0] : $_) .= '' for @res;
+ return @res;
}
sub _chunkify_order_by {
my ($self, $expanded) = @_;
- return grep length, $self->render_aqt($expanded)
+ return grep length, @{ $self->render_aqt($expanded) }
if $expanded->{-ident} or @{$expanded->{-literal}||[]} == 1;
for ($expanded) {
- if (ref() eq 'HASH' and my $l = $_->{-list}) {
- return map $self->_chunkify_order_by($_), @$l;
+ if (ref() eq 'HASH' and $_->{-op} and $_->{-op}[0] eq ',') {
+ my ($comma, @list) = @{$_->{-op}};
+ return map $self->_chunkify_order_by($_), @list;
}
- return [ $self->render_aqt($_) ];
+ return $self->render_aqt($_);
}
}
sub _table {
my $self = shift;
my $from = shift;
- ($self->render_aqt(
- $self->_expand_maybe_list_expr($from, undef, -ident)
- ))[0];
+ $self->render_aqt(
+ $self->expand_maybe_list_expr($from, -ident)
+ )->[0];
}
# UTILITY FUNCTIONS
#======================================================================
-sub _expand_maybe_list_expr {
- my ($self, $expr, $logic, $default) = @_;
- my $e = do {
- if (ref($expr) eq 'ARRAY') {
- return { -list => [
- map $self->expand_expr($_, $default), @$expr
- ] } if @$expr > 1;
- $expr->[0]
- } else {
- $expr
- }
- };
- return $self->expand_expr($e, $default);
+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
# Conversion, if applicable
sub _convert {
#my ($self, $arg) = @_;
- if ($_[0]->{convert_where}) {
- return $_[0]->_sqlcase($_[0]->{convert_where}) .'(' . $_[1] . ')';
+ if (my $conv = $_[0]->{convert_where}) {
+ return @{ $_[0]->join_query_parts('',
+ $_[0]->_sqlcase($conv),
+ '(' , $_[1] , ')'
+ ) };
}
return $_[1];
}
}
}
-sub _join_sql_clauses {
- my ($self, $logic, $clauses_aref, $bind_aref) = @_;
-
- if (@$clauses_aref > 1) {
- my $join = " " . $self->_sqlcase($logic) . " ";
- my $sql = '( ' . join($join, @$clauses_aref) . ' )';
- return ($sql, @$bind_aref);
- }
- elsif (@$clauses_aref) {
- return ($clauses_aref->[0], @$bind_aref); # no parentheses
- }
- else {
- return (); # if no SQL, ignore @$bind_aref
- }
-}
-
-
# Fix SQL case, if so requested
sub _sqlcase {
# LDNOTE: if $self->{case} is true, then it contains 'lower', so we
return $_[0]->{case} ? $_[1] : uc($_[1]);
}
-
#======================================================================
# DISPATCHING FROM REFKIND
#======================================================================
# This allows us to check for a local, then _form, attr
my $self = shift;
my($name) = $AUTOLOAD =~ /.*::(.+)/;
+ puke "AUTOLOAD invoked for method name ${name} and allow_autoload option not set" unless $self->{allow_autoload};
return $self->generate($name, @_);
}
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
+
+See L<SQL::Abstract::Reference> for the C<expr> versus C<aqt> concept and
+an explanation of what the below extensions are extending.
+
+=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 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.
+
+ 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