@@ -1,4 +1,8 @@

 0.1692

+    - separate DBIx::Custom type_rule from filter

+    - DBIx::Custom Model filter attrribute is DEPRECATED!

+    - removed EXPERIMENTAL DBIx::Custom::Model alias_table

+    - added DBIx::Custom column method's table option

     - separate DBIx::Custom::Result type_rule from filter again

 0.1692

     - removed EXPERIMENTAL DBIx::Model result_filter

@@ -99,7 +99,16 @@ sub assign_param {

 }

 sub column {

-    my ($self, $table, $columns) = @_;

+    my $self = shift;

+    my $option = pop if ref $_[-1] eq 'HASH';

+    my $real_table = shift;

+    my $columns = shift;

+    my $table = $option->{alias} || $real_table;

+    

+    # Columns

+    unless ($columns) {

+        $columns ||= $self->model($real_table)->columns;

+    }

     # Reserved word quote

     my $q = $self->reserved_word_quote;

@@ -305,17 +314,10 @@ sub create_model {

     my $filter = ref $model->filter eq 'HASH'

                ? [%{$model->filter}]

                : $model->filter;

+    warn "DBIx::Custom::Model filter method is DEPRECATED!"

+      if @$filter;

     $self->_apply_filter($model->table, @$filter);

-    

-    # Associate table with model

-    croak "Table name is duplicated " . _subname

-      if exists $self->{_model_from}->{$model->table};

-    $self->{_model_from}->{$model->table} = $model->name;

-    # Table alias

-    $self->{_table_alias} ||= {};

-    $self->{_table_alias} = {%{$self->{_table_alias}}, %{$model->table_alias}};

-    

     # Set model

     $self->model($model->name, $model);

@@ -381,33 +383,6 @@ sub execute {

         $_ =~ s/$q//g for @$tables;

     }

-    # Table alias

-    foreach my $table (@$tables) {

-        

-        # No need

-        next unless my $alias = $self->{_table_alias}->{$table};

-        $self->{filter} ||= {};

-        next if $self->{filter}{out}{$table};

-        

-        # Filter

-        $self->{filter}{out} ||= {};

-        $self->{filter}{in}  ||= {};

-        $self->{filter}{end} ||= {};

-        

-        # Create alias filter

-        foreach my $type (qw/out in end/) {

-            my @filter_names = keys %{$self->{filter}{$type}{$alias} || {}};

-            foreach my $filter_name (@filter_names) {

-                my $filter_name_alias = $filter_name;

-                $filter_name_alias =~ s/^$alias\./$table\./;

-                $filter_name_alias =~ s/^${alias}__/${table}__/; 

-                $filter_name_alias =~ s/^${alias}-/${table}-/; 

-                $self->{filter}{$type}{$table}{$filter_name_alias}

-                  = $self->{filter}{$type}{$alias}{$filter_name}

-            }

-        }

-    }

-

     # Type rule

     my $applied_filter = {};

     unless ($type_rule_off) {

@@ -981,7 +956,7 @@ sub type_rule {

         # Into

         $type_rule->{into} = _array_to_hash($type_rule->{into});

         $self->{type_rule} = $type_rule;

-        $self->{_into} ||= {};

+        $self->{_into} = {};

         foreach my $type_name (keys %{$type_rule->{into} || {}}) {

             croak qq{type name of into section must be lower case}

               if $type_name =~ /[A-Z]/;

@@ -9,9 +9,7 @@ use DBIx::Custom::Util '_subname';

 push @DBIx::Custom::CARP_NOT, __PACKAGE__;

 has [qw/dbi name table view/],

-    table_alias => sub { {} },

     columns => sub { [] },

-    filter => sub { [] },

     join => sub { [] },

     type => sub { [] },

     primary_key => sub { [] };

@@ -64,23 +62,6 @@ foreach my $method (@methods) {

     *{"${class}::$method"} = $code;

 }

-sub column {

-    my ($self, $table, $columns) = @_;

-    

-    $self->{_table_alias} ||= {};

-    my $dist;

-    $dist = $self->dbi->{_table_alias}{$table}

-          ? $self->dbi->{_table_alias}{$table}

-          : $table;

-    

-    $self->dbi->{_model_from} ||= {};

-    my $model = $self->dbi->{_model_from}->{$dist};

-    

-    $columns ||= $self->model($model)->columns;

-    

-    return $self->dbi->column($table, $columns);

-}

-

 sub DESTROY { }

 sub method {

@@ -117,6 +98,9 @@ sub new {

     return $self;

 }

+# DEPRECATED!

+has filter => sub { [] };

+

 1;

 =head1 NAME

@@ -138,16 +122,6 @@ my $table = DBIx::Custom::Model->new(table => 'books');

 L<DBIx::Custom> object.

-=head2 C<filter>

-

-    my $dbi = $model->filter

-    $model  = $model->filter(

-        title => {out => 'tp_to_date', in => 'date_to_tp'}

-        author => {out => ..., in => ...},

-    );

-

-This filter is applied when L<DBIx::Custom>'s C<include_model()> is called.

-

 =head2 C<name>

     my $name = $model->name;

@@ -180,15 +154,6 @@ C<delete_at()>,C<select_at()>.

 Table name, this is used as C<select()> C<table> option.

 Generally, this is automatically set from class name.

-=head2 C<table_alias> EXPERIMENTAL

-

-    my $table_alias = $model->table_alias;

-    $model = $model->table_alias(user1 => 'user', user2 => 'user');

-

-Table alias. If you define table alias,

-same filter as the table is avaliable

-, and can write $dbi->column('user1') to get all columns.

-

 =head2 C<type>

     my $type = $model->type;

@@ -208,22 +173,10 @@ model is included by C<include_model>.

 =head1 METHODS

-L<DBIx::Custom> inherits all methods from L<Object::Simple>,

-and you can use all methods of the object set to C<dbi>.

+L<DBIx::Custom::Model> inherits all methods from L<Object::Simple>,

+and you can use all methods of L<DBIx::Custom> and L<DBI>

 and implements the following new ones.

-=head2 C<column> EXPERIMETNAL

-

-    my $column = $model->column(book => ['author', 'title']);

-    my $column = $model->column('book');

-

-Create column clause. The follwoing column clause is created.

-

-    book.author as "book.author",

-    book.title as "book.title"

-

-If Second argument is ommited, all columns set by C<columns> is used.

-

 =head2 C<delete>

     $table->delete(...);

@@ -107,183 +107,137 @@ sub register_tag {

 # DEPRECATED!

 sub _parse_tag {

     my ($self, $source) = @_;

-

     # Source

     $source ||= '';

-

     # Tree

     my @tree;

-    

     # Value

     my $value = '';

-    

     # State

     my $state = 'text';

-    

     # Before charactor

     my $before = '';

-

     # Position

     my $pos = 0;

-    

     # Parse

     my $original = $source;

     my $tag_count = 0;

     while (defined(my $c = substr($source, $pos, 1))) {

-        

         # Last

         last unless length $c;

-        

         # Parameter

         if ($c eq ':' && (substr($source, $pos + 1, 1) || '') =~ /\w/) {

             push @tree, {type => 'param'};;

         }

-        

         # State is text

         if ($state eq 'text') {

-            

             # Tag start charactor

             if ($c eq '{') {

-                

                 # Escaped charactor

                 if ($before eq "\\") {

                     substr($value, -1, 1, '');

                     $value .= $c;

                 }

-                

                 # Tag start

                 else {

-                    

                     # Change state

                     $state = 'tag';

-                    

                     # Add text

                     push @tree, {type => 'text', value => $value}

                       if $value;

-                    

                     # Clear

                     $value = '';

                 }

             }

-            

             # Tag end charactor

             elsif ($c eq '}') {

-            

                 # Escaped charactor

                 if ($before eq "\\") {

                     substr($value, -1, 1, '');

                     $value .= $c;

                 }

-                

                 # Unexpected

                 else {

                     croak qq{Parsing error. unexpected "\}". }

                         . qq{pos $pos of "$original" } . _subname

                 }

             }

-            

             # Normal charactor

             else { $value .= $c }

         }

-        

         # State is tags

         else {

-            

             # Tag start charactor

             if ($c eq '{') {

-            

                 # Escaped charactor

                 if ($before eq "\\") {

                     substr($value, -1, 1, '');

                     $value .= $c;

                 }

-                

                 # Unexpected

                 else {

                     croak qq{Parsing error. unexpected "\{". }

                         . qq{pos $pos of "$original" } . _subname

                 }

             }

-            

             # Tag end charactor

             elsif ($c eq '}') {

-                

                 # Escaped charactor

                 if ($before eq "\\") {

                     substr($value, -1, 1, '');

                     $value .= $c;

                 }

-                

                 # Tag end

                 else {

-                

                     # Change state

                     $state = 'text';

-                    

                     # Add tag

                     my ($tag_name, @tag_args) = split /\s+/, $value;

                     push @tree, {type => 'tag', tag_name => $tag_name, 

                                  tag_args => \@tag_args};

-                    

                     # Clear

                     $value = '';

-                    

                     # Countup

                     $tag_count++;

                 }

             }

-            

             # Normal charactor

             else { $value .= $c }

         }

-        

         # Save before charactor

         $before = $c;

-        

         # increment position

         $pos++;

     }

-    

     # Tag not finished

     croak qq{Tag not finished. "$original" } . _subname

       if $state eq 'tag';

-    

     # Not contains tag

     return DBIx::Custom::Query->new(sql => $source, tag_count => $tag_count)

       if $tag_count == 0;

-    

     # Add rest text

     push @tree, {type => 'text', value => $value}

       if $value;

-        

     # SQL

     my $sql = '';

-    

     # All Columns

     my $all_columns = [];

-    

     # Tables

     my $tables = [];

-    

     # Build SQL 

     foreach my $node (@tree) {

-        

         # Text

         if ($node->{type} eq 'text') { $sql .= $node->{value} }

-        

         # Parameter

         elsif ($node->{type} eq 'param') {

             push @$all_columns, 'RESERVED_PARAMETER';

         }

         # Tag

         else {

-            

             # Tag name

             my $tag_name = $node->{tag_name};

-            

             # Tag arguments

             my $tag_args = $node->{tag_args};

-            

             # Table

             if ($tag_name eq 'table') {

                 my $table = $tag_args->[0];

@@ -291,38 +245,29 @@ sub _parse_tag {

                 $sql .= $table;

                 next;

             }

-

             # Get tag

             my $tag = $self->tag_processors->{$tag_name}

                              || $self->tags->{$tag_name};

-            

             # Tag is not registered

             croak qq{Tag "$tag_name" is not registered } . _subname

               unless $tag;

-            

             # Tag not sub reference

             croak qq{Tag "$tag_name" must be sub reference } . _subname

               unless ref $tag eq 'CODE';

-            

             # Execute tag

             my $r = $tag->(@$tag_args);

-            

             # Check tag return value

             croak qq{Tag "$tag_name" must return [STRING, ARRAY_REFERENCE] }

                 . _subname

               unless ref $r eq 'ARRAY' && defined $r->[0] && ref $r->[1] eq 'ARRAY';

-            

             # Part of SQL statement and colum names

             my ($part, $columns) = @$r;

-            

             # Add columns

             push @$all_columns, @$columns;

-            

             # Join part tag to SQL

             $sql .= $part;

         }

     }

-

     # Query

     my $query = DBIx::Custom::Query->new(

         sql => $sql,

@@ -330,7 +275,6 @@ sub _parse_tag {

         tables => $tables,

         tag_count => $tag_count

     );

-    

     return $query;

 }

@@ -340,13 +284,10 @@ has tag_processors => sub { {} };

 # DEPRECATED!

 sub register_tag_processor {

     my $self = shift;

-    

     warn "register_tag_processor is DEPRECATED! use register_tag instead";

-    

     # Merge tag

     my $tag_processors = ref $_[0] eq 'HASH' ? $_[0] : {@_};

     $self->tag_processors({%{$self->tag_processors}, %{$tag_processors}});

-    

     return $self;

 }

@@ -423,6 +423,7 @@ Fetch multiple rows and put them into array of array reference.

 Set filter for column.

 You can use subroutine or filter name as filter.

+This filter is executed after C<type_rule> filter.

 =head2 C<one>

@@ -2170,7 +2170,7 @@ $model = $dbi->model('table1');

 eval{$model->execute('select * from table1')};

 ok(!$@);

-test 'table_alias';

+test 'column table option';

 $dbi = MyDBI9->connect($NEW_ARGS->{0});

 $dbi->execute($CREATE_TABLE->{0});

 $dbi->execute($CREATE_TABLE->{2});

@@ -2180,32 +2180,32 @@ $dbi->execute('insert into table2 (key1, key3) values (1, 4);');

 $model = $dbi->model('table1');

 $result = $model->select(

     column => [

-        $model->column('table2_alias')

+        $model->column('table2', {alias => 'table2_alias'})

     ],

-    where => {'table2_alias.key3' => 2}

+    where => {'table2_alias.key3' => 4}

 );

 is_deeply($result->one, 

-          {'table2_alias.key1' => 1, 'table2_alias.key3' => 48});

+          {'table2_alias.key1' => 1, 'table2_alias.key3' => 4});

 $dbi->separator('__');

 $result = $model->select(

     column => [

-        $model->column('table2_alias')

+        $model->column('table2', {alias => 'table2_alias'})

     ],

-    where => {'table2_alias.key3' => 2}

+    where => {'table2_alias.key3' => 4}

 );

 is_deeply($result->one, 

-          {'table2_alias__key1' => 1, 'table2_alias__key3' => 48});

+          {'table2_alias__key1' => 1, 'table2_alias__key3' => 4});

 $dbi->separator('-');

 $result = $model->select(

     column => [

-        $model->column('table2_alias')

+        $model->column('table2', {alias => 'table2_alias'})

     ],

-    where => {'table2_alias.key3' => 2}

+    where => {'table2_alias.key3' => 4}

 );

 is_deeply($result->one, 

-          {'table2_alias-key1' => 1, 'table2_alias-key3' => 48});

+          {'table2_alias-key1' => 1, 'table2_alias-key3' => 4});

 test 'type() option';

 $dbi = DBIx::Custom->connect(

@@ -2,7 +2,6 @@ package MyModel8::table1;

 use MyModel8 -base;

 has join => sub { ['left join table2 as table2_alias on table1.key1 = table2_alias.key1'] };

-has table_alias => sub { {'table2_alias' => 'table2'} };

 1;