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

 0.1604

+  renamed default_query_filter to default_bind_filter(not backword compatible)

+  renamed DBIx::Custom::SQLTemplate to DBIx::Custom::SQLBuilder(not backword compatible)

+  renamed create_query to build_query(not backword compatible)

+  renamed sql_template to sql_builder(not backword compatible)

   removed DESTROY method(not backword compatible)

   removed disconnect method(not backword compatible)

   fixed DBIx::Custom::MySQL connect_memory

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

 use Carp 'croak';

 use DBI;

 use DBIx::Custom::Result;

-use DBIx::Custom::SQLTemplate;

+use DBIx::Custom::QueryBuilder;

 use DBIx::Custom::Query;

 use Encode qw/encode_utf8 decode_utf8/;

 __PACKAGE__->attr('dbh');

 __PACKAGE__->attr([qw/user password data_source/]);

-__PACKAGE__->attr([qw/default_query_filter default_fetch_filter/]);

+__PACKAGE__->attr([qw/default_bind_filter default_fetch_filter/]);

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

                                   inherit => 'hash_copy');

@@ -24,7 +24,7 @@ __PACKAGE__->register_filter(

 );

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

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

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

 __PACKAGE__->attr(cache => 1);

 __PACKAGE__->attr(cache_method => sub {

@@ -109,12 +109,12 @@ sub insert {

       unless @insert_keys;

     # Templte for insert

-    my $template = "insert into $table {insert "

+    my $source = "insert into $table {insert "

                    . join(' ', @insert_keys) . '}';

-    $template .= " $append" if $append;

+    $source .= " $append" if $append;

     # Execute query

-    my $ret_val = $self->execute($template, param  => $param, 

+    my $ret_val = $self->execute($source, param  => $param, 

                                             filter => $filter);

     return $ret_val;

@@ -171,8 +171,8 @@ sub update {

     }

     # Template for update

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

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

+    my $source = "update $table $update_clause $where_clause";

+    $source .= " $append_statement" if $append_statement;

     # Rearrange parammeters

     foreach my $wkey (@where_keys) {

@@ -189,7 +189,7 @@ sub update {

     }

     # Execute query

-    my $ret_val = $self->execute($template, param  => $param, 

+    my $ret_val = $self->execute($source, param  => $param, 

                                             filter => $filter);

     return $ret_val;

@@ -234,11 +234,11 @@ sub delete {

     }

     # Template for delete

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

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

+    my $source = "delete from $table $where_clause";

+    $source .= " $append_statement" if $append_statement;

     # Execute query

-    my $ret_val = $self->execute($template, param  => $where, 

+    my $ret_val = $self->execute($source, param  => $where, 

                                             filter => $filter);

     return $ret_val;

@@ -269,82 +269,83 @@ sub select {

     my $param    = $args{param} || {};

     # SQL template for select statement

-    my $template = 'select ';

+    my $source = 'select ';

     # Column clause

     if (@$columns) {

         foreach my $column (@$columns) {

-            $template .= "$column, ";

+            $source .= "$column, ";

         }

-        $template =~ s/, $/ /;

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

     }

     else {

-        $template .= '* ';

+        $source .= '* ';

     }

     # Table

-    $template .= 'from ';

+    $source .= 'from ';

     foreach my $table (@$tables) {

-        $template .= "$table, ";

+        $source .= "$table, ";

     }

-    $template =~ s/, $/ /;

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

     # Where clause

     my @where_keys = keys %$where;

     if (@where_keys) {

-        $template .= 'where ';

+        $source .= 'where ';

         foreach my $where_key (@where_keys) {

-            $template .= "{= $where_key} and ";

+            $source .= "{= $where_key} and ";

         }

     }

-    $template =~ s/ and $//;

+    $source =~ s/ and $//;

     # Relation

     if ($relation) {

-        $template .= @where_keys ? "and " : "where ";

+        $source .= @where_keys ? "and " : "where ";

         foreach my $rkey (keys %$relation) {

-            $template .= "$rkey = " . $relation->{$rkey} . " and ";

+            $source .= "$rkey = " . $relation->{$rkey} . " and ";

         }

     }

-    $template =~ s/ and $//;

+    $source =~ s/ and $//;

     # Append some statement

-    $template .= " $append" if $append;

+    $source .= " $append" if $append;

     # Execute query

-    my $result = $self->execute($template, param  => $where, 

+    my $result = $self->execute($source, param  => $where, 

                                            filter => $filter);

     return $result;

 }

-sub create_query {

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

-    

-    # Create query from SQL template

-    my $sql_template = $self->sql_template;

+sub build_query {

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

+    # Cache

     my $cache = $self->cache;

     # Create query

     my $query;

     if ($cache) {

-        # Cached query

-        my $q = $self->cache_method->($self, $template);

+        # Get query

+        my $q = $self->cache_method->($self, $source);

         # Create query

         $query = DBIx::Custom::Query->new($q) if $q;

     }

     unless ($query) {

+

+        # Create SQL object

+        my $builder = $self->sql_builder;

         # Create query

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

+        $query = eval{$builder->build_query($source)};

         croak($@) if $@;

         # Cache query

-        $self->cache_method->($self, $template,

+        $self->cache_method->($self, $source,

                              {sql     => $query->sql, 

                               columns => $query->columns})

           if $cache;

@@ -375,14 +376,14 @@ sub execute{

     # First argument is SQL template

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

-        my $template;

+        my $source;

         if (ref $query eq 'ARRAY') {

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

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

         }

-        else { $template = $query }

+        else { $source = $query }

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

+        $query = $self->build_query($source);

     }

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

@@ -398,15 +399,13 @@ sub execute{

     # Return resultset if select statement is executed

     if ($sth->{NUM_OF_FIELDS}) {

-        # Get result class

-        my $result_class = $self->result_class;

-        

         # Create result

-        my $result = $result_class->new({

-            sth             => $sth,

-            default_filter  => $self->default_fetch_filter,

-            filters         => $self->filters

-        });

+        my $result = $self->result_class->new(

+            sth            => $sth,

+            default_filter => $self->default_fetch_filter,

+            filters        => $self->filters

+        );

+

         return $result;

     }

     return $affected;

@@ -434,7 +433,7 @@ sub _build_bind_values {

         $filter ||= {};

         # Filter name

-        my $fname = $filter->{$column} || $self->default_query_filter || '';

+        my $fname = $filter->{$column} || $self->default_bind_filter || '';

         my $filter_func;

         if ($fname) {

@@ -530,13 +529,13 @@ This module is not stable. Method name and implementations will be changed.

                   filter => {tilte => 'encode_utf8'});

     # Create query and execute it

-    my $query = $dbi->create_query(

+    my $query = $dbi->build_query(

         "select id from books where {= author} && {like title}"

     );

     $dbi->execute($query, param => {author => 'ken', title => '%Perl%'})

     # Default filter

-    $dbi->default_query_filter('encode_utf8');

+    $dbi->default_bind_filter('encode_utf8');

     $dbi->default_fetch_filter('decode_utf8');

     # Fetch

@@ -635,10 +634,10 @@ By default, "encode_utf8" and "decode_utf8" is registered.

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

     $decode_utf8 = $dbi->filters->{decode_utf8};

-=head2 C<default_query_filter>

+=head2 C<default_bind_filter>

-    $dbi                  = $dbi->default_query_filter('encode_utf8');

-    $default_query_filter = $dbi->default_query_filter

+    $dbi                 = $dbi->default_bind_filter('encode_utf8');

+    $default_bind_filter = $dbi->default_bind_filter

 Default filter for value binding

@@ -655,16 +654,16 @@ Default filter for fetching.

     $result_class = $dbi->result_class;

 Result class for select statement.

-Default to L<DBIx::Custom::Result>

+Default to L<DBIx::Custom::Result>.

-=head2 C<sql_template>

+=head2 C<sql_builder>

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

-    $sql_template = $dbi->sql_template;

+    $dbi       = $dbi->sql_builder('DBIx::Cutom::QueryBuilder);

+    $sql_class = $dbi->sql_builder;

-SQLTemplate instance. sql_template attribute must be 

-the instance of L<DBIx::Cutom::SQLTemplate> subclass.

-Default to DBIx::Cutom::SQLTemplate object

+SQL builder. sql_builder_class must be 

+the instance of L<DBIx::Cutom::QueryBuilder> subclass

+Default to DBIx::Custom::QueryBuilder.

 =head1 METHODS

@@ -796,19 +795,19 @@ B<Example:>

         relation => {'books.id' => 'rental.book_id'}

     );

-=head2 C<create_query>

+=head2 C<build_query>

-    my $query = $dbi->create_query(

+    my $query = $dbi->build_query(

         "select * from authors where {= name} and {= age};"

     );

-Create the instance of L<DBIx::Custom::Query>. 

-This receive the string written by SQL template.

+Build the instance of L<DBIx::Custom::Query>

+using L<DBIx::Custom::QueryBuilder>.

 =head2 C<execute>

     $result = $dbi->execute($query,    param => $params, filter => {%filter});

-    $result = $dbi->execute($template, param => $params, filter => {%filter});

+    $result = $dbi->execute($source, param => $params, filter => {%filter});

 Execute the instace of L<DBIx::Custom::Query> or

 the string written by SQL template.

@@ -823,8 +822,6 @@ B<Example:>

         # do something

     }

-See also L<DBIx::Custom::SQLTemplate> to know how to write SQL template.

-

 =head2 C<register_filter>

     $dbi->register_filter(%filters);

@@ -0,0 +1,314 @@

+package DBIx::Custom::QueryBuilder;

+

+use strict;

+use warnings;

+

+use base 'Object::Simple';

+

+use Carp 'croak';

+use DBIx::Custom::Query;

+use DBIx::Custom::QueryBuilder::TagProcessor;

+

+__PACKAGE__->dual_attr('tag_processors', default => sub { {} }, inherit => 'hash_copy');

+__PACKAGE__->register_tag_processor(

+    '?'      => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_placeholder_tag,

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

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

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

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

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

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

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

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

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

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

+);

+

+__PACKAGE__->attr(tag_start => '{');

+__PACKAGE__->attr(tag_end   => '}');

+

+__PACKAGE__->attr('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 register_tag_processor {

+    my $self = shift;

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

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

+    return $self;

+}

+

+sub build_query {

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

+    

+    # Parse

+    my $tree = $self->_parse($source);

+    

+    # Build query

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

+    

+    return $query;

+}

+

+sub _parse {

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

+    

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

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

+    }

+    $source ||= '';

+    

+    my $tree = [];

+    

+    # Tags

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

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

+    

+    # Tokenize

+    my $state = 'text';

+    

+    # Save original

+    my $original = $source;

+    

+    # Parse

+    while ($source =~ 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}' is not registerd.\n\n" .

+                      "<SQL builder syntax>\n" .

+                      "$tag_syntax\n" .

+                      "<Your source>\n" .

+                      "$original\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 => [$source]} if $source;

+    

+    return $tree;

+}

+

+sub _build_query {

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

+    

+    # SQL

+    my $sql = '';

+    

+    # All parameter key infomation

+    my $all_columns = [];

+    

+    # 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, $columns) = $tag_processor->($tag_name, $tag_args);

+            

+            # Check tag processor return value

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

+              if !defined $expand || ref $columns 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 @$columns;

+            

+            # Add key information

+            push @$all_columns, @$columns;

+            

+            # Join expand tag to SQL

+            $sql .= $expand;

+        }

+    }

+    

+    # Add semicolon

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

+    

+    # Query

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

+    

+    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;

+

+=head1 NAME

+

+DBIx::Custom::QueryBuilder - Query builder

+

+=head1 SYNOPSIS

+    

+    my $builder = DBIx::Custom::QueryBuilder->new;

+    

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

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

+    

+    my $query = $sql_builder->build_query($source);

+

+=head1 ATTRIBUTES

+

+=head2 C<tag_processors>

+

+    my $tag_processors = $builder->tag_processors;

+    $builder           = $builder->tag_processors(\%tag_processors);

+

+Tag processors.

+

+=head2 C<tag_start>

+    

+    my $tag_start = $builder->tag_start;

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

+

+String of tag start.

+Default to '{'

+

+=head2 C<tag_end>

+    

+    my $tag_end = $builder->tag_start;

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

+

+String of tag end.

+Default to '}'

+    

+=head2 C<tag_syntax>

+    

+    my $tag_syntax = $builder->tag_syntax;

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

+

+Tag syntax.

+

+=head1 METHODS

+

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

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

+

+=head2 C<new>

+

+    my $builder = DBIx::Custom::SQLBuilder->new;

+    my $builder = DBIx::Custom::SQLBuilder->new(%attrs);

+    my $builder = DBIx::Custom::SQLBuilder->new(\%attrs);

+

+Create a instance.

+

+=head2 C<build_query>

+    

+    my $query = $builder->build_query($source);

+

+Build L<DBIx::Custom::Query> object.

+

+B<Example:>

+

+Source:

+

+    my $query = $builder->build_query(

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

+

+Query:

+

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

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

+

+=head2 C<register_tag_processor>

+

+    $builder = $builder->register_tag_processor($tag_processor);

+

+Register tag processor.

+

+    $builder->register_tag_processor(

+        '?' => sub {

+            my $args = shift;

+            

+            # Do something

+            

+            # Expanded tag and column names

+            return ($expand, $columns);

+        }

+    );

+

+Tag processor receive arguments in tags

+and must return expanded tag and column names.

+

+=head1 Tags

+

+    {? NAME}    ->   ?

+    {= NAME}    ->   NAME = ?

+    {<> NAME}   ->   NAME <> ?

+    

+    {< NAME}    ->   NAME < ?

+    {> NAME}    ->   NAME > ?

+    {>= NAME}   ->   NAME >= ?

+    {<= NAME}   ->   NAME <= ?

+    

+    {like NAME}       ->   NAME like ?

+    {in NAME COUNT}   ->   NAME in [?, ?, ..]

+    

+    {insert NAME1 NAME2 NAME3}   ->   (NAME1, NAME2, NAME3) values (?, ?, ?)

+    {update NAME1 NAME2 NAME3}   ->   set NAME1 = ?, NAME2 = ?, NAME3 = ?

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

-package DBIx::Custom::SQLTemplate::TagProcessors;

+package DBIx::Custom::QueryBuilder::TagProcessors;

 use strict;

 use warnings;

@@ -117,7 +117,7 @@ sub expand_update_tag {

 =head1 NAME

-DBIx::Custom::SQLTemplate::TagProcessor - Tag processor

+DBIx::Custom::SQLBuilder::TagProcessors - Tag processor

 =head1 FUNCTIONS

@@ -1,374 +0,0 @@

-package DBIx::Custom::SQLTemplate;

-

-use strict;

-use warnings;

-

-use base 'Object::Simple';

-

-use Carp 'croak';

-use DBIx::Custom::Query;

-use DBIx::Custom::SQLTemplate::TagProcessor;

-

-__PACKAGE__->attr('tag_processors' => sub { {} });

-

-__PACKAGE__->attr(tag_start => '{');

-__PACKAGE__->attr(tag_end   => '}');

-

-__PACKAGE__->attr('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 new {

-    my $self = shift->SUPER::new;

-    

-    $self->register_tag_processor(

-        '?'      => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_placeholder_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

-    );

-    

-    return $self;

-}

-

-sub register_tag_processor {

-    my $self = shift;

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

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

-    return $self;

-}

-

-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_columns = [];

-    

-    # 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, $columns) = $tag_processor->($tag_name, $tag_args);

-            

-            # Check tag processor return value

-            croak("Tag processor '$tag_name' must return (\$expand, \$columns)")

-              if !defined $expand || ref $columns 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 @$columns;

-            

-            # Add key information

-            push @$all_columns, @$columns;

-            

-            # Join expand tag to SQL

-            $sql .= $expand;

-        }

-    }

-    

-    # Add semicolon

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

-    

-    # Query

-    my $query = DBIx::Custom::Query->new(sql => $sql, columns => $all_columns);

-    

-    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;

-

-=head1 NAME

-

-DBIx::Custom::SQLTemplate - SQL template system

-

-=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 C<tag_processors>

-

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

-                                                $name2 => $tag_processor2);

-    $tag_processors = $sql_tmpl->tag_processors;

-

-=head2 C<tag_start>

-    

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

-    $tag_start = $sql_tmpl->tag_start;

-

-Default is '{'

-

-=head2 C<tag_end>

-    

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

-    $tag_end = $sql_tmpl->tag_start;

-

-Default is '}'

-    

-=head2 C<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 C<new>

-

-=head2 C<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 C<register_tag_processor>

-

-Add tag processor

-    

-    $sql_tmpl = $sql_tmpl->register_tag_processor($tag_processor);

-

-The following is register_tag_processor sample

-

-    $sql_tmpl->register_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 C<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

-

@@ -70,7 +70,7 @@ $dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});

 test 'DBIx::Custom::Result test';

 $tmpl = "select key1, key2 from table1";

-$query = $dbi->create_query($tmpl);

+$query = $dbi->build_query($tmpl);

 $result = $dbi->execute($query);

 @rows = ();

@@ -98,7 +98,7 @@ test 'Insert query return value';

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

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

 $tmpl = "insert into table1 {insert key1 key2}";

-$query = $dbi->create_query($tmpl);

+$query = $dbi->build_query($tmpl);

 $ret_val = $dbi->execute($query, param => {key1 => 1, key2 => 2});

 ok($ret_val, $test);

@@ -119,7 +119,7 @@ $dbi->register_filter(twice       => sub { $_[0] * 2},

                     three_times => sub { $_[0] * 3});

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

-$insert_query = $dbi->create_query($insert_tmpl);

+$insert_query = $dbi->build_query($insert_tmpl);

 $insert_query->filter({key1 => 'twice'});

 $dbi->execute($insert_query, param => {key1 => 1, key2 => 2});

 $result = $dbi->execute($SELECT_TMPLS->{0});

@@ -130,10 +130,10 @@ $dbi->execute($DROP_TABLE->{0});

 test 'Filter in';

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

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

-$insert_query = $dbi->create_query($insert_tmpl);

+$insert_query = $dbi->build_query($insert_tmpl);

 $dbi->execute($insert_query, param => {key1 => 2, key2 => 4});

 $select_tmpl = "select * from table1 where {in table1.key1 2} and {in table1.key2 2}";

-$select_query = $dbi->create_query($select_tmpl);

+$select_query = $dbi->build_query($select_tmpl);

 $select_query->filter({'table1.key1' => 'twice'});

 $result = $dbi->execute($select_query, param => {'table1.key1' => [1,5], 'table1.key2' => [2,4]});

 $rows = $result->fetch_hash_all;

@@ -146,13 +146,13 @@ $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2, key3 => 3, key4

 $dbi->insert(table => 'table1', param => {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});

 $tmpl = "select * from table1 where {= key1} and {<> key2} and {< key3} and {> key4} and {>= key5};";

-$query = $dbi->create_query($tmpl);

+$query = $dbi->build_query($tmpl);

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

 $rows = $result->fetch_hash_all;

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

 $tmpl = "select * from table1 where {<= key1} and {like key2};";

-$query = $dbi->create_query($tmpl);

+$query = $dbi->build_query($tmpl);

 $result = $dbi->execute($query, param => {key1 => 1, key2 => '%2%'});

 $rows = $result->fetch_hash_all;

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

@@ -164,7 +164,7 @@ $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2, key3 => 3, key4

 $dbi->insert(table => 'table1', param => {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});

 $tmpl = "select * from table1 where {in key1 2};";

-$query = $dbi->create_query($tmpl);

+$query = $dbi->build_query($tmpl);

 $result = $dbi->execute($query, param => {key1 => [9, 1]});

 $rows = $result->fetch_hash_all;

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

@@ -197,8 +197,8 @@ eval {DBIx::Custom->connect(data_source => 'dbi:SQLit')};

 ok($@, "$test : connect error");

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

-eval{$dbi->create_query("{p }")};

-ok($@, "$test : create_query invalid SQL template");

+eval{$dbi->build_query("{p }")};

+ok($@, "$test : build_query invalid SQL template");

 test 'insert';

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

@@ -214,12 +214,12 @@ $dbi->register_filter(

     twice       => sub { $_[0] * 2 },

     three_times => sub { $_[0] * 3 }

 );

-$dbi->default_query_filter('twice');

+$dbi->default_bind_filter('twice');

 $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2}, filter => {key1 => 'three_times'});

 $result = $dbi->execute($SELECT_TMPLS->{0});

 $rows   = $result->fetch_hash_all;

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

-$dbi->default_query_filter(undef);

+$dbi->default_bind_filter(undef);

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

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

@@ -414,7 +414,7 @@ test 'cache';

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

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

 $tmpl = 'select * from table1 where {= key1} and {= key2};';

-$dbi->create_query($tmpl);

+$dbi->build_query($tmpl);

 is_deeply($dbi->{_cached}->{$tmpl}, 

           {sql => "select * from table1 where key1 = ? and key2 = ?;", columns => ['key1', 'key2']}, "$test : cache");

@@ -31,12 +31,12 @@ $dbi = DBIx::Custom->new(

     default_bind_filter => 'f',

     default_fetch_filter => 'g',

     result_class => 'g',

-    sql_template => $SQL_TMPL->{0},

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

 );

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

                 filters => {f => 3}, default_bind_filter => 'f',

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

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

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

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