@@ -8,7 +8,7 @@ use base 'Object::Simple';

 use Carp 'croak';

 use DBI;

 use DBIx::Custom::Result;

-use DBIx::Custom::SQL::Template;

+use DBIx::Custom::SQLTemplate;

 use DBIx::Custom::Query;

 use DBIx::Custom::KeyInfo;

@@ -28,9 +28,9 @@ __PACKAGE__->dual_attr([qw/ filters formats/],

                        default => sub { {} }, inherit => 'hash_copy');

 __PACKAGE__->attr(result_class => 'DBIx::Custom::Result');

-__PACKAGE__->attr(sql_tmpl => sub { DBIx::Custom::SQL::Template->new });

+__PACKAGE__->attr(sql_tmpl => sub { DBIx::Custom::SQLTemplate->new });

-sub add_filter {

+sub resist_filter {

     my $invocant = shift;

     # Add filter

@@ -40,7 +40,7 @@ sub add_filter {

     return $invocant;

 }

-sub add_format{

+sub resist_format{

     my $invocant = shift;

     # Add format

@@ -172,9 +172,7 @@ sub create_query {

     my $class = ref $self;

-    my $table = '';

     if (ref $template eq 'ARRAY') {

-        $table    = $template->[0] if $template->[0];

         $template = $template->[1];

     }

@@ -182,7 +180,7 @@ sub create_query {

     my $sql_tmpl = $self->sql_tmpl;

     # Try to get cached query

-    my $cached_query = $class->_query_caches->{"$table$template"};

+    my $cached_query = $class->_query_caches->{"$template"};

     # Create query

     my $query;

@@ -193,11 +191,10 @@ sub create_query {

         );

     }

     else {

-        $sql_tmpl->table($table);

         $query = eval{$sql_tmpl->create_query($template)};

         croak($@) if $@;

-        $class->_add_query_cache("$table$template", $query);

+        $class->_add_query_cache("$template", $query);

     }

     # Connect if not

@@ -209,36 +206,30 @@ sub create_query {

     # Set statement handle

     $query->sth($sth);

-    # Set bind filter

-    $query->query_filter($self->default_query_filter);

-    

-    # Set fetch filter

-    $query->fetch_filter($self->default_fetch_filter);

-    

     return $query;

 }

 sub query{

-    my ($self, $query, $params, $query_edit_cb)  = @_;

+    my ($self, $query, $params, $args)  = @_;

     $params ||= {};

+    # Filter

+    my $filter = $args->{filter} || {};

+    

     # First argument is SQL template

     unless (ref $query eq 'DBIx::Custom::Query') {

-        my $table;

         my $template;

         if (ref $query eq 'ARRAY') {

-            $table    = $query->[0];

-            $template = $query->[1];

+            $template = $query->[0];

         }

         else { $template = $query }

-        $query = $self->create_query([$table, $template]);

-        $query_edit_cb->($query) if ref $query_edit_cb eq 'CODE';

+        $query = $self->create_query($template);

     }

-    

+

     # Create bind value

-    my $bind_values = $self->_build_bind_values($query, $params);

+    my $bind_values = $self->_build_bind_values($query, $params, $filter);

     # Execute

     my $sth      = $query->sth;

@@ -264,9 +255,9 @@ sub query{

         # Create result

         my $result = $result_class->new({

-            _dbi             => $self,

-            sth              => $sth,

-            fetch_filter     => $query->fetch_filter,

+            sth             => $sth,

+            default_filter  => $self->default_fetch_filter,

+            filters         => $self->filters

         });

         return $result;

     }

@@ -274,29 +265,27 @@ sub query{

 }

 sub _build_bind_values {

-    my ($self, $query, $params) = @_;

-    my $key_infos  = $query->key_infos;

-    my $filter     = $query->query_filter;

+    my ($self, $query, $params, $filter) = @_;

+    my $key_infos      = $query->key_infos;

+    my $default_filter = $self->default_query_filter;

+    my $filters        = $self->filters;

     # binding values

     my @bind_values;

     # Build bind values

     foreach my $key_info (@$key_infos) {

-        my $table        = $key_info->table;

-        my $column       = $key_info->column;

-        my $id           = $key_info->id;

-        my $pos          = $key_info->pos;

+        my $column       = $key_info->{column};

+        my $pos          = $key_info->{pos};

         # Value

-        my $value = $id && defined $pos ? $params->{$id}->{$column}->[$pos]

-                  : $id                 ? $params->{$id}->{$column}

-                  : defined $pos        ? $params->{$column}->[$pos]

-                  : $params->{$column};

+        my $value = defined $pos ? $params->{$column}->[$pos] : $params->{$column};

         # Filter

+        $filter = $filters->{$filter} || $filters->{$default_filter};

+        

         push @bind_values, 

-             $filter ? $filter->($value, $table, $column, $self)

+             $filter ? $filter->($value)

                      : $value;

     }

@@ -387,7 +376,7 @@ sub drop_table {

     return $self->do($sql);

 }

-our %VALID_INSERT_ARGS = map { $_ => 1 } qw/append query_edit_cb/;

+our %VALID_INSERT_ARGS = map { $_ => 1 } qw/append filter/;

 sub insert {

     my ($self, $table, $insert_params, $args) = @_;

@@ -408,7 +397,7 @@ sub insert {

     }

     my $append_statement = $args->{append} || '';

-    my $query_edit_cb    = $args->{query_edit_cb};

+    my $filter           = $args->{filter};

     # Insert keys

     my @insert_keys = keys %$insert_params;

@@ -420,24 +409,15 @@ sub insert {

     # Templte for insert

     my $template = "insert into $table {insert " . join(' ', @insert_keys) . '}';

     $template .= " $append_statement" if $append_statement;

-    # Create query

-    my $query = $self->create_query([$table, $template]);

-    

-    # Query edit callback must be code reference

-    croak("Query edit callback must be code reference")

-      if $query_edit_cb && ref $query_edit_cb ne 'CODE';

-    

-    # Query edit if need

-    $query_edit_cb->($query) if $query_edit_cb;

     # Execute query

-    my $ret_val = $self->query($query, $insert_params);

+    my $ret_val = $self->query($template, $insert_params, {filter => $filter});

     return $ret_val;

 }

 our %VALID_UPDATE_ARGS

-  = map { $_ => 1 } qw/where append query_edit_cb allow_update_all/;

+  = map { $_ => 1 } qw/where append filter allow_update_all/;

 sub update {

     my ($self, $table, $update_params, $args) = @_;

@@ -451,7 +431,7 @@ sub update {

     # Arguments

     my $where_params     = $args->{where} || {};

     my $append_statement = $args->{append} || '';

-    my $query_edit_cb    = $args->{query_edit_cb};

+    my $filter           = $args->{filter};

     my $allow_update_all = $args->{allow_update_all};

     # Update keys

@@ -491,21 +471,11 @@ sub update {

     my $template = "update $table $update_clause $where_clause";

     $template .= " $append_statement" if $append_statement;

-    # Create query

-    my $query = $self->create_query([$table, $template]);

-    

-    # Query edit callback must be code reference

-    croak("Query edit callback must be code reference")

-      if $query_edit_cb && ref $query_edit_cb ne 'CODE';

-    

-    # Query edit if need

-    $query_edit_cb->($query) if $query_edit_cb;

-    

     # Rearrange parammeters

     my $params = {%$update_params, '@where' => $where_params};

     # Execute query

-    my $ret_val = $self->query($query, $params);

+    my $ret_val = $self->query($template, $params, {filter => $filter});

     return $ret_val;

 }

@@ -522,7 +492,7 @@ sub update_all {

 }

 our %VALID_DELETE_ARGS

-  = map { $_ => 1 } qw/where append query_edit_cb allow_delete_all/;

+  = map { $_ => 1 } qw/where append filter allow_delete_all/;

 sub delete {

     my ($self, $table, $args) = @_;

@@ -539,7 +509,7 @@ sub delete {

     # Arguments

     my $where_params     = $args->{where} || {};

     my $append_statement = $args->{append};

-    my $query_edit_cb    = $args->{query_edit_cb};

+    my $filter    = $args->{filter};

     my $allow_delete_all = $args->{allow_delete_all};

     # Where keys

@@ -563,18 +533,8 @@ sub delete {

     my $template = "delete from $table $where_clause";

     $template .= " $append_statement" if $append_statement;

-    # Create query

-    my $query = $self->create_query([$table, $template]);

-    

-    # Query edit callback must be code reference

-    croak("Query edit callback must be code reference")

-      if $query_edit_cb && ref $query_edit_cb ne 'CODE';

-    

-    # Query edit if need

-    $query_edit_cb->($query) if $query_edit_cb;

-    

     # Execute query

-    my $ret_val = $self->query($query, $where_params);

+    my $ret_val = $self->query($template, $where_params, {filter => $filter});

     return $ret_val;

 }

@@ -590,22 +550,8 @@ sub delete_all {

     return $self->delete($table, $args);

 }

-sub _select_usage { return << 'EOS' }

-Select usage:

-$dbi->select(

-    $table,                   # String or array ref

-    {

-        columns => $columns   # Array reference

-        where   => $params    # Hash reference.

-        append  => $statement # String. 

-        query_edit_cb => $cb  # Sub reference

-    }

-);

-EOS

-

 our %VALID_SELECT_ARGS

-  = map { $_ => 1 } qw/columns where append query_edit_cb/;

-

+  = map { $_ => 1 } qw/columns where append filter/;

 sub select {

     my ($self, $tables, $args) = @_;

@@ -624,7 +570,7 @@ sub select {

     my $columns          = $args->{columns} || [];

     my $where_params     = $args->{where} || {};

     my $append_statement = $args->{append} || '';

-    my $query_edit_cb    = $args->{query_edit_cb};

+    my $filter    = $args->{filter};

     # SQL template for select statement

     my $template = 'select ';

@@ -684,14 +630,8 @@ sub select {

         $template .= " $append_statement";

     }

-    # Create query

-    my $query = $self->create_query([$tables->[0], $template]);

-    

-    # Query edit

-    $query_edit_cb->($query) if $query_edit_cb;

-    

     # Execute query

-    my $result = $self->query($query, $where_params_new);

+    my $result = $self->query($template, $where_params_new, {filter => $filter});

     return $result;

 }

@@ -822,12 +762,12 @@ DBI options

 =head2 sql_tmpl

-SQL::Template object

+SQLTemplate object

-    $dbi      = $dbi->sql_tmpl(DBIx::Cutom::SQL::Template->new);

+    $dbi      = $dbi->sql_tmpl(DBIx::Cutom::SQLTemplate->new);

     $sql_tmpl = $dbi->sql_tmpl;

-See also L<DBIx::Custom::SQL::Template>.

+See also L<DBIx::Custom::SQLTemplate>.

 =head2 filters

@@ -840,7 +780,7 @@ This method is generally used to get a filter.

     $filter = $dbi->filters->{encode_utf8};

-If you add filter, use add_filter method.

+If you add filter, use resist_filter method.

 =head2 formats

@@ -853,7 +793,7 @@ This method is generally used to get a format.

     $filter = $dbi->formats->{datetime};

-If you add format, use add_format method.

+If you add format, use resist_format method.

 =head2 default_query_filter

@@ -864,7 +804,7 @@ Binding filter

 The following is bind filter sample

-    $dbi->add_filter(encode_utf8 => sub {

+    $dbi->resist_filter(encode_utf8 => sub {

         my $value = shift;

         require Encode 'encode_utf8';

@@ -890,7 +830,7 @@ Fetching filter

 The following is fetch filter sample

-    $dbi->add_filter(decode_utf8 => sub {

+    $dbi->resist_filter(decode_utf8 => sub {

         my $value = shift;

         require Encode 'decode_utf8';

@@ -963,15 +903,15 @@ Check if database is connected.

     $is_connected = $dbi->connected;

-=head2 add_filter

+=head2 resist_filter

 Resist filter

-    $dbi->add_filter($fname1 => $filter1, $fname => $filter2);

+    $dbi->resist_filter($fname1 => $filter1, $fname => $filter2);

-The following is add_filter sample

+The following is resist_filter sample

-    $dbi->add_filter(

+    $dbi->resist_filter(

         encode_utf8 => sub {

             my ($value, $key, $dbi, $infos) = @_;

             utf8::upgrade($value) unless Encode::is_utf8($value);

@@ -983,15 +923,15 @@ The following is add_filter sample

         }

     );

-=head2 add_format

+=head2 resist_format

 Add format

-    $dbi->add_format($fname1 => $format, $fname2 => $format2);

+    $dbi->resist_format($fname1 => $format, $fname2 => $format2);

-The following is add_format sample.

+The following is resist_format sample.

-    $dbi->add_format(date => '%Y:%m:%d', datetime => '%Y-%m-%d %H:%M:%S');

+    $dbi->resist_format(date => '%Y:%m:%d', datetime => '%Y-%m-%d %H:%M:%S');

 =head2 create_query

@@ -1003,7 +943,7 @@ $query is <DBIx::Query> object. This is executed by query method as the followin

     $dbi->query($query, $params);

-If you know SQL template, see also L<DBIx::Custom::SQL::Template>.

+If you know SQL template, see also L<DBIx::Custom::SQLTemplate>.

 =head2 query

@@ -1020,7 +960,7 @@ The following is query sample

         # do something

     }

-If you now syntax of template, See also L<DBIx::Custom::SQL::Template>

+If you now syntax of template, See also L<DBIx::Custom::SQLTemplate>

 Return value of query method is L<DBIx::Custom::Result> object

@@ -7,12 +7,13 @@ use base 'DBIx::Custom';

 use Encode qw/decode encode/;

-__PACKAGE__->add_filter(

+__PACKAGE__->resist_filter(

+    none        => sub { $_[0] },

     encode_utf8 => sub { encode('UTF-8', $_[0]) },

     decode_utf8 => sub { decode('UTF-8', $_[0]) }

 );

-__PACKAGE__->add_format(

+__PACKAGE__->resist_format(

     'SQL99_date'        => '%Y-%m-%d',

     'SQL99_datetime'    => '%Y-%m-%d %H:%M:%S',

     'SQL99_time'        => '%H:%M:%S',

@@ -6,7 +6,7 @@ use strict;

 use base 'DBIx::Custom::Basic';

 use Carp 'croak';

-__PACKAGE__->add_format(

+__PACKAGE__->resist_format(

     datetime => __PACKAGE__->formats->{SQL99_datetime},

     date     => __PACKAGE__->formats->{SQL99_date},

     time     => __PACKAGE__->formats->{SQL99_time},

@@ -5,7 +5,7 @@ use warnings;

 use base 'Object::Simple';

-__PACKAGE__->attr([qw/sql key_infos query_filter fetch_filter sth/]);

+__PACKAGE__->attr([qw/sql key_infos default_filter filter sth/]);

 1;

@@ -21,10 +21,6 @@ DBIx::Custom::Query - DBIx::Custom query

     # Create by using create_query

     my $query = DBIx::Custom->create_query($template);

-    # Attributes

-    $query->query_filter($dbi->filters->{default_query_filter});

-    $query->fetch_filter($dbi->filters->{default_fetch_filter});

-

 =head1 ATTRIBUTES

 =head2 sth

@@ -41,19 +37,19 @@ SQL

     $query = $query->sql($sql);

     $sql   = $query->sql;

-=head2 query_filter

+=head2 default_filter

 Filter excuted when value is bind

-    $query       = $query->query_filter($query_filter);

-    $query_filter = $query->query_filter;

+    $query          = $query->default_filter($default_filter);

+    $default_filter = $query->default_filter;

-=head2 fetch_filter

+=head2 filter

-Filter excuted when data is fetched

+Filter excuted when value is bind

-    $query        = $query->fetch_filter($fetch_filter);

-    $fetch_filter = $query->fetch_filter;

+    $query  = $query->filter($filter);

+    $filter = $query->filter;

 =head2 key_infos

@@ -7,35 +7,42 @@ use base 'Object::Simple';

 use Carp 'croak';

-__PACKAGE__->attr([qw/_dbi sth fetch_filter/]);

+__PACKAGE__->attr([qw/sth filters default_filter filter/]);

 sub fetch {

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

-    my $sth = $self->sth;

-    my $fetch_filter = $self->fetch_filter;

+    

+    my $sth            = $self->sth;

+    my $filters        = $self->filters || {};

+    my $default_filter = $self->default_filter;

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

     # Fetch

     my $row = $sth->fetchrow_arrayref;

     # Cannot fetch

     return unless $row;

+

+    # Key

+    my $columns  = $sth->{NAME_lc};

     # Filter

-    if ($fetch_filter) {

-        my $keys  = $sth->{NAME_lc};

-        my $types = $sth->{TYPE};

-        for (my $i = 0; $i < @$keys; $i++) {

-            $row->[$i]= $fetch_filter->($row->[$i], $keys->[$i], $self->_dbi,

-                                        {type => $types->[$i], sth => $sth, index => $i});

-        }

+    for (my $i = 0; $i < @$columns; $i++) {

+        my $fname  = $filter->{$columns->[$i]} || $filters->{$default_filter};

+        my $filter = $filters->{$fname};

+        $row->[$i] = $filter->($row->[$i]) if $filter;

     }

+

     return wantarray ? @$row : $row;

 }

 sub fetch_hash {

     my $self = shift;

-    my $sth = $self->sth;

-    my $fetch_filter = $self->fetch_filter;

+

+    my $sth            = $self->sth;

+    my $filters        = $self->filters || {};

+    my $default_filter = $self->default_filter;

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

     # Fetch

     my $row = $sth->fetchrow_arrayref;

@@ -44,25 +51,18 @@ sub fetch_hash {

     return unless $row;

     # Keys

-    my $keys  = $sth->{NAME_lc};

+    my $columns  = $sth->{NAME_lc};

     # Filter

     my $row_hash = {};

-    if ($fetch_filter) {

-        my $types = $sth->{TYPE};

-        for (my $i = 0; $i < @$keys; $i++) {

-            $row_hash->{$keys->[$i]}

-              = $fetch_filter->($row->[$i], $keys->[$i], $self->_dbi,

-                                {type => $types->[$i], sth => $sth, index => $i});

-        }

+    for (my $i = 0; $i < @$columns; $i++) {

+        my $fname  = $filter->{$columns->[$i]} || $filters->{$default_filter};

+        my $filter = $filters->{$fname};

+        $row_hash->{$columns->[$i]} = $filter

+                                    ? $filter->($columns->[$i])

+                                    : $columns->[$i];

     }

-    # No filter

-    else {

-        for (my $i = 0; $i < @$keys; $i++) {

-            $row_hash->{$keys->[$i]} = $row->[$i];

-        }

-    }

     return wantarray ? %$row_hash : $row_hash;

 }

@@ -200,12 +200,19 @@ Statement handle

     $result = $result->sth($sth);

     $sth    = $reuslt->sth

-=head2 fetch_filter

+=head2 default_filter

+

+Filter excuted when data is fetched

+

+    $result         = $result->default_filter($sth);

+    $default_filter = $result->default_filter;

+

+=head2 filter

 Filter excuted when data is fetched

-    $result         = $result->fetch_filter($sth);

-    $fetch_filter   = $result->fech_filter;

+    $result   = $result->filter($sth);

+    $filter   = $result->filter;

 =head1 METHODS

@@ -0,0 +1,506 @@

+package DBIx::Custom::SQLTemplate;

+

+use strict;

+use warnings;

+

+use base 'Object::Simple';

+use Carp 'croak';

+use DBIx::Custom::Query;

+

+__PACKAGE__->dual_attr('tag_processors', default => sub { {} },

+                                         inherit => 'hash_copy');

+

+__PACKAGE__->dual_attr('tag_start', default => '{', inherit => 'scalar_copy');

+__PACKAGE__->dual_attr('tag_end',   default => '}', inherit => 'scalar_copy');

+

+__PACKAGE__->dual_attr('tag_syntax', inherit => 'scalar_copy');

+

+__PACKAGE__->add_tag_processor(

+    '?'      => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_basic_tag,

+    '='      => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_basic_tag,

+    '<>'     => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_basic_tag,

+    '>'      => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_basic_tag,

+    '<'      => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_basic_tag,

+    '>='     => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_basic_tag,

+    '<='     => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_basic_tag,

+    'like'   => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_basic_tag,

+    'in'     => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_in_tag,

+    'insert' => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_insert_tag,

+    'update' => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_update_tag

+);

+

+__PACKAGE__->tag_syntax(<< 'EOS');

+[tag]                     [expand]

+{? name}                  ?

+{= name}                  name = ?

+{<> name}                 name <> ?

+

+{< name}                  name < ?

+{> name}                  name > ?

+{>= name}                 name >= ?

+{<= name}                 name <= ?

+

+{like name}               name like ?

+{in name number}          name in [?, ?, ..]

+

+{insert key1 key2} (key1, key2) values (?, ?)

+{update key1 key2}    set key1 = ?, key2 = ?

+EOS

+

+

+sub add_tag_processor {

+    my $invocant = shift;

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

+    $invocant->tag_processors({%{$invocant->tag_processors}, %{$tag_processors}});

+    return $invocant;

+}

+

+sub clone {

+    my $self = shift;

+    my $new = $self->new;

+    

+    $new->tag_start($self->tag_start);

+    $new->tag_end($self->tag_end);

+    $new->tag_syntax($self->tag_syntax);

+    $new->tag_processors({%{$self->tag_processors || {}}});

+    

+    return $new;

+}

+

+sub create_query {

+    my ($self, $template)  = @_;

+    

+    # Parse template

+    my $tree = $self->_parse_template($template);

+    

+    # Build query

+    my $query = $self->_build_query($tree);

+    

+    return $query;

+}

+

+sub _parse_template {

+    my ($self, $template) = @_;

+    

+    if (ref $template eq 'ARRAY') {

+        $template = $template->[1];

+    }

+    $template ||= '';

+    

+    my $tree = [];

+    

+    # Tags

+    my $tag_start = quotemeta $self->tag_start;

+    my $tag_end   = quotemeta $self->tag_end;

+    

+    # Tokenize

+    my $state = 'text';

+    

+    # Save original template

+    my $original_template = $template;

+    

+    # Parse template

+    while ($template =~ s/([^$tag_start]*?)$tag_start([^$tag_end].*?)$tag_end//sm) {

+        my $text = $1;

+        my $tag  = $2;

+        

+        # Parse tree

+        push @$tree, {type => 'text', tag_args => [$text]} if $text;

+        

+        if ($tag) {

+            # Get tag name and arguments

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

+            

+            # Tag processor is exist?

+            unless ($self->tag_processors->{$tag_name}) {

+                my $tag_syntax = $self->tag_syntax;

+                croak("Tag '{$tag}' in SQL template is not exist.\n\n" .

+                      "<SQL template tag syntax>\n" .

+                      "$tag_syntax\n" .

+                      "<Your SQL template>\n" .

+                      "$original_template\n\n");

+            }

+            

+            # Check tag arguments

+            foreach my $tag_arg (@tag_args) {

+                # Cannot cantain placehosder '?'

+                croak("Tag '{t }' arguments cannot contain '?'")

+                  if $tag_arg =~ /\?/;

+            }

+            

+            # Add tag to parsing tree

+            push @$tree, {type => 'tag', tag_name => $tag_name, tag_args => [@tag_args]};

+        }

+    }

+    

+    # Add text to parsing tree 

+    push @$tree, {type => 'text', tag_args => [$template]} if $template;

+    

+    return $tree;

+}

+

+sub _build_query {

+    my ($self, $tree) = @_;

+    

+    # SQL

+    my $sql = '';

+    

+    # All parameter key infomation

+    my $all_key_infos = [];

+    

+    # Build SQL 

+    foreach my $node (@$tree) {

+        

+        # Get type, tag name, and arguments

+        my $type     = $node->{type};

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

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

+        

+        # Text

+        if ($type eq 'text') {

+            # Join text

+            $sql .= $tag_args->[0];

+        }

+        

+        # Tag

+        elsif ($type eq 'tag') {

+            

+            # Get tag processor

+            my $tag_processor = $self->tag_processors->{$tag_name};

+            

+            # Tag processor is code ref?

+            croak("Tag processor '$tag_name' must be code reference")

+              unless ref $tag_processor eq 'CODE';

+            

+            # Expand tag using tag processor

+            my ($expand, $key_infos)

+              = $tag_processor->($tag_name, $tag_args);

+            

+            # Check tag processor return value

+            croak("Tag processor '$tag_name' must return (\$expand, \$key_infos)")

+              if !defined $expand || ref $key_infos ne 'ARRAY';

+            

+            # Check placeholder count

+            croak("Placeholder count in SQL created by tag processor '$tag_name' " .

+                  "must be same as key informations count")

+              unless $self->_placeholder_count($expand) eq @$key_infos;

+            

+            # Add key information

+            push @$all_key_infos, @$key_infos;

+            

+            # Join expand tag to SQL

+            $sql .= $expand;

+        }

+    }

+    

+    # Add semicolon

+    $sql .= ';' unless $sql =~ /;$/;

+    

+    # Query

+    my $query = DBIx::Custom::Query->new(sql => $sql, key_infos => $all_key_infos);

+    

+    return $query;

+}

+

+sub _placeholder_count {

+    my ($self, $expand) = @_;

+    $expand ||= '';

+    

+    my $count = 0;

+    my $pos   = -1;

+    while (($pos = index($expand, '?', $pos + 1)) != -1) {

+        $count++;

+    }

+    return $count;

+}

+

+1;

+

+package DBIx::Custom::SQLTemplate::TagProcessors;

+

+use strict;

+use warnings;

+

+use Carp 'croak';

+use DBIx::Custom::KeyInfo;

+

+sub expand_basic_tag {

+    my ($tag_name, $tag_args) = @_;

+    

+    # Key

+    my $column = $tag_args->[0];

+    

+    # Key is not exist

+    croak("You must be pass key as argument to tag '{$tag_name }'")

+      unless $column;

+

+    # Expanded tag

+    my $expand = $tag_name eq '?'

+               ? '?'

+               : "$column $tag_name ?";

+

+    return ($expand, [{column => $column}]);

+}

+

+sub expand_in_tag {

+    my ($tag_name, $tag_args) = @_;

+    my ($column, $placeholder_count) = @$tag_args;

+    

+    # Key must be specified

+    croak("You must be pass key as first argument of tag '{$tag_name }'\n" . 

+          "Usage: {$tag_name \$key \$placeholder_count}")

+      unless $column;

+    

+    # Place holder count must be specified

+    croak("You must be pass placeholder count as second argument of tag '{$tag_name }'\n" . 

+          "Usage: {$tag_name \$key \$placeholder_count}")

+      if !$placeholder_count || $placeholder_count =~ /\D/;

+

+    # Expand tag

+    my $expand = "$column $tag_name (";

+    for (my $i = 0; $i < $placeholder_count; $i++) {

+        $expand .= '?, ';

+    }

+    

+    $expand =~ s/, $//;

+    $expand .= ')';

+    

+    # Create parameter key infomations

+    my $key_infos = [];

+    for (my $i = 0; $i < $placeholder_count; $i++) {

+        

+        # Add parameter key infos

+        push @$key_infos, {column => $column, pos => $i};

+    }

+    

+    return ($expand, $key_infos);

+}

+

+sub expand_insert_tag {

+    my ($tag_name, $columns) = @_;

+    

+    # Insert key (k1, k2, k3, ..)

+    my $insert_keys = '(';

+    

+    # placeholder (?, ?, ?, ..)

+    my $place_holders = '(';

+    

+    foreach my $column (@$columns) {

+        

+        # Join insert column

+        $insert_keys   .= "$column, ";

+        

+        # Join place holder

+        $place_holders .= "?, ";

+    }

+    

+    # Delete last ', '

+    $insert_keys =~ s/, $//;

+    

+    # Close 

+    $insert_keys .= ')';

+    $place_holders =~ s/, $//;

+    $place_holders .= ')';

+    

+    # Expand tag

+    my $expand = "$insert_keys values $place_holders";

+    

+    # Create parameter key infomations

+    my $key_infos = [];

+    foreach my $column (@$columns) {

+        push @$key_infos, {column => $column};

+    }

+    

+    return ($expand, $key_infos);

+}

+

+sub expand_update_tag {

+    my ($tag_name, $columns) = @_;

+    

+    # Expanded tag

+    my $expand = 'set ';

+    

+    foreach my $column (@$columns) {

+

+        # Join key and placeholder

+        $expand .= "$column = ?, ";

+    }

+    

+    # Delete last ', '

+    $expand =~ s/, $//;

+    

+    my $key_infos = [];

+    foreach my $column (@$columns) {

+        push @$key_infos, {column => $column};

+    }

+    

+    return ($expand, $key_infos);

+}

+

+package DBIx::Custom::SQLTemplate;

+

+1;

+

+=head1 NAME

+

+DBIx::Custom::SQLTemplate - DBIx::Custom SQL Template

+

+=head1 SYNOPSIS

+    

+    my $sql_tmpl = DBIx::Custom::SQLTemplate->new;

+    

+    my $tmpl   = "select from table {= k1} && {<> k2} || {like k3}";

+    my $param = {k1 => 1, k2 => 2, k3 => 3};

+    

+    my $query = $sql_template->create_query($tmpl);

+

+=head1 ATTRIBUTES

+

+=head2 tag_processors

+

+    $sql_tmpl       = $sql_tmpl->tag_processors($name1 => $tag_processor1

+                                                $name2 => $tag_processor2);

+    $tag_processors = $sql_tmpl->tag_processors;

+

+=head2 tag_start

+    

+    $sql_tmpl  = $sql_tmpl->tag_start('{');

+    $tag_start = $sql_tmpl->tag_start;

+

+Default is '{'

+

+=head2 tag_end

+    

+    $sql_tmpl    = $sql_tmpl->tag_start('}');

+    $tag_end = $sql_tmpl->tag_start;

+

+Default is '}'

+    

+=head2 tag_syntax

+    

+    $sql_tmpl   = $sql_tmpl->tag_syntax($tag_syntax);

+    $tag_syntax = $sql_tmpl->tag_syntax;

+

+=head1 METHODS

+

+This class is L<Object::Simple> subclass.

+You can use all methods of L<Object::Simple>

+

+=head2 create_query

+    

+Create L<DBIx::Custom::Query> object parsing SQL template

+

+    $query = $sql_tmpl->create_query($tmpl);

+    

+    # Sample

+    $query = $sql_tmpl->create_sql(

+         "select * from table where {= title} && {like author} || {<= price}")

+    

+    # Expanded

+    $qeury->sql : "select * from table where title = ? && author like ? price <= ?;"

+    $query->key_infos : [['title'], ['author'], ['price']]

+    

+    # Sample with table name

+    ($sql, @bind_values) = $sql_tmpl->create_sql(

+            "select * from table where {= table.title} && {like table.author}",

+            {table => {title => 'Perl', author => '%Taro%'}}

+        )

+    

+    # Expanded

+    $query->sql : "select * from table where table.title = ? && table.title like ?;"

+    $query->key_infos :[ [['table.title'],['table', 'title']],

+                         [['table.author'],['table', 'author']] ]

+

+This method create query using by L<DBIx::Custom>.

+query has two infomation

+

+    1. sql       : SQL

+    2. key_infos : Parameter access key information

+

+=head2 add_tag_processor

+

+Add tag processor

+    

+    $sql_tmpl = $sql_tmpl->add_tag_processor($tag_processor);

+

+The following is add_tag_processor sample

+

+    $sql_tmpl->add_tag_processor(

+        '?' => sub {

+            my ($tag_name, $tag_args) = @_;

+            

+            my $key1 = $tag_args->[0];

+            my $key2 = $tag_args->[1];

+            

+            my $key_infos = [];

+            

+            # Expand tag and create key informations

+            

+            # Return expand tags and key informations

+            return ($expand, $key_infos);

+        }

+    );

+

+Tag processor recieve 2 argument

+

+    1. Tag name            (?, =, <>, or etc)

+    2. Tag arguments       (arg1 and arg2 in {tag_name arg1 arg2})

+

+Tag processor return 2 value

+

+    1. Expanded Tag (For exsample, '{= title}' is expanded to 'title = ?')

+    2. Key infomations

+    

+You must be return expanded tag and key infomations.

+

+Key information is a little complex. so I will explan this in future.

+

+If you want to know more, Please see DBIx::Custom::SQLTemplate source code.

+

+=head2 clone

+

+Clone DBIx::Custom::SQLTemplate object

+

+    $clone = $sql_tmpl->clone;

+    

+=head1 Available Tags

+    

+Available Tags

+

+    [tag]            [expand]

+    {? name}         ?

+    {= name}         name = ?

+    {<> name}        name <> ?

+    

+    {< name}         name < ?

+    {> name}         name > ?

+    {>= name}        name >= ?

+    {<= name}        name <= ?

+    

+    {like name}      name like ?

+    {in name}        name in [?, ?, ..]

+    

+    {insert}         (key1, key2, key3) values (?, ?, ?)

+    {update}         set key1 = ?, key2 = ?, key3 = ?

+    

+

+The following is insert SQL sample

+

+    $query = $sql_tmpl->create_sql(

+        "insert into table {insert key1 key2}"

+    );

+    

+    # Expanded

+    $query->sql : "insert into table (key1, key2) values (?, ?)"

+

+The following is update SQL sample

+    

+    $query = $sql_tmpl->create_sql(

+        "update table {update key1 key2} where {= key3}"

+    );

+    

+    # Expanded

+    $query->sql : "update table set key1 = ?, key2 = ? where key3 = ?;"

+    

+=cut

+

@@ -7,7 +7,7 @@ use base 'DBIx::Custom::Basic';

 use Carp 'croak';

 # Add format

-__PACKAGE__->add_format(

+__PACKAGE__->resist_format(

     datetime => __PACKAGE__->formats->{SQL99_datetime},

     date     => __PACKAGE__->formats->{SQL99_date},

     time     => __PACKAGE__->formats->{SQL99_time},

@@ -260,7 +260,7 @@ $rows = $result->fetch_hash_all;

 is_deeply($rows, [{key1 => 2, key2 => 4}], "$test : query_filter");

-test 'DBIx::Custom::SQL::Template basic tag';

+test 'DBIx::Custom::SQLTemplate basic tag';

 $dbi->do($DROP_TABLE->{0});

 $dbi->do($CREATE_TABLE->{1});

 $sth = $dbi->prepare("insert into table1 (key1, key2, key3, key4, key5) values (?, ?, ?, ?, ?);");

@@ -304,7 +304,7 @@ $rows = $result->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "$test : basic tag2 with table dot");

-test 'DIB::Custom::SQL::Template in tag';

+test 'DIB::Custom::SQLTemplate in tag';

 $dbi->do($DROP_TABLE->{0});

 $dbi->do($CREATE_TABLE->{1});

 $sth = $dbi->prepare("insert into table1 (key1, key2, key3, key4, key5) values (?, ?, ?, ?, ?);");

@@ -330,7 +330,7 @@ $rows = $result->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "$test : with table dot");

-test 'DBIx::Custom::SQL::Template insert tag';

+test 'DBIx::Custom::SQLTemplate insert tag';

 $dbi->do("delete from table1");

 $insert_tmpl = 'insert into table1 {insert key1 key2 key3 key4 key5}';

 $dbi->query($insert_tmpl, {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});

@@ -346,7 +346,7 @@ $result = $dbi->query($SELECT_TMPLS->{0});

 $rows = $result->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "$test : with table name");

-test 'DBIx::Custom::SQL::Template update tag';

+test 'DBIx::Custom::SQLTemplate update tag';

 $dbi->do("delete from table1");

 $insert_tmpl = "insert into table1 {insert key1 key2 key3 key4 key5}";

 $dbi->query($insert_tmpl, {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});

@@ -0,0 +1,15 @@

+#!perl -T

+

+use Test::More tests => 7;

+

+BEGIN {

+	use_ok( 'DBIx::Custom' );

+	use_ok( 'DBIx::Custom::Basic' );

+	use_ok( 'DBIx::Custom::MySQL' );

+	use_ok( 'DBIx::Custom::Query' );

+	use_ok( 'DBIx::Custom::Result' );

+	use_ok( 'DBIx::Custom::SQLTemplate' );

+	use_ok( 'DBIx::Custom::SQLite' );

+}

+

+diag( "Testing DBIx::Custom $DBIx::Custom::VERSION, Perl $], $^X" );

@@ -0,0 +1,51 @@

+#!perl -T

+

+use strict;

+use warnings;

+use Test::More tests => 3;

+

+sub not_in_file_ok {

+    my ($filename, %regex) = @_;

+    open( my $fh, '<', $filename )

+        or die "couldn't open $filename for reading: $!";

+

+    my %violated;

+

+    while (my $line = <$fh>) {

+        while (my ($desc, $regex) = each %regex) {

+            if ($line =~ $regex) {

+                push @{$violated{$desc}||=[]}, $.;

+            }

+        }

+    }

+

+    if (%violated) {

+        fail("$filename contains boilerplate text");

+        diag "$_ appears on lines @{$violated{$_}}" for keys %violated;

+    } else {

+        pass("$filename contains no boilerplate text");

+    }

+}

+

+sub module_boilerplate_ok {

+    my ($module) = @_;

+    not_in_file_ok($module =>

+        'the great new $MODULENAME'   => qr/ - The great new /,

+        'boilerplate description'     => qr/Quick summary of what the module/,

+        'stub function definition'    => qr/function[12]/,

+    );

+}

+

+

+  not_in_file_ok(README =>

+    "The README is used..."       => qr/The README is used/,

+    "'version information here'"  => qr/to provide version information/,

+  );

+

+  not_in_file_ok(Changes =>

+    "placeholder date/time"       => qr(Date/time)

+  );

+

+  module_boilerplate_ok('lib/DBIx/Custom.pm');

+

+

@@ -0,0 +1,55 @@

+use Test::More;

+use strict;

+use warnings;

+use utf8;

+use Encode qw/decode encode/;

+

+BEGIN {

+    eval { require DBD::SQLite; 1 }

+        or plan skip_all => 'DBD::SQLite required';

+    eval { DBD::SQLite->VERSION >= 1 }

+        or plan skip_all => 'DBD::SQLite >= 1.00 required';

+

+    plan 'no_plan';

+    use_ok('DBIx::Custom');

+}

+

+# Function for test name

+my $test;

+sub test {

+    $test = shift;

+}

+

+# Constant varialbes for test

+my $CREATE_TABLE = {

+    0 => 'create table table1 (key1 char(255), key2 char(255));',

+    1 => 'create table table1 (key1 char(255), key2 char(255), key3 char(255), key4 char(255), key5 char(255));',

+    2 => 'create table table2 (key1 char(255), key3 char(255));'

+};

+

+my $SELECT_TMPL = {

+    0 => 'select * from table1;'

+};

+

+my $DROP_TABLE = {

+    0 => 'drop table table1'

+};

+

+my $NEW_ARGS = {

+    0 => {data_source => 'dbi:SQLite:dbname=:memory:'}

+};

+

+# Variables for test

+my $dbi;

+my $decoded_str;

+my $encoded_str;

+my $array;

+my $ret_val;

+

+use DBIx::Custom::Basic;

+

+test 'Filter';

+$dbi = DBIx::Custom::Basic->new($NEW_ARGS->{0});

+ok($dbi->filters->{encode_utf8}, "$test : exists default_bind_filter");

+ok($dbi->filters->{decode_utf8}, "$test : exists default_fetch_filter");

+

@@ -0,0 +1,67 @@

+use Test::More;

+use strict;

+use warnings;

+

+BEGIN {

+    eval { require Time::Piece; 1 }

+        or plan skip_all => 'Time::Piece required';

+    

+    eval { Time::Piece->VERSION >= 1.15 }

+        or plan skip_all => 'Time::Piece >= 1.15 requred';

+        

+    plan 'no_plan';

+    use_ok('DBIx::Custom');

+}

+

+# Function for test name

+my $test;

+sub test {

+    $test = shift;

+}

+

+# Varialbe for tests

+

+my $format;

+my $data;

+my $timepiece;

+my $dbi;

+

+use DBIx::Custom::Basic;

+

+

+test 'SQL99 format';

+$dbi = DBIx::Custom::Basic->new;

+$data   = '2009-01-02 03:04:05';

+$format = $dbi->formats->{'SQL99_datetime'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : datetime date");

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : datetime time");

+

+$data   = '2009-01-02';

+$format = $dbi->formats->{'SQL99_date'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : date");

+

+$data   = '03:04:05';

+$format = $dbi->formats->{'SQL99_time'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : time");

+

+

+test 'ISO-8601 format';

+$data   = '2009-01-02T03:04:05';

+$format = $dbi->formats->{'ISO-8601_datetime'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : datetime date");

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : datetime time");

+

+$data   = '2009-01-02';

+$format = $dbi->formats->{'ISO-8601_date'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : date");

+

+$data   = '03:04:05';

+$format = $dbi->formats->{'ISO-8601_time'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : time");

+

@@ -0,0 +1,36 @@

+use Test::More;

+use strict;

+use warnings;

+

+# user password database

+our ($USER, $PASSWORD, $DATABASE) = connect_info();

+

+plan skip_all => 'private MySQL test' unless $USER;

+

+plan 'no_plan';

+

+use DBIx::Custom;

+use Scalar::Util 'blessed';

+{

+    my $dbi = DBIx::Custom->new(

+        user => $USER,

+        password => $PASSWORD,

+        data_source => "dbi:mysql:dbname=$DATABASE"

+    );

+    $dbi->connect;

+    

+    ok(blessed $dbi->dbh);

+    can_ok($dbi->dbh, qw/prepare/);

+}

+

+sub connect_info {

+    my $file = 'password.tmp';

+    open my $fh, '<', $file

+      or return;

+    

+    my ($user, $password, $database) = split(/\s/, (<$fh>)[0]);

+    

+    close $fh;

+    

+    return ($user, $password, $database);

+}

@@ -0,0 +1,127 @@

+use Test::More 'no_plan';

+use strict;

+use warnings;

+

+use DBIx::Custom;

+use DBIx::Custom::SQLTemplate;

+

+# Function for test name

+my $test;

+sub test {

+    $test = shift;

+}

+

+# Variables for test

+our $SQL_TMPL = {

+    0 => DBIx::Custom::SQLTemplate->new->tag_start(0),

+    1 => DBIx::Custom::SQLTemplate->new->tag_start(1),

+    2 => DBIx::Custom::SQLTemplate->new->tag_start(2)

+};

+my $dbi;

+

+

+test 'Constructor';

+$dbi = DBIx::Custom->new(

+    user => 'a',

+    database => 'a',

+    password => 'b',

+    data_source => 'c',

+    options => {d => 1, e => 2},

+    filters => {

+        f => 3,

+    },

+    default_bind_filter => 'f',

+    default_fetch_filter => 'g',

+    result_class => 'g',

+    sql_tmpl => $SQL_TMPL->{0},

+);

+is_deeply($dbi,{user => 'a', database => 'a', password => 'b', data_source => 'c', 

+                options => {d => 1, e => 2}, filters => {f => 3}, default_bind_filter => 'f',

+                default_fetch_filter => 'g', result_class => 'g',

+                sql_tmpl => $SQL_TMPL->{0}}, $test);

+isa_ok($dbi, 'DBIx::Custom');

+

+

+test 'Sub class constructor';

+{

+    package DBIx::Custom::T1;

+    use base 'DBIx::Custom';

+    

+    __PACKAGE__

+      ->filters({f => 3})

+      ->formats({f => 3})

+    ;

+}

+$dbi = DBIx::Custom::T1->new(

+    filters => {

+        fo => 30,

+    },

+    formats => {

+        fo => 30,

+    },

+);

+is_deeply(scalar $dbi->filters, {fo => 30}, "$test : filters");

+is_deeply(scalar $dbi->formats, {fo => 30}, "$test : formats");

+

+test 'Sub class constructor default';

+$dbi = DBIx::Custom::T1->new;