Use seperate dispatch table for where to top level

[dbsrgits/SQL-Abstract-2.0-ish.git] / lib / SQL / Abstract.pm

diff --git a/lib/SQL/Abstract.pm b/lib/SQL/Abstract.pm
index 7c89615..f077979 100644 (file)
--- a/lib/SQL/Abstract.pm
+++ b/lib/SQL/Abstract.pm
@@ -1,5 +1,4 @@
 use MooseX::Declare;
-use MooseX::Method::Signatures;
 
 
 class SQL::Abstract {
@@ -8,11 +7,11 @@ class SQL::Abstract {
   use Data::Dump qw/pp/;
 
   use Moose::Util::TypeConstraints;
-  use MooseX::Types -declare => ['NameSeparator'];
-  use MooseX::Types::Moose qw/ArrayRef Str/;
+  use MooseX::Types -declare => [qw/NameSeparator/];
+  use MooseX::Types::Moose qw/ArrayRef Str Int HashRef CodeRef/;
   use MooseX::AttributeHelpers;
 
-  use namespace::clean -except => ['meta'];
+  clean;
 
   subtype NameSeparator,
     as ArrayRef[Str];
@@ -25,6 +24,59 @@ class SQL::Abstract {
 
   our $AST_VERSION = '1';
 
+  # Operator precedence for bracketing
+  our %PRIO = (
+    and => 10,
+    or  => 50
+  );
+
+  our %BINOP_MAP = (
+    '>' => '>',
+    '<' => '<',
+    '==' => '=',
+    '!=' => '!=',
+    # LIKE is always "field LIKE <value>"
+    '-like' => 'IN',
+    '-not_like' => 'NOT LIKE',
+  );
+
+  has where_dispatch_table => (
+    is => 'ro',
+    lazy_build => 1,
+    isa => HashRef[CodeRef],
+    metaclass => 'Collection::ImmutableHash',
+    provides => {
+      get => 'lookup_where_dispatch'
+    }
+  );
+
+  has binop_map => (
+    is => 'ro',
+    lazy_build => 1,
+    isa => HashRef,
+    metaclass => 'Collection::ImmutableHash',
+    provides => {
+      exists => 'is_valid_binop',
+      get => 'binop_mapping',
+      keys => 'binary_operators'
+    }
+  );
+
+  sub _build_binop_map { return {%BINOP_MAP} };
+
+  method _build_where_dispatch_table {
+    my $binop = $self->can('_binop') or croak "InternalError: $self can't do _binop!";
+    return {
+      map { $_ => $binop } $self->binary_operators
+    }
+  }
+
+  has ast_version => (
+    is => 'ro',
+    isa => Int,
+    required => 1
+  );
+
   has name_separator => ( 
     is => 'rw', 
     isa => NameSeparator,
@@ -42,86 +94,51 @@ class SQL::Abstract {
 
   has binds => (
     isa => ArrayRef,
+    is => 'ro',
+    clearer => '_clear_binds',
+    lazy => 1,
     default => sub { [ ] },
     metaclass => 'Collection::Array',
     provides => {
       push => 'add_bind',
-      get => 'binds'
     }
   );
 
-  method generate (ArrayRef $ast) {
-    $self = new $self unless blessed($self);
+  # TODO: once MXMS supports %args, use that here
+  method create(ClassName $class: Int $ver) {
+    croak "AST version $ver is greater than supported version of $AST_VERSION"
+      if $ver > $AST_VERSION;
 
-    local $_ = $ast->[0];
-    s/^-/_/ or croak "Unknown type tag '$_'";
-    my $meth = $self->can($_) || \&_generic_func;
-    return $meth->($self, $ast);
-  }
+    my $name = "${class}::AST::v$ver";
+    Class::MOP::load_class($name);
 
-  method _select(ArrayRef $ast) {
-    
+    return $name->new(ast_version => $ver);
   }
 
-  method _name(ArrayRef $ast) {
-    my (undef, @names) = @$ast;
-
-    my $sep = $self->name_separator;
-
-    return $sep->[0] . 
-           join( $sep->[1] . $sep->[0], @names ) . 
-           $sep->[1]
-              if (@$sep > 1);
+  # Main entry point
+  method generate(ClassName $class: ArrayRef $ast) {
+    croak "SQL::Abstract AST version not specified"
+      unless ($ast->[0] eq '-ast_version');
 
-    return join($sep->[0], @names);
-  }
+    my (undef, $ver) = splice(@$ast, 0, 2);
 
-  method _list(ArrayRef $ast) {
-    my (undef, @items) = @$ast;
+    # TODO: once MXMS supports %args, use that here
+    my $self = $class->create($ver);
 
-    return join(
-      $self->list_separator,
-      map { $self->generate($_) } @items);
+    return ($self->dispatch($ast), $self->binds);
   }
 
-  method _alias(ArrayRef $ast) {
-    my (undef, $alias, $as) = @$ast;
-
-    return $self->generate($alias) . " AS $as";
-
+  method reset() {
+    $self->_clear_binds();
   }
 
-  method _value(ArrayRef $ast) {
-    my ($undef, $value) = @$ast;
-
-    $self->add_bind($value);
-    return "?";
-  }
-
-  method _where(ArrayRef $ast) {
-    my (undef, @clauses) = @$ast;
-
-    my @output;
-
-    foreach (@clauses) {
-      my $op = $_->[0];
+  method dispatch (ArrayRef $ast) {
 
-      unless (substr($op, 0, 1) eq '-') {
-        # A simple comparison op (==, >, etc.)
-        croak "Binary operator $op expects 2 children, got " . $#$_
-          if @{$_} > 3;
-
-        push @output, $self->generate($_->[1]), 
-                      $op,
-                      $self->generate($_->[2]);
-      }
-    }
-
-    return join(' ', 'WHERE', @output);
-  }
-
-  method _generic_func(ArrayRef $ast) {
+    local $_ = $ast->[0];
+    s/^-/_/ or croak "Unknown type tag '$_'";
+    
+    my $meth = $self->can($_) || croak "Unknown tag '$_'";
+    return $meth->($self, $ast);
   }
 
-
 };