use Moose::Util::TypeConstraints;
use MooseX::Types::Moose qw/Str ScalarRef ArrayRef HashRef/;
use SQL::Abstract::Types::Compat ':all';
- use SQL::Abstract::Types qw/AST/;
+ use SQL::Abstract::Types qw/AST NameSeparator QuoteChars/;
use SQL::Abstract::AST::v1;
use Data::Dump qw/pp/;
use Devel::PartialDump qw/dump/;
predicate => 'has_field_convertor'
);
+ # TODO: a metaclass trait to automatically use this on vistior construction
+ has quote_char => (
+ is => 'rw',
+ isa => QuoteChars,
+ coerce => 1,
+ predicate => "has_quote_chars"
+ );
+
+ has name_sep => (
+ is => 'rw',
+ isa => NameSeparator,
+ predicate => "has_name_sep"
+ );
+
+ method _build_visitor() {
+ my %args = (
+ ast_version => 1
+ );
+ $args{quote_chars} = $self->quote_char
+ if $self->has_quote_chars;
+ $args{name_sep} = $self->name_sep
+ if $self->has_name_sep;
+
+ # TODO: this needs improving along with SQL::A::create
+ my $visitor = SQL::Abstract::AST::v1->new(%args);
+ }
+
method select(Str|ArrayRef|ScalarRef $from, ArrayRef|Str $fields,
WhereType $where?,
WhereType $order?)
{
my $ast = $self->select_ast($from,$fields,$where,$order);
- return ($self->visitor->dispatch($ast), $self->visitor->binds);
+ $DB::single = 1;
+ return ($self->visitor->dispatch($ast), @{$self->visitor->binds});
}
+
method select_ast(Str|ArrayRef|ScalarRef $from, ArrayRef|Str $fields,
WhereType $where?,
WhereType $order?)
$ast->{where} = $self->recurse_where($where)
if defined $where;
+
+ if (defined $order) {
+ my @order = is_ArrayRef($order) ? @$order : $order;
+ $ast->{order_by} = [ map { $self->mk_name(0, $_) } @order ];
+ }
+
return $ast;
}
return $ret;
}
- method _build_visitor() {
- return SQL::Abstract->create(1);
- }
+ # method mk_name(Bool $use_convert, Str @names) {
sub mk_name {
- my ($self, $use_convert) = (shift,shift);
- my $ast = { -type => 'name', args => [ @_ ] };
+ my ($self, $use_convert, @names) = @_;
+
+ @names = split /\Q@{[$self->name_sep]}\E/, $names[0]
+ if (@names == 1 && $self->has_name_sep);
+
+ my $ast = { -type => 'name', args => [ @names ] };
return $ast
unless $use_convert && $self->has_field_convertor;
method tablespec(Str|ArrayRef|ScalarRef $from) {
return $self->mk_name(0, $from)
if is_Str($from);
+
+ return {
+ -type => 'list',
+ args => [ map {
+ $self->mk_name(0, $_)
+ } @$from ]
+ };
}
method recurse_where(WhereType $ast, LogicEnum $logic?) returns (AST) {
croak "Unknown where clause type " . dump($ast);
}
+ # Deals with where({ .... }) case
method recurse_where_hash(LogicEnum $logic, HashRef $ast) returns (AST) {
my @args;
my $ret = {
return $ret;
}
+ # Deals with where([ .... ]) case
method recurse_where_array(LogicEnum $logic, ArrayRef $ast) returns (AST) {
my @args;
my $ret = {
return $ret;
}
- method field(Str $key, $value) returns (AST) {
- my $op = $CMP_MAP{$self->cmp} || $self->cmp;
+ # { field => { .... } } case
+ method field_hash(Str $key, HashRef $value) returns (AST) {
+ my ($op, @rest) = keys %$value;
+
+ confess "Don't know how to handle " . dump($value) . " (too many keys)"
+ if @rest;
+
+ $value = $value->{$op};
+
my $ret = {
-type => 'expr',
op => $op,
$self->mk_name(1, $key)
],
};
+ $ret->{op} = $op;
+
+ # TODO: Validate the op?
+ # 'word_like' operator
+ if ($op =~ /^-?(?:(not)[_ ])?([a-z_]+)$/i) {
+ $ret->{op} = lc $2;
+ $ret->{op} = "not_" . $ret->{op} if $1;
+
- if (is_HashRef($value)) {
- my ($op, @rest) = keys %$value;
- confess "Don't know how to handle " . dump($value) . " (too many keys)"
- if @rest;
- $value = $value->{$op};
-
- # TODO: Validate the op?
- if ($op =~ /^-?(?:(not)[_ ])?([a-z_]+)$/i) {
- $ret->{op} = lc $2;
- $ret->{op} = "not_" . $ret->{op} if $1;
-
- if (is_ArrayRef($value)) {
- push @{$ret->{args}}, $self->value($_)
- for @{$value};
- return $ret;
- }
- }
- else {
- $ret->{op} = $op;
- }
-
if (is_ArrayRef($value)) {
- local $self->{cmp} = $op;
-
- my $ast = {
- -type => 'expr',
- # Handle e => { '!=', [qw(f g)] }.
- # SQLA treats this as a 'DWIM'
- op => $op eq '!=' ? 'or' : 'and',
- args => [ map {
- $self->field($key, $_)
- } @{$value} ]
- };
- return $ast;
+ push @{$ret->{args}}, $self->value($_) for @{$value};
+ return $ret;
}
- push @{$ret->{args}}, $self->value($value);
-
}
- elsif (is_ArrayRef($value)) {
- # Return an or clause, sort of.
- return {
+
+ # Cases like:
+ # field => { '!=' => [ 'a','b','c'] }
+ # field => { '<' => [ 'a','b','c'] }
+ #
+ # *not* when op is a work or function operator - basic cmp operator only
+ if (is_ArrayRef($value)) {
+ local $self->{cmp} = $op;
+
+ my $ast = {
-type => 'expr',
op => 'or',
args => [ map {
- $self->field($key, $_)
- } @$value ]
+ $self->field($key, $_)
+ } @{$value} ]
};
+ return $ast;
+ }
+
+
+ push @{$ret->{args}}, $self->value($value);
+ return $ret;
+ }
+
+ # Handle [ { ... }, { ... } ]
+ method field_array(Str $key, ArrayRef $value) {
+ # Return an or clause, sort of.
+ return {
+ -type => 'expr',
+ op => 'or',
+ args => [ map {
+ $self->field($key, $_)
+ } @$value ]
+ };
+ }
+
+ method field(Str $key, $value) returns (AST) {
+
+ if (is_HashRef($value)) {
+ return $self->field_hash($key, $value);
}
- else {
- push @{$ret->{args}}, $self->value($value);
+ elsif (is_ArrayRef($value)) {
+ return $self->field_array($key, $value);
}
+ my $ret = {
+ -type => 'expr',
+ op => $CMP_MAP{$self->cmp} || $self->cmp,
+ args => [
+ $self->mk_name(1, $key),
+ $self->value($value)
+ ],
+ };
+
return $ret;
}
projects / dbsrgits/SQL-Abstract-2.0-ish.git / blobdiff