cleanup ・ 006d7ff ・ Gitprep

- cleanup;
- Browse files
- Yuki Kimoto commited on 2012-01-20
- 1 parent 5c5a8a2
  
  commit 006d7fffcee85b5b1644b8d883d6f663650f0a55

Showing 12 changed files with 4196 additions and 4241 deletions

+572 -572

Changes

@@ -1,754 +1,754 @@
 0.2106
-    - renamed DBIx::Custom::Result::fetch_hash_first to fethc_hash_one
-      because first is misleading name. fethc_hash_first is DEPRECATED!
-    - renamed DBIx::Custom::Result::fetch_first to fetch_one,
-      because first is misleading name. fetch_first is DEPRECATED!
+  - renamed DBIx::Custom::Result::fetch_hash_first to fethc_hash_one
+    because first is misleading name. fethc_hash_first is DEPRECATED!
+  - renamed DBIx::Custom::Result::fetch_first to fetch_one,
+    because first is misleading name. fetch_first is DEPRECATED!
 0.2105
-    - added EXPERIMENTAL DBIx::Custom::Result::value method
-    - added EXPERIMENTAL DBIx::Custom::Result::column method
+  - added EXPERIMENTAL DBIx::Custom::Result::value method
+  - added EXPERIMENTAL DBIx::Custom::Result::column method
 0.2104
-    - improved bulk_insert performance
+  - improved bulk_insert performance
 0.2103
-    - added EXPERIMENTAL insert bulk_insert option.
+  - added EXPERIMENTAL insert bulk_insert option.
 0.2102
-    - fixed bug that DBIx::Custom::Model count method don't receive model's
-      attribute
-    - insert method can receive multipule parameters, this is very fast, this is experimental
+  - fixed bug that DBIx::Custom::Model count method don't receive model's
+    attribute
+  - insert method can receive multipule parameters, this is very fast, this is experimental
 0.2101
-    - fixed small default_bind_filter bug
-    - micro optimization
-    - select method can receive odd number argument. In that case first argument
-      is column option.
-    - fixed update_or_insert bug that when parameter don't contain any key-value
-      this method throw exception.
+  - fixed small default_bind_filter bug
+  - micro optimization
+  - select method can receive odd number argument. In that case first argument
+    is column option.
+  - fixed update_or_insert bug that when parameter don't contain any key-value
+    this method throw exception.
 0.2100
-    - micro optimization
-    - DBIx::Custom::Query is DEPRECATED!
+  - micro optimization
+  - DBIx::Custom::Query is DEPRECATED!
 0.1747
-    - fixed bug DBIx::Custom::Result fetch_hash_multi throw warnings
-      which cannnot fetch any more
-    - fixed bug DBIx::Custom::Result fetch_hash_multi throw warnings
-      which cannnot fetch any more
+  - fixed bug DBIx::Custom::Result fetch_hash_multi throw warnings
+    which cannnot fetch any more
+  - fixed bug DBIx::Custom::Result fetch_hash_multi throw warnings
+    which cannnot fetch any more
 0.1746
-    - micro optimization
+  - micro optimization
 0.1745
-    - DBIx::Custom::Order prepend method receiving array reference
-      is DEPRECATED!
-    - DBIx::Custom::QueryBuilder class is DEPRECATED!
-    - added DBIX_CUSTOM_DISABLE_MODEL_EXECUTE environment variable
-    - added DBIX_CUSTOM_TAG_PARSE environment variable
-    - tag_parse attribute is DEPRECATED! 
-    - show_datatype method return lower case string
-    - show_typename method return lower case string
-    - DBIx::Custom::Result filter_on method is DEPRECATED!
-    - DBIx::Custom::Result filter_off method is DEPRECATED!
+  - DBIx::Custom::Order prepend method receiving array reference
+    is DEPRECATED!
+  - DBIx::Custom::QueryBuilder class is DEPRECATED!
+  - added DBIX_CUSTOM_DISABLE_MODEL_EXECUTE environment variable
+  - added DBIX_CUSTOM_TAG_PARSE environment variable
+  - tag_parse attribute is DEPRECATED! 
+  - show_datatype method return lower case string
+  - show_typename method return lower case string
+  - DBIx::Custom::Result filter_on method is DEPRECATED!
+  - DBIx::Custom::Result filter_off method is DEPRECATED!
 0.1744
-    - id option work if id count is lower than primary key count.
-    - removed EXPERIMETNAL status from update_or_insert method and
-      DBIx::Custom::Model's update_or_insert method
-    - removed EXPERIMENTAL status from reuse option
-    - removed EXPERIMENTAL status from update_at option and created_at option
-    - removed EXPERIMETNAL status from now attribute
+  - id option work if id count is lower than primary key count.
+  - removed EXPERIMETNAL status from update_or_insert method and
+    DBIx::Custom::Model's update_or_insert method
+  - removed EXPERIMENTAL status from reuse option
+  - removed EXPERIMENTAL status from update_at option and created_at option
+  - removed EXPERIMETNAL status from now attribute
 0.1743
-    - DBIx::Custom::Model execute method is DEPRECATED!
-    - fixed bug that update_all can't receive parameter as first argument
-    - fixed bug that delete_all can't receive parameter as first argument
-    - fixed where clause parsing bug when time(like 00:00:00) contain
+  - DBIx::Custom::Model execute method is DEPRECATED!
+  - fixed bug that update_all can't receive parameter as first argument
+  - fixed bug that delete_all can't receive parameter as first argument
+  - fixed where clause parsing bug when time(like 00:00:00) contain
 0.1742
-    - fixed update_or_insert method bug
-    - micro optimization
+  - fixed update_or_insert method bug
+  - micro optimization
 0.1741
-    - added EXPERIMENTAL update_or_insert to DBIx::Custom::Model
+  - added EXPERIMENTAL update_or_insert to DBIx::Custom::Model
 0.1740
-    - EXPERIMENTAL update_or_insert need id and primary_key option
-      and added option option
-    - insert method created_at and updated_at option can receive scalar reference
-    - update method updated_at option can receive scalar reference
-    - select column option [COLUMN => ALIAS] syntax is DEPRECATED!
-    - added EXPERIMENTAL q method
-    - execute method id option is DEPRECATED!
+  - EXPERIMENTAL update_or_insert need id and primary_key option
+    and added option option
+  - insert method created_at and updated_at option can receive scalar reference
+  - update method updated_at option can receive scalar reference
+  - select column option [COLUMN => ALIAS] syntax is DEPRECATED!
+  - added EXPERIMENTAL q method
+  - execute method id option is DEPRECATED!
 0.1739
-    - insert timestamp option is DEPRECATED!
-      use created_at option with now attribute
-    - update timestamp option is DEPRECATED!
-      use updated_at option wieh now attribute
-    - insert_timestamp method is DEPRECATED!
-      use now method
-    - update_timestamp method is DEPRECATED!
-      use use now method
-    - added EXPEREIMTNAL now method
-    - added EXPERIMENTAL insert created_at option
-    - added EXPERIMETNAL insert updated_at option
-    - added EXPERIMETNAL update updated_at option
-    - added new timestamp system using the above methods and options
+  - insert timestamp option is DEPRECATED!
+    use created_at option with now attribute
+  - update timestamp option is DEPRECATED!
+    use updated_at option wieh now attribute
+  - insert_timestamp method is DEPRECATED!
+    use now method
+  - update_timestamp method is DEPRECATED!
+    use use now method
+  - added EXPEREIMTNAL now method
+  - added EXPERIMENTAL insert created_at option
+  - added EXPERIMETNAL insert updated_at option
+  - added EXPERIMETNAL update updated_at option
+  - added new timestamp system using the above methods and options
 0.1738
-    - micro optimization
-    - removed example that query pass execute method in documentation
-      this is many bug reason much more than I have expected
-      and passing query to execute method is DEPRECATED!
-    - insert method id value is not copied to parameter
-      if the key exists in parameter
+  - micro optimization
+  - removed example that query pass execute method in documentation
+    this is many bug reason much more than I have expected
+    and passing query to execute method is DEPRECATED!
+  - insert method id value is not copied to parameter
+    if the key exists in parameter
 0.1737
-    - micro optimization
-    - fixed DEBUG messsage bug
+  - micro optimization
+  - fixed DEBUG messsage bug
 0.1736
-    - micro optimization
+  - micro optimization
 0.1735
-    - added EXPERIMENTAL reuse_query option to execute method
+  - added EXPERIMENTAL reuse_query option to execute method
 0.1734
-    - moved DBIx::Custom::Guide to wiki
+  - moved DBIx::Custom::Guide to wiki
 0.1733
-    - select method join option can receive string.
-    - removed DEPRECATED status of select param option
-    - select method where_param option is DEPRECATED!
-      use where => [STRING, PARAM] syntax instead
-    - delete method where_param option is DEPRECATED!
-      use where => [STRING, PARAM] syntax instead
-    - update method where_param option is DEPRECATED!
-      use where => [STRING, PARAM] syntax instead
-    - update method param option is DEPRECATED!
-    - insert method param option is DEPRECATED!
-    - removed argument checking logic because in database performance is more
-      important.
+  - select method join option can receive string.
+  - removed DEPRECATED status of select param option
+  - select method where_param option is DEPRECATED!
+    use where => [STRING, PARAM] syntax instead
+  - delete method where_param option is DEPRECATED!
+    use where => [STRING, PARAM] syntax instead
+  - update method where_param option is DEPRECATED!
+    use where => [STRING, PARAM] syntax instead
+  - update method param option is DEPRECATED!
+  - insert method param option is DEPRECATED!
+  - removed argument checking logic because in database performance is more
+    important.
 0.1732
-    - removed EXPERIMETNAL flag from like_value
+  - removed EXPERIMETNAL flag from like_value
 0.1731
-    - removed DEPRECATED status from insert method's id option
-    - renamed EXPERIMENTAL insert_or_update to update_or_insert
+  - removed DEPRECATED status from insert method's id option
+  - renamed EXPERIMENTAL insert_or_update to update_or_insert
 0.1730
-    - added EXPERIMENTAL insert_or_update method
-    - method method of DBIx::Custom::Model is renamed to helper,
-      method is DEPRECATED!
-    - method method is renamed to helper, method is DEPRECATED!
-    - insert method's id option is DEPRECATED!
-    - fixed id option bug when column name is anbiguous
+  - added EXPERIMENTAL insert_or_update method
+  - method method of DBIx::Custom::Model is renamed to helper,
+    method is DEPRECATED!
+  - method method is renamed to helper, method is DEPRECATED!
+  - insert method's id option is DEPRECATED!
+  - fixed id option bug when column name is anbiguous
 0.1729
-    - dbi_option attribute is renamed to option, dbi_option is DEPRECATED!
-    - default_dbi_option is renamed to default_option, default_dbi_option
-      is DEPRECATED!
+  - dbi_option attribute is renamed to option, dbi_option is DEPRECATED!
+  - default_dbi_option is renamed to default_option, default_dbi_option
+    is DEPRECATED!
 0.1728
-    - added {key => ..., value => ...} syntax to DBIx::Custom::Mapper map method
-      ,and argument of string and code reference is DEPRECATED!
-    - update_param is DEPRECATED, use assing_clause instead.
-    - assing_param is renamed to assing_clause, assing_param is DEPRECATED!
-    - insert_param is renamed to values_clause, insert_param is DEPRECATED!
+  - added {key => ..., value => ...} syntax to DBIx::Custom::Mapper map method
+    ,and argument of string and code reference is DEPRECATED!
+  - update_param is DEPRECATED, use assing_clause instead.
+  - assing_param is renamed to assing_clause, assing_param is DEPRECATED!
+  - insert_param is renamed to values_clause, insert_param is DEPRECATED!
 0.1727
-    - improved join clause parsing
+  - improved join clause parsing
 0.1726
-    - improved join clause parsing
+  - improved join clause parsing
 0.1725
-    - improved join clause parsing
+  - improved join clause parsing
 0.1724
-    - added EXPERIMENTAL like_value method to DBIx::Custom
-    - sqlfilter option is renamed to after_build_sql, sqlfilter is DEPRECATED!
-    - removed EXPERIMENTAL flag from DBIx::Custom::Mapper
-    - removed EXPERIMENTAL flag from the following DBIx::Custom methods
-    insert_timestamp, mapper, update_timestamp
-    - removed EXPERIMENTAL flag from the following DBIx::Custom method's option
-    timestamp, 
+  - added EXPERIMENTAL like_value method to DBIx::Custom
+  - sqlfilter option is renamed to after_build_sql, sqlfilter is DEPRECATED!
+  - removed EXPERIMENTAL flag from DBIx::Custom::Mapper
+  - removed EXPERIMENTAL flag from the following DBIx::Custom methods
+  insert_timestamp, mapper, update_timestamp
+  - removed EXPERIMENTAL flag from the following DBIx::Custom method's option
+  timestamp, 
 0.1723
-    - removed EXPERIMENTAL call_dbi method from DBIx::Custom::Model
-    - removed EXPERIMENTAL map_param method from DBIx::Custom
-    - removed EXPERIMENTAL the following methods from DBIx::Custom::Where
-      if, map
-    - removed EXPERIMENTAL flag from the following DBIx::Custom::Model methods
-      count, execute
-    - removed EXPERIMENTAL flag from the following DBIx::Custom::Result mehotds
-      filter_on, type_rule, type_rule_off, type_rule_on, type_rule1_off,
-      type_rule1_on, type_rule2_off, type_rule2_on
-    - removed EXPERIMENTAL flag from the following DBIx::Custom method's options
-      sqlfilter, type_rule_off, type_rule1_off, type_rule2_off,
-      table_alias, wrap
-    - removed EXPERIMENTAL flag from DBIx::Custom::Order
-    - removed EXPERIMETNAL flag from the following DBIx::Custom methods
-      exclude_table, user_column_info,
-      user_table_info, available_datatype, available_typename,
-      assign_param, count, get_column_info, get_table_info
-      order, show_datatype, show_typename methods, show_tables, type_rule,
-    - added EXPERIMENTAL update_timestamp method to DBIx::Custom
-    - added EXPERIMENTAL insert_timestamp method to DBIx::Custom
-    - removed EXPERIMENTAL timestamp attribute from DBIx::Custom
+  - removed EXPERIMENTAL call_dbi method from DBIx::Custom::Model
+  - removed EXPERIMENTAL map_param method from DBIx::Custom
+  - removed EXPERIMENTAL the following methods from DBIx::Custom::Where
+    if, map
+  - removed EXPERIMENTAL flag from the following DBIx::Custom::Model methods
+    count, execute
+  - removed EXPERIMENTAL flag from the following DBIx::Custom::Result mehotds
+    filter_on, type_rule, type_rule_off, type_rule_on, type_rule1_off,
+    type_rule1_on, type_rule2_off, type_rule2_on
+  - removed EXPERIMENTAL flag from the following DBIx::Custom method's options
+    sqlfilter, type_rule_off, type_rule1_off, type_rule2_off,
+    table_alias, wrap
+  - removed EXPERIMENTAL flag from DBIx::Custom::Order
+  - removed EXPERIMETNAL flag from the following DBIx::Custom methods
+    exclude_table, user_column_info,
+    user_table_info, available_datatype, available_typename,
+    assign_param, count, get_column_info, get_table_info
+    order, show_datatype, show_typename methods, show_tables, type_rule,
+  - added EXPERIMENTAL update_timestamp method to DBIx::Custom
+  - added EXPERIMENTAL insert_timestamp method to DBIx::Custom
+  - removed EXPERIMENTAL timestamp attribute from DBIx::Custom
 0.1722
-    - added EXPERIMENTAL timestamp option to DBIx::Custom insert
-      and update method.
-    - added EXPERIMENTAL timestamp attribute to DBIx::Custom
-    - added {KEY => {OPTION_KEY => OPTION_VALUE} syntax
-      to EXPERIMENTAL DBIx::Custom::Mapper map method
-    - added {KEY => sub { VALUE }} syntax
-      to EXPERIMETNAL DBIx::Custom::Mapper map method
-    - removed EXPERIMENTAL wrap option from select method
-    - insert_param, update_param, and assign param can
-      be wrapeed by DB function by C<wrap> option
-    - added EXPERIMENTAL pass attribute to DBIx::Custom::Mapper
-    - removed EXPERIMENTAL ignore attribute from DBIx::Custom::Mapper
+  - added EXPERIMENTAL timestamp option to DBIx::Custom insert
+    and update method.
+  - added EXPERIMENTAL timestamp attribute to DBIx::Custom
+  - added {KEY => {OPTION_KEY => OPTION_VALUE} syntax
+    to EXPERIMENTAL DBIx::Custom::Mapper map method
+  - added {KEY => sub { VALUE }} syntax
+    to EXPERIMETNAL DBIx::Custom::Mapper map method
+  - removed EXPERIMENTAL wrap option from select method
+  - insert_param, update_param, and assign param can
+    be wrapeed by DB function by C<wrap> option
+  - added EXPERIMENTAL pass attribute to DBIx::Custom::Mapper
+  - removed EXPERIMENTAL ignore attribute from DBIx::Custom::Mapper
 0.1721
-    - added EXPERIMENTAL DBIx::Custom::Mapper class
-    - added EXPERIMENTAL mapper method to DBIx::Custom
+  - added EXPERIMENTAL DBIx::Custom::Mapper class
+  - added EXPERIMENTAL mapper method to DBIx::Custom
 0.1720
-    - removed placeholder count check
-    - added EXPERIMENTAL execute method's id and primary key option.
-    - added EXPERIMENTAL DBIx::Custom::Model execute method
+  - removed placeholder count check
+  - added EXPERIMENTAL execute method's id and primary key option.
+  - added EXPERIMENTAL DBIx::Custom::Model execute method
 0.1719
-    - DBIx::Custom support Microsoft Access through DBD::ODBC
+  - DBIx::Custom support Microsoft Access through DBD::ODBC
 0.1718
-    - added EXPERIMENTAL DBIx::Custom::Model call_dbi method
-    - added EXPERIMENTAL count method
-    - added EXPERIMENTAL DBIx::Custom::Model count method
+  - added EXPERIMENTAL DBIx::Custom::Model call_dbi method
+  - added EXPERIMENTAL count method
+  - added EXPERIMENTAL DBIx::Custom::Model count method
 0.1717
-    - added EXPERIMENTAL get_table_info
-    - added EXPERIMETNAL user_table_info attribute
-      and each_table find table info in user_table_info if set.
-    - added EXPERIMENTAL get_column_info
-    - added EXPERIMENTAL user_column_info attribute
-      and each_column find column info in user_column_info if set.
-    - connector is automatically set to DBDx::Connector object
-      if connector is set to 1 when connect method is called.
+  - added EXPERIMENTAL get_table_info
+  - added EXPERIMETNAL user_table_info attribute
+    and each_table find table info in user_table_info if set.
+  - added EXPERIMENTAL get_column_info
+  - added EXPERIMENTAL user_column_info attribute
+    and each_column find column info in user_column_info if set.
+  - connector is automatically set to DBDx::Connector object
+    if connector is set to 1 when connect method is called.
 0.1716
-    - fixed bugs when using DBD::Oracle.
-    - added EXPERIMENTAL show_tables method.
+  - fixed bugs when using DBD::Oracle.
+  - added EXPERIMENTAL show_tables method.
 0.1715
-    - default quote attribute in ODBC driver is changed to "[]"
-    - fixed some bug in Microsoft SQL Server
-    - added EXPERIMENTAL execute method sqlfilter option
+  - default quote attribute in ODBC driver is changed to "[]"
+  - fixed some bug in Microsoft SQL Server
+  - added EXPERIMENTAL execute method sqlfilter option
 0.1714
-    - fixed not backword compatible change in 0.1712 query_buider
+  - fixed not backword compatible change in 0.1712 query_buider
 0.1713
-    - fixed memory leak and connection increasing bug when using model.
+  - fixed memory leak and connection increasing bug when using model.
 0.1712
-    - you can set any string as separator
-    - fixed memory leak and connection increasing bug, and query_buider method return new object.
-    - added EXPERIMENTAL exclude_table attribute
-    - added EXPERIMENTAL show_typename method
-    - added EXPERIMENTAL show_datatype method
+  - you can set any string as separator
+  - fixed memory leak and connection increasing bug, and query_buider method return new object.
+  - added EXPERIMENTAL exclude_table attribute
+  - added EXPERIMENTAL show_typename method
+  - added EXPERIMENTAL show_datatype method
 0.1711
-    - renamed EXPERIMENTAL available_type_name to available_typename
-    - renamed EXPERIMENTAL available_data_type to available_datatype
-    - added EXPERIMENTAL DBIx::Custom::Where if method
-    - added EXPERIMENTAL DBIx::Custom::Where map method
+  - renamed EXPERIMENTAL available_type_name to available_typename
+  - renamed EXPERIMENTAL available_data_type to available_datatype
+  - added EXPERIMENTAL DBIx::Custom::Where if method
+  - added EXPERIMENTAL DBIx::Custom::Where map method
 0.1710
-    - use more DBIx::Custom information in sub modules to decrease bugs
-      (very sorry, this change can't keep backword compatible,
-       but maybe no effects,
-       because the attributes is automatically set by DBIx::Custom, not user).
-    - Fixed fisrt executed where clause failed in some condition.
+  - use more DBIx::Custom information in sub modules to decrease bugs
+    (very sorry, this change can't keep backword compatible,
+     but maybe no effects,
+     because the attributes is automatically set by DBIx::Custom, not user).
+  - Fixed fisrt executed where clause failed in some condition.
 0.1709
-    - fixed named placeholder bug and added escape syntax
+  - fixed named placeholder bug and added escape syntax
 0.1708
-    - improved execute method performance
+  - improved execute method performance
 0.1707
-    - I call :title named placeholder, stoping calling it parameter
-    - removed some EXPERIMENTAL status
-    - fixed performance
+  - I call :title named placeholder, stoping calling it parameter
+  - removed some EXPERIMENTAL status
+  - fixed performance
 0.1706
-    - Added execute method's query option document
-      You can get more performance.
-    - DBIx::Custom::Query table and filters attribute method and
-      filter method is DEPRECATED!
-      because I think query object must have only the information
-      for statement handle caching.
+  - Added execute method's query option document
+    You can get more performance.
+  - DBIx::Custom::Query table and filters attribute method and
+    filter method is DEPRECATED!
+    because I think query object must have only the information
+    for statement handle caching.
 0.1705
-    - insert and update method's param can set constant value by scalara reference
-      such as {date => \"NOW()"} This is EXPERIMENTAL.
+  - insert and update method's param can set constant value by scalara reference
+    such as {date => \"NOW()"} This is EXPERIMENTAL.
 0.1704
-    - added quote method's two character support like []
-      for Microsoft SQL Server and Access
-    - added EXPERIMENTAL parameter new syntax :name{operator}
+  - added quote method's two character support like []
+    for Microsoft SQL Server and Access
+  - added EXPERIMENTAL parameter new syntax :name{operator}
 0.1703
-    - added EXPERIMENTAL join new syntax.
+  - added EXPERIMENTAL join new syntax.
 0.1702
-    - removed EXPERIMENTAL status of some methods.
-    - fixed some join bug
+  - removed EXPERIMENTAL status of some methods.
+  - fixed some join bug
 0.1701
-    - added DBIx::Cusotm::Order prepend method automatically quoted syntax
-    - simplified arguments check
-    - added EXPERIMENTAL each_table method
-    - select method column option [COLUMN, as => ALIAS] format is DEPRECATED!
-      changed to [COLUMN => ALIAS]
-    - added EXPERIMENTAL DBIx::Custom::Result header method
-    - added EXPERIMENTAL last_sql attribute method
+  - added DBIx::Cusotm::Order prepend method automatically quoted syntax
+  - simplified arguments check
+  - added EXPERIMENTAL each_table method
+  - select method column option [COLUMN, as => ALIAS] format is DEPRECATED!
+    changed to [COLUMN => ALIAS]
+  - added EXPERIMENTAL DBIx::Custom::Result header method
+  - added EXPERIMENTAL last_sql attribute method
 0.1700
-    - fixed end_filter DEPRECATED warnings bug
+  - fixed end_filter DEPRECATED warnings bug
 0.1699
-    - added tag_parse attribute.
-    - added EXPERIMENTAL order method
-    - added EXPERIMENTAL DBIx::Custom::Order module
-    - changed backword compatible policy
-      ------------------------------------------------------------------------
-      If a functionality is DEPRECATED, you can know it by DEPRECATED warnings
-      except for attribute method.
-      You can check all DEPRECATED functionalities by document.
-      DEPRECATED functionality is removed after five years,
-      but if at least one person use the functionality and tell me that thing
-      I extend one year each time you tell me it.
+  - added tag_parse attribute.
+  - added EXPERIMENTAL order method
+  - added EXPERIMENTAL DBIx::Custom::Order module
+  - changed backword compatible policy
+    ------------------------------------------------------------------------
+    If a functionality is DEPRECATED, you can know it by DEPRECATED warnings
+    except for attribute method.
+    You can check all DEPRECATED functionalities by document.
+    DEPRECATED functionality is removed after five years,
+    but if at least one person use the functionality and tell me that thing
+    I extend one year each time you tell me it.
 
-      EXPERIMENTAL functionality will be changed without warnings.
-      ------------------------------------------------------------------------
+    EXPERIMENTAL functionality will be changed without warnings.
+    ------------------------------------------------------------------------
 0.1698
-    - fixed DBIx::Custom::Where to_string method small bug
-    - added EXPERIMENTAL execute method table_alias option
+  - fixed DBIx::Custom::Where to_string method small bug
+  - added EXPERIMENTAL execute method table_alias option
 0.1697
-    - added EXPERIMENTAL map_param method
+  - added EXPERIMENTAL map_param method
 0.1696
-    - added new argument format update, delete, select method where option
-    - create_query is DEPRECATED! use query option of each method instead.
-    - added EXPERIMENTAL insert, update, and select method prefix option
-    - fixed small insert, update, delete, select method id option bug
+  - added new argument format update, delete, select method where option
+  - create_query is DEPRECATED! use query option of each method instead.
+  - added EXPERIMENTAL insert, update, and select method prefix option
+  - fixed small insert, update, delete, select method id option bug
 0.1695
-    - changed EXPERIMENTAL DBIx::Custom::Result type_rule_off method argument
-    - added EXPERIMENTAL DBIx::Custom::Result type_rule_on method
-    - changed EXPERIMENTAL DBIx::Custom::Result type_rule1_off method argument
-    - added EXPERIMENTAL DBIx::Custom::Result type_rule1_on method
-    - changed EXPERIMENTAL DBIx::Custom::Result type_rule2_off method argument
-    - added EXPERIMENTAL DBIx::Custom::Result type_rule2_on method
-    - changed EXPERIMENTAL DBIx::Custom::Result filter_off method argument
-    - added EXPERIMENTAL DBIx::Custom::Result filter_on method
+  - changed EXPERIMENTAL DBIx::Custom::Result type_rule_off method argument
+  - added EXPERIMENTAL DBIx::Custom::Result type_rule_on method
+  - changed EXPERIMENTAL DBIx::Custom::Result type_rule1_off method argument
+  - added EXPERIMENTAL DBIx::Custom::Result type_rule1_on method
+  - changed EXPERIMENTAL DBIx::Custom::Result type_rule2_off method argument
+  - added EXPERIMENTAL DBIx::Custom::Result type_rule2_on method
+  - changed EXPERIMENTAL DBIx::Custom::Result filter_off method argument
+  - added EXPERIMENTAL DBIx::Custom::Result filter_on method
 0.1694
-    - EXPERIMENTAL type_rule argument format is changed
-    - DBIx::Custom::Result type_rule method on setting return self 
-    - reserved_word_quote is DEPRECATED! this is renamed to quote
-    - DBIx::Custom::Model type attribute is DEPRECATED!
-      this is renamed to bind_type.
+  - EXPERIMENTAL type_rule argument format is changed
+  - DBIx::Custom::Result type_rule method on setting return self 
+  - reserved_word_quote is DEPRECATED! this is renamed to quote
+  - DBIx::Custom::Model type attribute is DEPRECATED!
+    this is renamed to bind_type.
 0.1693
-    - separate DBIx::Custom type_rule from filter
-    - DBIx::Custom::Model filter attrribute is DEPRECATED!
-    - DBIx::Custom::Model name attribute 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
+  - separate DBIx::Custom type_rule from filter
+  - DBIx::Custom::Model filter attrribute is DEPRECATED!
+  - DBIx::Custom::Model name attribute 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
-    - DBIx::Custom::Result filter override type_rule
-    - added EXPERIMENTAL DBIx::Custom::Result type_rule
-    - added EXPERIMENTAL available_type_name method 
-    - EXPERIMENTAL type_rule_off is not passed form execute method 
-      to DBIx::Custom::Result object
+  - removed EXPERIMENTAL DBIx::Model result_filter
+  - DBIx::Custom::Result filter override type_rule
+  - added EXPERIMENTAL DBIx::Custom::Result type_rule
+  - added EXPERIMENTAL available_type_name method 
+  - EXPERIMENTAL type_rule_off is not passed form execute method 
+    to DBIx::Custom::Result object
 0.1691
-    - DBIx::Custom::Result end_filter, remove_filter, remove_end_filter is DEPRECATED!
-    - apply_filter is DEPRECATED!
-    - EXPERIMETAL column method and table_alias think about "-" separator
-    - EXPERIMTANL column method think about separator
-    - removed EXPERIMENTAL col method.
-    - added EXPERIMENTAL separater method
-    - added EXPERIMENTAL select prefix option.
-    - fixed bug that data_source DEPRECATED warnings pirnt STDERR
-    - fixed bug that type_rule from option can't receive filter name
+  - DBIx::Custom::Result end_filter, remove_filter, remove_end_filter is DEPRECATED!
+  - apply_filter is DEPRECATED!
+  - EXPERIMETAL column method and table_alias think about "-" separator
+  - EXPERIMTANL column method think about separator
+  - removed EXPERIMENTAL col method.
+  - added EXPERIMENTAL separater method
+  - added EXPERIMENTAL select prefix option.
+  - fixed bug that data_source DEPRECATED warnings pirnt STDERR
+  - fixed bug that type_rule from option can't receive filter name
 0.1690
-    - use latest Object::Simple features
+  - use latest Object::Simple features
 0.1689
-    - added EXPERIMENTAL available_data_type
-    - simplified type_rule
-    - changed type_rule arguments format
-    - added EXPERIMENTAL DBIx::Custom::Model result_filter attribute
-    - added EXPERIMETNAL DBIx::Custom::Result filter_off method
-    - EXPERIMENTAL type_rule can receive filter name
+  - added EXPERIMENTAL available_data_type
+  - simplified type_rule
+  - changed type_rule arguments format
+  - added EXPERIMENTAL DBIx::Custom::Model result_filter attribute
+  - added EXPERIMETNAL DBIx::Custom::Result filter_off method
+  - EXPERIMENTAL type_rule can receive filter name
 0.1688
-    - fixed bug that model insert, update, delete select can't
-      odd number arguments
-    - improved type_rule method
+  - fixed bug that model insert, update, delete select can't
+    odd number arguments
+  - improved type_rule method
 0.1687
-    - added EXPERIMENTAL type_rule method
-    - added EXPERIMENTAL execute() type_rule_off option
-    - execute method can second argument as parameter
+  - added EXPERIMENTAL type_rule method
+  - added EXPERIMENTAL execute() type_rule_off option
+  - execute method can second argument as parameter
 0.1686
-    - select() column option can receive array reference in array.
-      This is EXPERIMENTAL
-    - select() EXPERIMETNAL column option hash format
-      return table.column, not table__column
-    - added EXPERIMENTAL col method.
-    - set reserved_word_quote automatically from driver name
+  - select() column option can receive array reference in array.
+    This is EXPERIMENTAL
+  - select() EXPERIMETNAL column option hash format
+    return table.column, not table__column
+  - added EXPERIMENTAL col method.
+  - set reserved_word_quote automatically from driver name
 0.1685
-    - insert_at, update_at, delete_at, select_at is DEPRECATED!
-      use insert, update, delete, select method and id option.
-    - insert, insert_at, update, update_at can receive odd number arguments,
-      first one is parameter.
+  - insert_at, update_at, delete_at, select_at is DEPRECATED!
+    use insert, update, delete, select method and id option.
+  - insert, insert_at, update, update_at can receive odd number arguments,
+    first one is parameter.
 0.1684
-    - added DBIx::Custom::Result all method, this is alias for fetch_hash_all
-    - added DBIx::Custom::Result one method, this is alias for fetch_hash_first
-    - DBIx::Custom::Result fetch_hash_first can recieve argument
-    - select() column option can receive hash reference. This is EXPERIMENTAL
-    - update_param_tag is DEPRECATED! use update_param instead.
-    - insert_param_tag is DEPRECATED! use insert_param instead.
-    - assing_param_tag is DEPRECATED! use assign_param instead.
-    - Tag system such as {? title}, {= title} is DEPRECATED!
-      and added paramter system such as :title.
+  - added DBIx::Custom::Result all method, this is alias for fetch_hash_all
+  - added DBIx::Custom::Result one method, this is alias for fetch_hash_first
+  - DBIx::Custom::Result fetch_hash_first can recieve argument
+  - select() column option can receive hash reference. This is EXPERIMENTAL
+  - update_param_tag is DEPRECATED! use update_param instead.
+  - insert_param_tag is DEPRECATED! use insert_param instead.
+  - assing_param_tag is DEPRECATED! use assign_param instead.
+  - Tag system such as {? title}, {= title} is DEPRECATED!
+    and added paramter system such as :title.
 0.1683
-    - data_source is DEPRECATED! It is renamed to dsn
+  - data_source is DEPRECATED! It is renamed to dsn
 0.1682
-    - improved debug message
-    - fixed merge_param bug
+  - improved debug message
+  - fixed merge_param bug
 0.1681
-    - added EXPERIMENTAL assign_tag() method
+  - added EXPERIMENTAL assign_tag() method
 0.1680
-    - DEPRECATED select() param option, this is renamed to where_param
-    - added select(), update(), and delete() where_param option
+  - DEPRECATED select() param option, this is renamed to where_param
+  - added select(), update(), and delete() where_param option
 0.1679
-    - added EXPERIMENTAL select() wrap option to support Oracle ROWNUM
+  - added EXPERIMENTAL select() wrap option to support Oracle ROWNUM
 0.1678
-    - DBIx::Custom::Model filter attribute can receive hash reference
-    - DBIx::Custom::Where clause attribute can receive clause without column name
-    - improved error messages
+  - DBIx::Custom::Model filter attribute can receive hash reference
+  - DBIx::Custom::Where clause attribute can receive clause without column name
+  - improved error messages
 0.1677
-    - improved table search in column and join clause
-    - DEPRECATED table tag. use table option.
+  - improved table search in column and join clause
+  - DEPRECATED table tag. use table option.
 0.1676
-    - fixed test bug
+  - fixed test bug
 0.1675
-    - removed DEPRECATED DBIx::Custom::MySQL and DBIx::Custom::SQLite
-      these implementations remine in https://github.com/yuki-kimoto/DBIx-Custom/wiki
-      for some users.
-    - removed EXPERIMENTAL replace().
-    - removed EXPERIMENTAL mark from many methods.
+  - removed DEPRECATED DBIx::Custom::MySQL and DBIx::Custom::SQLite
+    these implementations remine in https://github.com/yuki-kimoto/DBIx-Custom/wiki
+    for some users.
+  - removed EXPERIMENTAL replace().
+  - removed EXPERIMENTAL mark from many methods.
 0.1674
-    - fixed test bug
+  - fixed test bug
 0.1673
-    - fixed dbh() method bug.
+  - fixed dbh() method bug.
 0.1672
-    - removed EXPERIMENTAL Prefork server safe implementation, my implementation is very buggy.
-    - added EXPERIMETNAL connector() attribute.
-    - change retern value to array refrence of EXPERIMENTAL replace()
+  - removed EXPERIMENTAL Prefork server safe implementation, my implementation is very buggy.
+  - added EXPERIMETNAL connector() attribute.
+  - change retern value to array refrence of EXPERIMENTAL replace()
 0,1671
-    - added environment variable DBIX_CUSTOM_DEBUG
+  - added environment variable DBIX_CUSTOM_DEBUG
 0.1670
-    - removed EXPERIMETNAL select() column hash option. it's a little complex.
-    - added EXPERIMENTAL select() param option.
-    - added EXPERIMENTAL replace().
+  - removed EXPERIMETNAL select() column hash option. it's a little complex.
+  - added EXPERIMENTAL select() param option.
+  - added EXPERIMENTAL replace().
 0.1669
-    - renamed update_param to update_param_tag, update_param is DEPRECATED!
-    - renamed insert_param to insert_param_tag, insert_param is DEPRECATED!
+  - renamed update_param to update_param_tag, update_param is DEPRECATED!
+  - renamed insert_param to insert_param_tag, insert_param is DEPRECATED!
 0.1668
-    - added EXPERIMENTAL update_param no_set option.
-    - added EXPERIMENTAL reserved_word_quote attribute.
+  - added EXPERIMENTAL update_param no_set option.
+  - added EXPERIMENTAL reserved_word_quote attribute.
 0.1666
-    - removed from cache() and cache_method() document for a while and cache() value
-      become 0 because I find something bug.
-    - create_model() return model.
-    - added document of hash filter
-    - adeed EXPERIMENTAL DBIx::Custom::Model method()
+  - removed from cache() and cache_method() document for a while and cache() value
+    become 0 because I find something bug.
+  - create_model() return model.
+  - added document of hash filter
+  - adeed EXPERIMENTAL DBIx::Custom::Model method()
 0.1665
-    - removed EXPERIMETNAL flag from insert_at(), update_at(), delete_at(), select_at(), insert_param(), not_exists(), select()'s query option, update_param(), where, table tag, each column, safety_character, DBIx::Where, where().
-    - added EXPERIMETNAL create_model()
+  - removed EXPERIMETNAL flag from insert_at(), update_at(), delete_at(), select_at(), insert_param(), not_exists(), select()'s query option, update_param(), where, table tag, each column, safety_character, DBIx::Where, where().
+  - added EXPERIMETNAL create_model()
 0.1664
-    - where can recieve array refrence, which contains where cluase and paramter.
+  - where can recieve array refrence, which contains where cluase and paramter.
 0.1663
-    - added EXPERIMENTAL type() attribute to DBIx::Custom::Model
-    - added EXPERIMENTAL bind_param_option can set bind_param option
-      to insert(), update(), delete(), select(), insert_at(),
-      update_at(), delete_at(), select_at(), delete_all(), update_all()
+  - added EXPERIMENTAL type() attribute to DBIx::Custom::Model
+  - added EXPERIMENTAL bind_param_option can set bind_param option
+    to insert(), update(), delete(), select(), insert_at(),
+    update_at(), delete_at(), select_at(), delete_all(), update_all()
 0.1662
-    - removed EXPERIMENTAL DBIx::Custom::Model column_clause
-    - added EXPERIMENTAL column()
-    - added EXPERIMENTAL mycolumn()
+  - removed EXPERIMENTAL DBIx::Custom::Model column_clause
+  - added EXPERIMENTAL column()
+  - added EXPERIMENTAL mycolumn()
 0.1661
-    - added EXPERIMENTAL DBIx::Custom::Model table_alias attribute
-    - added EXPERIMENTAL DBIx::Custom::Model mycolumn()
-    - added EXPERIMENTAL DBIx::Custom::Model column()
-    - fixed autoloading bug
-    - added EXPERIMETNAL select() prepend table option
-    - added EXPERIMETNAL select() column table option
-    - added EXPERIMETNAL select() column all option
-    - removed EXPERIMETNAL select() all_column option
-    - removed EXPERIMENTAL view()
+  - added EXPERIMENTAL DBIx::Custom::Model table_alias attribute
+  - added EXPERIMENTAL DBIx::Custom::Model mycolumn()
+  - added EXPERIMENTAL DBIx::Custom::Model column()
+  - fixed autoloading bug
+  - added EXPERIMETNAL select() prepend table option
+  - added EXPERIMETNAL select() column table option
+  - added EXPERIMETNAL select() column all option
+  - removed EXPERIMETNAL select() all_column option
+  - removed EXPERIMENTAL view()
 0.1660
-    - added EXPERIMENTAL DBIx::Custom::Model view()
-    - added EXPERIMENTAL view()
-    - DBIx::Custom::Model inherit DBIx::Custom
-    - removed EXPERIMETNAL DBIx::Custom::Model method()
-    - added table choice feature to select() EXPERIMENTAL all_column option 
-    - removed EXPERIMENTAL DBIx::Custom::Model column attribute for side effect
+  - added EXPERIMENTAL DBIx::Custom::Model view()
+  - added EXPERIMENTAL view()
+  - DBIx::Custom::Model inherit DBIx::Custom
+  - removed EXPERIMETNAL DBIx::Custom::Model method()
+  - added table choice feature to select() EXPERIMENTAL all_column option 
+  - removed EXPERIMENTAL DBIx::Custom::Model column attribute for side effect
 0.1659
-    - EXPERIMETAL fork safety implementaion.
-    - removed EXPERIMENTAL selection
-    - added select() all_column option
+  - EXPERIMETAL fork safety implementaion.
+  - removed EXPERIMENTAL selection
+  - added select() all_column option
 0.1658
-    - added EXPERIMENTAL DBIx::Custom::Model column() prefix option.
-    - fixed select_at join column invalid bug
-    - added DBIx::Custom::Model column() attribute 
+  - added EXPERIMENTAL DBIx::Custom::Model column() prefix option.
+  - fixed select_at join column invalid bug
+  - added DBIx::Custom::Model column() attribute 
 0.1657
-    - remaned EXPERIMENTAL safty_charcter to safty_name
-    - safty_charcter is changed, set only one character regex.
+  - remaned EXPERIMENTAL safty_charcter to safty_name
+  - safty_charcter is changed, set only one character regex.
 0.1656
-    - fixed some select() join opition bug
+  - fixed some select() join opition bug
 0.1655
-    - added EXPERIMENTAL DBIx::Custom::Model join attribute
-    - added EXPERIMENTAL select() join option
-    - deprecated select() relation option
-    - added EXPERIMENTAL update_param and insert_param
-    - remove EXPERIMENTAL DBIx::Custom::Model relation
+  - added EXPERIMENTAL DBIx::Custom::Model join attribute
+  - added EXPERIMENTAL select() join option
+  - deprecated select() relation option
+  - added EXPERIMENTAL update_param and insert_param
+  - remove EXPERIMENTAL DBIx::Custom::Model relation
 0.1654
-    - selection can contain where clause.
+  - selection can contain where clause.
 0.1653
-    - added EXPERIMENTAL DBIx::Custom::Result remove_filter()
-    - added EXPERIMENTAL DBIx::Custom::Result remove_end_filter()
-    - added EXPERIMENTAL DBIx::Custom::Model insert_at()
-    - added EXPERIMENTAL insert_at()
-    - improved error message
+  - added EXPERIMENTAL DBIx::Custom::Result remove_filter()
+  - added EXPERIMENTAL DBIx::Custom::Result remove_end_filter()
+  - added EXPERIMENTAL DBIx::Custom::Model insert_at()
+  - added EXPERIMENTAL insert_at()
+  - improved error message
 0.1652
-    - all filter can receive array reference and receiving hash reference is DEPRECATED!
+  - all filter can receive array reference and receiving hash reference is DEPRECATED!
 0.1651
-    - add EXPERIMENTAL DBIx::Custom::Model filter attribute.
+  - add EXPERIMENTAL DBIx::Custom::Model filter attribute.
 0.1650
-    - add EXPERIMENTAL DBIx::Custom::Model name() attribute
+  - add EXPERIMENTAL DBIx::Custom::Model name() attribute
 0.1649
-    - add EXPERIMENTAL DBIx::Custom::Model column_clause() method.
-    - select method column option can receive string.
-    - DBIx::Custom::Model select() and select_at() think about relation attirbute
+  - add EXPERIMENTAL DBIx::Custom::Model column_clause() method.
+  - select method column option can receive string.
+  - DBIx::Custom::Model select() and select_at() think about relation attirbute
 0.1648
-    - add EXPERIMENTAL DBIx::Custom::Model relation() attribute
-    - add EXPERIMENTAL update_at(), delete_at(), select_at()
-    - add EXPERIMENTAL setup_model()
-    - add EXPERIMENTAL DBIx::Custom::Model columns attirbute
-    - add EXPERIMENTAL DBIx::Custom::Model foreign_key() attribute 
-    - add EXPERIMENTAL models() attribute
+  - add EXPERIMENTAL DBIx::Custom::Model relation() attribute
+  - add EXPERIMENTAL update_at(), delete_at(), select_at()
+  - add EXPERIMENTAL setup_model()
+  - add EXPERIMENTAL DBIx::Custom::Model columns attirbute
+  - add EXPERIMENTAL DBIx::Custom::Model foreign_key() attribute 
+  - add EXPERIMENTAL models() attribute
 0.1647
-    - add default_dbi_option()
+  - add default_dbi_option()
 0.1646
-    - add feture. all model class in namespace is included by include_model
-    - rename EXPERIMENTAL include_table to include_model
-    - rename EXPERIMENTAL table to model
-    - rename EXPERIMENTAL DBIx::Custom::Table to DBIx::Custom::Model
-    - remame EXPERIMENTAL DBIx::Custom::Table::name() to DBIx::Custom::Model::table();
+  - add feture. all model class in namespace is included by include_model
+  - rename EXPERIMENTAL include_table to include_model
+  - rename EXPERIMENTAL table to model
+  - rename EXPERIMENTAL DBIx::Custom::Table to DBIx::Custom::Model
+  - remame EXPERIMENTAL DBIx::Custom::Table::name() to DBIx::Custom::Model::table();
 0.1645
-    - removed EXPERIMENTAL base_table() for class expandability.
-    - EXPERIMENTAL table() can't set table object any more.
-    - added EXPERIMENTAL include_table().
+  - removed EXPERIMENTAL base_table() for class expandability.
+  - EXPERIMENTAL table() can't set table object any more.
+  - added EXPERIMENTAL include_table().
 0.1644
-    - update pod
+  - update pod
 0.1643
-    - add EXPERIMENTAL selection option to select()
-    - add EXPERIMENTAL table tag
-    - fix bug : filter can't overwirite undef value.
-    - add EXPERIMENTAL feature to apply_filter(). you can apply end filter.
-    - add EXPERIMENTAL feature to apply_filter(). TABLE__COLUMN is filterded now.
+  - add EXPERIMENTAL selection option to select()
+  - add EXPERIMENTAL table tag
+  - fix bug : filter can't overwirite undef value.
+  - add EXPERIMENTAL feature to apply_filter(). you can apply end filter.
+  - add EXPERIMENTAL feature to apply_filter(). TABLE__COLUMN is filterded now.
 0.1642
-    - removed EXPERIMENTAL DBIx::Custom::Table base() method
-    - table created by tabled method can call base_$method correponding to base_table's one
+  - removed EXPERIMENTAL DBIx::Custom::Table base() method
+  - table created by tabled method can call base_$method correponding to base_table's one
 0.1641
-    - select() where can't receive array reference to prevend SQL injection easily(not backward compatible. sorry. use where() instead)
-    - added EXPERIMENTAL safety_column_name attribute
-    - fix SQL injection security hole about column name
+  - select() where can't receive array reference to prevend SQL injection easily(not backward compatible. sorry. use where() instead)
+  - added EXPERIMENTAL safety_column_name attribute
+  - fix SQL injection security hole about column name
 0.1640
-    - autoload DBI method
-    - removed EXPERIMENTAL expand
+  - autoload DBI method
+  - removed EXPERIMENTAL expand
 0.1639
-    - improved delete() and update() where option. you can use DBIx::Custom::Where object
-    - added EXPERIMENTAL not_exists()
+  - improved delete() and update() where option. you can use DBIx::Custom::Where object
+  - added EXPERIMENTAL not_exists()
 0.1638
-    - table object call dbi object method if not found method.
-    - added EXPERIMENTAL base_table attribute and removed EXPERIMENTAL table_class attribute
-    - renamed helper to method.
-    - added EXPERIMENTAL DBIx::Custom::Result::stash()
-    - renamed EXPERIMENTAL DBIx::Custom::Table helper to method
+  - table object call dbi object method if not found method.
+  - added EXPERIMENTAL base_table attribute and removed EXPERIMENTAL table_class attribute
+  - renamed helper to method.
+  - added EXPERIMENTAL DBIx::Custom::Result::stash()
+  - renamed EXPERIMENTAL DBIx::Custom::Table helper to method
 0.1637
-    - renamed dbi_options to dbi_option. dbi_options is available, but deprecated.
-    - renamed DBIx::Custom::TagProcessor to DBIx::Custom::Tag, and function names is cleanuped.
-    - renamed register_tag_processor to register_tag. register_tag_processor is available, but deprecated.
-    - renamed tag_processors to tags. tag_prosessors is available, but deprecated.
-    - improved error message
-    - build all clause if param is undefined.
-    - each_column callback receive self as first argument.
-    - removed EXPERIMENTAL txn_scope
+  - renamed dbi_options to dbi_option. dbi_options is available, but deprecated.
+  - renamed DBIx::Custom::TagProcessor to DBIx::Custom::Tag, and function names is cleanuped.
+  - renamed register_tag_processor to register_tag. register_tag_processor is available, but deprecated.
+  - renamed tag_processors to tags. tag_prosessors is available, but deprecated.
+  - improved error message
+  - build all clause if param is undefined.
+  - each_column callback receive self as first argument.
+  - removed EXPERIMENTAL txn_scope
 0.1636
-    - added tests and cleanup
+  - added tests and cleanup
 0.1635
-    - renamed iterate_all_columns to each_column
+  - renamed iterate_all_columns to each_column
 0.1634
-    - became more useful where method
-    - changed DBIx::Custom::Where greatly
+  - became more useful where method
+  - changed DBIx::Custom::Where greatly
 0.1633
-    - fixed test
+  - fixed test
 0.1632
-    - added EXPERIMENTAL where method
-    - added EXPERIMENTAL DBIx::Custom::Where.
-    - removed DBIx::Custom::Or
+  - added EXPERIMENTAL where method
+  - added EXPERIMENTAL DBIx::Custom::Where.
+  - removed DBIx::Custom::Or
 0.1631
-    - added EXPERIMENTAL DBIx::Custom::Result end_filter method
-    - EXPERIMENTAL extended select method's where option
-    - fix select method empty where failed bug
-    - added EXPERIMENTAL suger method query option
-    - added EXPERIMENTAL or method
+  - added EXPERIMENTAL DBIx::Custom::Result end_filter method
+  - EXPERIMENTAL extended select method's where option
+  - fix select method empty where failed bug
+  - added EXPERIMENTAL suger method query option
+  - added EXPERIMENTAL or method
 0.1630
-    - fix test bug
+  - fix test bug
 0.1629
-    - renamed auto_filter to apply_filter
-    - changed apply_filter method arguments
-    - deprecated cache_method
+  - renamed auto_filter to apply_filter
+  - changed apply_filter method arguments
+  - deprecated cache_method
 0.1628
-    - remove DBIx::Custom::Model
-    - move table method and table_class attribute to DBIx::Custom
-    - added examples
-    - fixed connect method bug
+  - remove DBIx::Custom::Model
+  - move table method and table_class attribute to DBIx::Custom
+  - added examples
+  - fixed connect method bug
 0.1627
-    - added insert, update, update_all, delete, delete_all, select method to DBIx::Custom::Table
-    - added EXPERIMENTAL txn_scope
+  - added insert, update, update_all, delete, delete_all, select method to DBIx::Custom::Table
+  - added EXPERIMENTAL txn_scope
 0.1626
-    - simplified DBIx::Custom::Model and DBIx::Custom::Table
+  - simplified DBIx::Custom::Model and DBIx::Custom::Table
 0.1625
-    - added EXPERIMENTAL DBIx::Custom::Model and DBIx::Custom::Table
+  - added EXPERIMENTAL DBIx::Custom::Model and DBIx::Custom::Table
 0.1624
-    - added EXPERIMENTAL iterate_all_columns method.
+  - added EXPERIMENTAL iterate_all_columns method.
 0.1623
-    - added EXPERIMENTAL auto_filter method
-    - deprecated default_bind_filter and default_fetch_filter because these are global effect.
-    - changed defautl_bind_filter and default_fetch_filter attributes to methods.
-    - changed DBIx::Custom::Result default_filter attribute to method
-    - changed DBIx::Custom::Result filter attribute to method.
-    - filter_check is always done for usability
+  - added EXPERIMENTAL auto_filter method
+  - deprecated default_bind_filter and default_fetch_filter because these are global effect.
+  - changed defautl_bind_filter and default_fetch_filter attributes to methods.
+  - changed DBIx::Custom::Result default_filter attribute to method
+  - changed DBIx::Custom::Result filter attribute to method.
+  - filter_check is always done for usability
 0.1622
-    - deprecated DBIx::Custom::SQLite and DBIx::Custom::MySQL
-    - added dbi_options attribute
-    - checked attributes passed to connect method
+  - deprecated DBIx::Custom::SQLite and DBIx::Custom::MySQL
+  - added dbi_options attribute
+  - checked attributes passed to connect method
 0.1621
-    - cleanup (removed undocumented features)
+  - cleanup (removed undocumented features)
 0.1620
-    - updated document
+  - updated document
 0.1619
-    - updated document
-    - added EXPERIMENTAL expand method
+  - updated document
+  - added EXPERIMENTAL expand method
 0.1618
-    - added helper method
-    - added begin_work, commit, and rollback method
+  - added helper method
+  - added begin_work, commit, and rollback method
 0.1617
-    - L<DBIx::Custom> is now stable. APIs keep backword compatible in the feature.
+  - L<DBIx::Custom> is now stable. APIs keep backword compatible in the feature.
 0.1616
-    - removed EXPERIMENTAL register_method(), and methods attribute, because it is too magical
+  - removed EXPERIMENTAL register_method(), and methods attribute, because it is too magical
 0.1615
-    - fixed DBIx::Custom::QueryBuilder build_query() bug
-    - required Perl 5.008001 to use @CARP_NOT 
+  - fixed DBIx::Custom::QueryBuilder build_query() bug
+  - required Perl 5.008001 to use @CARP_NOT 
 0.1614
-    - removed DBIx::Custom::Query start_tag and end tag attributes
-    - enable escaping '{' and '}' in the source of SQL
-    - fixed Carp Carp trust relationship
+  - removed DBIx::Custom::Query start_tag and end tag attributes
+  - enable escaping '{' and '}' in the source of SQL
+  - fixed Carp Carp trust relationship
 0.1613
-    - added EXPERIMENTAL register_method() method
-    - added EXPERIMENTAL methods attribute
+  - added EXPERIMENTAL register_method() method
+  - added EXPERIMENTAL methods attribute
 0.1612
-    - added tests
-    - updated document
-    - removed DBIx::Custom::SQLite last_insert_rawid() mehtod(not backword compatible)
-    - removed DBIx::Custom::MySQL last_insert_id() method(not backword compatible)
+  - added tests
+  - updated document
+  - removed DBIx::Custom::SQLite last_insert_rawid() mehtod(not backword compatible)
+  - removed DBIx::Custom::MySQL last_insert_id() method(not backword compatible)
 0.1611
-    - renamed update tag to update_param
-    - renamed insert tag to insert_param
-    - renamed sql_builder to query_builder
+  - renamed update tag to update_param
+  - renamed insert tag to insert_param
+  - renamed sql_builder to query_builder
 0.1610
-    - added filter_check attribute.
+  - added filter_check attribute.
 0.1609
-    - updated document.
+  - updated document.
 0.1608
-    - update document
-    - renamed DBIx::Custom::QueryBuilder::TagProcessors functions(not backword compatible)
+  - update document
+  - renamed DBIx::Custom::QueryBuilder::TagProcessors functions(not backword compatible)
 0.1607
-    - where argument of select() method can specify array(string, parameters)
-    - renamed build_query() to create_query()(not backword compatible)
+  - where argument of select() method can specify array(string, parameters)
+  - renamed build_query() to create_query()(not backword compatible)
 0.1606
-    - fix testing bug
+  - fix testing bug
 0.1605
-    - remove DBIx::Custom::QueryBuilder::tag_syntax()  (not backword compatible)
-    - renamed DBIx::Custom::TagProcessor to DBIx::Custom::TagProcessors (not backword compatible)
-    - changed arguments of tag processor(not backword compatible)
-    - renamed DBIx::Custom::QueryBuilder::TagProcessors functions(not backword compatible)
+  - remove DBIx::Custom::QueryBuilder::tag_syntax()  (not backword compatible)
+  - renamed DBIx::Custom::TagProcessor to DBIx::Custom::TagProcessors (not backword compatible)
+  - changed arguments of tag processor(not backword compatible)
+  - renamed DBIx::Custom::QueryBuilder::TagProcessors functions(not backword compatible)
 0.1604
-    - changed argument of tag processor(not backword compatible)
-    - 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
+  - changed argument of tag processor(not backword compatible)
+  - 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
 0.1603
-    - removed DBIx::Custom commit method (not backword compatible)
-    - removed DBIx::Custom rollback method (not backword compatible)
-    - removed DBIx::Custom auto_commit method (not backword compatible)
+  - removed DBIx::Custom commit method (not backword compatible)
+  - removed DBIx::Custom rollback method (not backword compatible)
+  - removed DBIx::Custom auto_commit method (not backword compatible)
 0.1602
-    - added cache_method attribute
+  - added cache_method attribute
 0.1601
-    - added cache attribute
-    - select, insert, update, update_all, delete, delete_all, execute only receive hash argument(not backword compatible)
+  - added cache attribute
+  - select, insert, update, update_all, delete, delete_all, execute only receive hash argument(not backword compatible)
 0.1503
-    - removed reconnect method
-    - removed connected method
-    - removed reconnect_memroy method
-    - renamed fetch_single to fetch_first
-    - renamed fetch_hash_single to fetch_hash_first
-    - updated document
+  - removed reconnect method
+  - removed connected method
+  - removed reconnect_memroy method
+  - renamed fetch_single to fetch_first
+  - renamed fetch_hash_single to fetch_hash_first
+  - updated document
 0.1502
-    - added commit method
-    - added rollback method
-    - changed select argument, added relation option
-    - moved host attribute to DBIx::Custom::MySQL
-    - moved port attribute to DBIx::Custom::MySQL
-    - moved database attribute to DBIx::Custom::MySQL and DBIx::Custom::SQLite
+  - added commit method
+  - added rollback method
+  - changed select argument, added relation option
+  - moved host attribute to DBIx::Custom::MySQL
+  - moved port attribute to DBIx::Custom::MySQL
+  - moved database attribute to DBIx::Custom::MySQL and DBIx::Custom::SQLite
 0.1501
-    - removed register_format()
-    - removed formats()
-    - removed run_transaction()
-    - removed create_table()
-    - removed drop_table()
-    - changed select() arguments
-    - changed insert() arguments
-    - changed update() arguments
-    - changed update_all() arguments
-    - changed delete() arguments
-    - changed delete_all() arguments
-    - changed execute() arguments
+  - removed register_format()
+  - removed formats()
+  - removed run_transaction()
+  - removed create_table()
+  - removed drop_table()
+  - changed select() arguments
+  - changed insert() arguments
+  - changed update() arguments
+  - changed update_all() arguments
+  - changed delete() arguments
+  - changed delete_all() arguments
+  - changed execute() arguments
 0.1402
-    - remove finish(), error()
-    - can receive code ref to filter()
-    - renamed resist to register
+  - remove finish(), error()
+  - can receive code ref to filter()
+  - renamed resist to register
 0.1401
-    - renamed fetch_rows to fetch_multi
-    - renamed fetch_hash_rows to fetch_hash_multi
+  - renamed fetch_rows to fetch_multi
+  - renamed fetch_hash_rows to fetch_hash_multi
 0.1301
-    - Changed many(not backword compatible)
+  - Changed many(not backword compatible)
 0.1201
-    - Changed many(not backword compatible)
+  - Changed many(not backword compatible)
 0.1101
-    - rename DBIx::Custom::SQLite last_insert_id to last_insert_rowid
+  - rename DBIx::Custom::SQLite last_insert_id to last_insert_rowid
 0.1001
-    - remove run_transaction().
-    - add transaction() and DBIx::Custom::Transaction
-    - rename fetch_first to fetch_single
-    - rename fetch_hash_first to fetch_hash_single
+  - remove run_transaction().
+  - add transaction() and DBIx::Custom::Transaction
+  - rename fetch_first to fetch_single
+  - rename fetch_hash_first to fetch_hash_single
 0.0906
-    - fix some bug
+  - fix some bug
 0.0905
-    - catch up with Object::Simple update
+  - catch up with Object::Simple update
 0.0904
-    - cleanup
+  - cleanup
 0.0903
-    - catch up with Object::Simple update
+  - catch up with Object::Simple update
 0.0902
-    - cleanup
+  - cleanup
 0.0901
-    - DBIx::Basic filter 'encode_utf8' utf8::upgrade process is deleted
+  - DBIx::Basic filter 'encode_utf8' utf8::upgrade process is deleted
 0.0801
-    - add 'create_table', 'drop_table' methods
+  - add 'create_table', 'drop_table' methods
 0.0701
-    - rename sql_template to sql_tmpl (not backword compatible)
-    - rename dbi_options to options (not backword compatible)
+  - rename sql_template to sql_tmpl (not backword compatible)
+  - rename dbi_options to options (not backword compatible)
 0.0605
-    - fix encode_utf8 filter
+  - fix encode_utf8 filter
 0.0604
-    - fix timeformat tests
+  - fix timeformat tests
 0.0603
-    - fix cache system bug
+  - fix cache system bug
 0.0602
-    - update document
+  - update document
 0.0601
-    - bind_filter argument is changed to ($value, $key, $dbi, $infos) (not backword compatible)
-    - fetch_filter argument is changed to ($value, $key, $dbi, $infos) (not backword compatible)
-    - run_transaction argument is changed to ($dbi)
+  - bind_filter argument is changed to ($value, $key, $dbi, $infos) (not backword compatible)
+  - fetch_filter argument is changed to ($value, $key, $dbi, $infos) (not backword compatible)
+  - run_transaction argument is changed to ($dbi)
 0.0502
-    - update document
+  - update document
 0.0501
-    - packaging DBIx::Custom::Result DBIx::Custom::Query DBIx::Custom::MySQL DBIx::Custom::SQLite DBIx::Custom::SQL::Template 
+  - packaging DBIx::Custom::Result DBIx::Custom::Query DBIx::Custom::MySQL DBIx::Custom::SQLite DBIx::Custom::SQL::Template 
 0.0401
-    - catch up with DBIx::Custom::Result version up
+  - catch up with DBIx::Custom::Result version up
 0.0301
-    - exchange filter argument 'key', 'value' (not backword compatible)
+  - exchange filter argument 'key', 'value' (not backword compatible)
 0.0201
-    - rename tranzaction to transaction
-    - add filter_off
+  - rename tranzaction to transaction
+  - add filter_off
 0.0101
-    - First release
+  - First release

+2340 -2370

lib/DBIx/Custom.pm

View

@@ -21,235 +21,229 @@ use Scalar::Util qw/weaken/;
 
 
 has [qw/connector dsn password quote user exclude_table user_table_info
-        user_column_info safety_character/],
-    cache => 0,
-    cache_method => sub {
-        sub {
-            my $self = shift;
-            
-            $self->{_cached} ||= {};
-            
-            if (@_ > 1) {
-                $self->{_cached}{$_[0]} = $_[1];
-            }
-            else {
-                return $self->{_cached}{$_[0]};
-            }
-        }
-    },
-    option => sub { {} },
-    default_option => sub {
-        {
-            RaiseError => 1,
-            PrintError => 0,
-            AutoCommit => 1
-        }
-    },
-    filters => sub {
-        {
-            encode_utf8 => sub { encode_utf8($_[0]) },
-            decode_utf8 => sub { decode_utf8($_[0]) }
-        }
-    },
-    last_sql => '',
-    models => sub { {} },
-    now => sub {
-        sub {
-            my ($sec, $min, $hour, $mday, $mon, $year) = localtime;
-            $mon++;
-            $year += 1900;
-            my $now = sprintf("%04d-%02d-%02d %02d:%02d:%02d",
-              $year, $mon, $mday, $hour, $min, $sec);
-            return $now;
-        }
-    },
-    query_builder => sub {
-        my $self = shift;
-        my $builder = DBIx::Custom::QueryBuilder->new(dbi => $self);
-        weaken $builder->{dbi};
-        return $builder;
-    },
-    result_class  => 'DBIx::Custom::Result',
-    separator => '.',
-    stash => sub { {} };
+     user_column_info safety_character/],
+  cache => 0,
+  cache_method => sub {
+    sub {
+      my $self = shift;
+      $self->{_cached} ||= {};
+      if (@_ > 1) { $self->{_cached}{$_[0]} = $_[1] }
+      else { return $self->{_cached}{$_[0]} }
+    }
+  },
+  option => sub { {} },
+  default_option => sub {
+    {
+      RaiseError => 1,
+      PrintError => 0,
+      AutoCommit => 1
+    }
+  },
+  filters => sub {
+    {
+      encode_utf8 => sub { encode_utf8($_[0]) },
+      decode_utf8 => sub { decode_utf8($_[0]) }
+    }
+  },
+  last_sql => '',
+  models => sub { {} },
+  now => sub {
+    sub {
+      my ($sec, $min, $hour, $mday, $mon, $year) = localtime;
+      $mon++;
+      $year += 1900;
+      my $now = sprintf("%04d-%02d-%02d %02d:%02d:%02d",
+        $year, $mon, $mday, $hour, $min, $sec);
+      return $now;
+    }
+  },
+  query_builder => sub {
+    my $self = shift;
+    my $builder = DBIx::Custom::QueryBuilder->new(dbi => $self);
+    weaken $builder->{dbi};
+    return $builder;
+  },
+  result_class  => 'DBIx::Custom::Result',
+  separator => '.',
+  stash => sub { {} };
 
 sub available_datatype {
-    my $self = shift;
-    
-    my $data_types = '';
-    for my $i (-1000 .. 1000) {
-         my $type_info = $self->dbh->type_info($i);
-         my $data_type = $type_info->{DATA_TYPE};
-         my $type_name = $type_info->{TYPE_NAME};
-         $data_types .= "$data_type ($type_name)\n"
-           if defined $data_type;
-    }
-    return "Data Type maybe equal to Type Name" unless $data_types;
-    $data_types = "Data Type (Type name)\n" . $data_types;
-    return $data_types;
+  my $self = shift;
+  
+  my $data_types = '';
+  for my $i (-1000 .. 1000) {
+     my $type_info = $self->dbh->type_info($i);
+     my $data_type = $type_info->{DATA_TYPE};
+     my $type_name = $type_info->{TYPE_NAME};
+     $data_types .= "$data_type ($type_name)\n"
+       if defined $data_type;
+  }
+  return "Data Type maybe equal to Type Name" unless $data_types;
+  $data_types = "Data Type (Type name)\n" . $data_types;
+  return $data_types;
 }
 
 sub available_typename {
-    my $self = shift;
-    
-    # Type Names
-    my $type_names = {};
-    $self->each_column(sub {
-        my ($self, $table, $column, $column_info) = @_;
-        $type_names->{$column_info->{TYPE_NAME}} = 1
-          if $column_info->{TYPE_NAME};
-    });
-    my @output = sort keys %$type_names;
-    unshift @output, "Type Name";
-    return join "\n", @output;
+  my $self = shift;
+  
+  # Type Names
+  my $type_names = {};
+  $self->each_column(sub {
+    my ($self, $table, $column, $column_info) = @_;
+    $type_names->{$column_info->{TYPE_NAME}} = 1
+      if $column_info->{TYPE_NAME};
+  });
+  my @output = sort keys %$type_names;
+  unshift @output, "Type Name";
+  return join "\n", @output;
 }
 
 our $AUTOLOAD;
 sub AUTOLOAD {
-    my $self = shift;
+  my $self = shift;
 
-    # Method name
-    my ($package, $mname) = $AUTOLOAD =~ /^([\w\:]+)\:\:(\w+)$/;
+  # Method name
+  my ($package, $mname) = $AUTOLOAD =~ /^([\w\:]+)\:\:(\w+)$/;
 
-    # Call method
-    $self->{_methods} ||= {};
-    if (my $method = $self->{_methods}->{$mname}) {
-        return $self->$method(@_)
-    }
-    elsif ($self->{dbh} && (my $dbh_method = $self->dbh->can($mname))) {
-        $self->dbh->$dbh_method(@_);
-    }
-    else {
-        croak qq{Can't locate object method "$mname" via "$package" }
-            . _subname;
-    }
+  # Call method
+  $self->{_methods} ||= {};
+  if (my $method = $self->{_methods}->{$mname}) {
+    return $self->$method(@_)
+  }
+  elsif ($self->{dbh} && (my $dbh_method = $self->dbh->can($mname))) {
+    $self->dbh->$dbh_method(@_);
+  }
+  else {
+    croak qq{Can't locate object method "$mname" via "$package" }
+      . _subname;
+  }
 }
 
 sub assign_clause {
-    my ($self, $param, $opts) = @_;
-    
-    my $wrap = $opts->{wrap} || {};
-    my ($q, $p) = split //, $self->q('');
-    
-    # Assign clause (performance is important)
-    join(
-      ', ',
-      map {
-          ref $param->{$_} eq 'SCALAR' ? "$q$_$p = " . ${$param->{$_}}
-          : $wrap->{$_} ? "$q$_$p = " . $wrap->{$_}->(":$_")
-          : "$q$_$p = :$_";
-      } sort keys %$param
-    );
+  my ($self, $param, $opts) = @_;
+  
+  my $wrap = $opts->{wrap} || {};
+  my ($q, $p) = split //, $self->q('');
+  
+  # Assign clause (performance is important)
+  join(
+    ', ',
+    map {
+      ref $param->{$_} eq 'SCALAR' ? "$q$_$p = " . ${$param->{$_}}
+      : $wrap->{$_} ? "$q$_$p = " . $wrap->{$_}->(":$_")
+      : "$q$_$p = :$_";
+    } sort keys %$param
+  );
 }
 
 sub column {
-    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 (defined $columns) {
-        $columns ||= $self->model($real_table)->columns;
-    }
-    
-    # Separator
-    my $separator = $self->separator;
-    
-    # Column clause
-    my @column;
-    $columns ||= [];
-    push @column, $self->q($table) . "." . $self->q($_) .
-      " as " . $self->q("${table}${separator}$_")
-      for @$columns;
-    
-    return join (', ', @column);
+  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 (defined $columns) {
+    $columns ||= $self->model($real_table)->columns;
+  }
+  
+  # Separator
+  my $separator = $self->separator;
+  
+  # Column clause
+  my @column;
+  $columns ||= [];
+  push @column, $self->q($table) . "." . $self->q($_) .
+    " as " . $self->q("${table}${separator}$_")
+    for @$columns;
+  
+  return join (', ', @column);
 }
 
 sub connect {
-    my $self = ref $_[0] ? shift : shift->new(@_);
-    
-    my $connector = $self->connector;
-    
-    if (!ref $connector && $connector) {
-        require DBIx::Connector;
-        
-        my $dsn = $self->dsn;
-        my $user = $self->user;
-        my $password = $self->password;
-        my $option = $self->_option;
-        my $connector = DBIx::Connector->new($dsn, $user, $password,
-          {%{$self->default_option} , %$option});
-        $self->connector($connector);
-    }
-    
-    # Connect
-    $self->dbh;
-    
-    return $self;
+  my $self = ref $_[0] ? shift : shift->new(@_);
+  
+  my $connector = $self->connector;
+  
+  if (!ref $connector && $connector) {
+    require DBIx::Connector;
+    
+    my $dsn = $self->dsn;
+    my $user = $self->user;
+    my $password = $self->password;
+    my $option = $self->_option;
+    my $connector = DBIx::Connector->new($dsn, $user, $password,
+      {%{$self->default_option} , %$option});
+    $self->connector($connector);
+  }
+  
+  # Connect
+  $self->dbh;
+  
+  return $self;
 }
 
 sub count { shift->select(column => 'count(*)', @_)->fetch_one->[0] }
 
 sub dbh {
-    my $self = shift;
+  my $self = shift;
+  
+  # Set
+  if (@_) {
+    $self->{dbh} = $_[0];
     
-    # Set
-    if (@_) {
-        $self->{dbh} = $_[0];
+    return $self;
+  }
+  
+  # Get
+  else {
+    # From Connction manager
+    if (my $connector = $self->connector) {
+      croak "connector must have dbh() method " . _subname
+        unless ref $connector && $connector->can('dbh');
         
-        return $self;
+      $self->{dbh} = $connector->dbh;
     }
     
-    # Get
-    else {
-        # From Connction manager
-        if (my $connector = $self->connector) {
-            croak "connector must have dbh() method " . _subname
-              unless ref $connector && $connector->can('dbh');
-              
-            $self->{dbh} = $connector->dbh;
-        }
-        
-        # Connect
-        $self->{dbh} ||= $self->_connect;
-        
-        # Quote
-        if (!defined $self->reserved_word_quote && !defined $self->quote) {
-            my $driver = $self->_driver;
-            my $quote =  $driver eq 'odbc' ? '[]'
-                       : $driver eq 'ado' ? '[]'
-                       : $driver eq 'mysql' ? '`'
-                       : '"';
-            $self->quote($quote);
-        }
-        
-        return $self->{dbh};
+    # Connect
+    $self->{dbh} ||= $self->_connect;
+    
+    # Quote
+    if (!defined $self->reserved_word_quote && !defined $self->quote) {
+      my $driver = $self->_driver;
+      my $quote =  $driver eq 'odbc' ? '[]'
+        : $driver eq 'ado' ? '[]'
+        : $driver eq 'mysql' ? '`'
+        : '"';
+      $self->quote($quote);
     }
+    
+    return $self->{dbh};
+  }
 }
 
 sub delete {
-    my ($self, %opt) = @_;
-    warn "delete method where_param option is DEPRECATED!"
-      if $opt{where_param};
-    
-    # Don't allow delete all rows
-    croak qq{delete method where or id option must be specified } . _subname
-      if !$opt{where} && !defined $opt{id} && !$opt{allow_delete_all};
-    
-    # Where
-    my $w = $self->_where_clause_and_param($opt{where}, $opt{where_param},
-      delete $opt{id}, $opt{primary_key}, $opt{table});
-
-    # Delete statement
-    my $sql = "delete ";
-    $sql .= "$opt{prefix} " if defined $opt{prefix};
-    $sql .= "from " . $self->q($opt{table}) . " $w->{clause} ";
-    
-    # Execute query
-    $opt{statement} = 'delete';
-    $self->execute($sql, $w->{param}, %opt);
+  my ($self, %opt) = @_;
+  warn "delete method where_param option is DEPRECATED!"
+    if $opt{where_param};
+  
+  # Don't allow delete all rows
+  croak qq{delete method where or id option must be specified } . _subname
+    if !$opt{where} && !defined $opt{id} && !$opt{allow_delete_all};
+  
+  # Where
+  my $w = $self->_where_clause_and_param($opt{where}, $opt{where_param},
+    delete $opt{id}, $opt{primary_key}, $opt{table});
+
+  # Delete statement
+  my $sql = "delete ";
+  $sql .= "$opt{prefix} " if defined $opt{prefix};
+  $sql .= "from " . $self->q($opt{table}) . " $w->{clause} ";
+  
+  # Execute query
+  $opt{statement} = 'delete';
+  $self->execute($sql, $w->{param}, %opt);
 }
 
 sub delete_all { shift->delete(@_, allow_delete_all => 1) }
@@ -257,1523 +251,1499 @@ sub delete_all { shift->delete(@_, allow_delete_all => 1) }
 sub DESTROY {}
 
 sub create_model {
-    my $self = shift;
-    
-    # Options
-    my $opt = ref $_[0] eq 'HASH' ? $_[0] : {@_};
-    $opt->{dbi} = $self;
-    my $model_class = delete $opt->{model_class} || 'DBIx::Custom::Model';
-    my $model_name  = delete $opt->{name};
-    my $model_table = delete $opt->{table};
-    $model_name ||= $model_table;
-    
-    # Create model
-    my $model = $model_class->new($opt);
-    weaken $model->{dbi};
-    $model->name($model_name) unless $model->name;
-    $model->table($model_table) unless $model->table;
-    
-    # Apply filter(DEPRECATED logic)
-    if ($model->{filter}) {
-        my $filter = ref $model->filter eq 'HASH'
-                   ? [%{$model->filter}]
-                   : $model->filter;
-        $filter ||= [];
-        warn "DBIx::Custom::Model filter method is DEPRECATED!"
-          if @$filter;
-        $self->_apply_filter($model->table, @$filter);
-    }
-    
-    # Set model
-    $self->model($model->name, $model);
-    
-    return $self->model($model->name);
+  my $self = shift;
+  
+  # Options
+  my $opt = ref $_[0] eq 'HASH' ? $_[0] : {@_};
+  $opt->{dbi} = $self;
+  my $model_class = delete $opt->{model_class} || 'DBIx::Custom::Model';
+  my $model_name  = delete $opt->{name};
+  my $model_table = delete $opt->{table};
+  $model_name ||= $model_table;
+  
+  # Create model
+  my $model = $model_class->new($opt);
+  weaken $model->{dbi};
+  $model->name($model_name) unless $model->name;
+  $model->table($model_table) unless $model->table;
+  
+  # Apply filter(DEPRECATED logic)
+  if ($model->{filter}) {
+    my $filter = ref $model->filter eq 'HASH'
+      ? [%{$model->filter}]
+      : $model->filter;
+    $filter ||= [];
+    warn "DBIx::Custom::Model filter method is DEPRECATED!"
+      if @$filter;
+    $self->_apply_filter($model->table, @$filter);
+  }
+  
+  # Set model
+  $self->model($model->name, $model);
+  
+  return $self->model($model->name);
 }
 
 sub each_column {
-    my ($self, $cb, %options) = @_;
+  my ($self, $cb, %options) = @_;
+
+  my $user_column_info = $self->user_column_info;
+  
+  if ($user_column_info) {
+    $self->$cb($_->{table}, $_->{column}, $_->{info}) for @$user_column_info;
+  }
+  else {
+    my $re = $self->exclude_table || $options{exclude_table};
+    # Tables
+    my %tables;
+    $self->each_table(sub { $tables{$_[1]}++ });
 
-    my $user_column_info = $self->user_column_info;
-    
-    if ($user_column_info) {
-        $self->$cb($_->{table}, $_->{column}, $_->{info}) for @$user_column_info;
-    }
-    else {
-    
-        my $re = $self->exclude_table || $options{exclude_table};
-        # Tables
-        my %tables;
-        $self->each_table(sub { $tables{$_[1]}++ });
-
-        # Iterate all tables
-        my @tables = sort keys %tables;
-        for (my $i = 0; $i < @tables; $i++) {
-            my $table = $tables[$i];
-            
-            # Iterate all columns
-            my $sth_columns;
-            eval {$sth_columns = $self->dbh->column_info(undef, undef, $table, '%')};
-            next if $@;
-            while (my $column_info = $sth_columns->fetchrow_hashref) {
-                my $column = $column_info->{COLUMN_NAME};
-                $self->$cb($table, $column, $column_info);
-            }
-        }
+    # Iterate all tables
+    my @tables = sort keys %tables;
+    for (my $i = 0; $i < @tables; $i++) {
+      my $table = $tables[$i];
+      
+      # Iterate all columns
+      my $sth_columns;
+      eval {$sth_columns = $self->dbh->column_info(undef, undef, $table, '%')};
+      next if $@;
+      while (my $column_info = $sth_columns->fetchrow_hashref) {
+        my $column = $column_info->{COLUMN_NAME};
+        $self->$cb($table, $column, $column_info);
+      }
     }
+  }
 }
 
 sub each_table {
-    my ($self, $cb, %option) = @_;
-    
-    my $user_table_infos = $self->user_table_info;
-    
-    # Iterate tables
-    if ($user_table_infos) {
-        $self->$cb($_->{table}, $_->{info}) for @$user_table_infos;
-    }
-    else {
-        my $re = $self->exclude_table || $option{exclude};
-        my $sth_tables = $self->dbh->table_info;
-        while (my $table_info = $sth_tables->fetchrow_hashref) {
-            
-            # Table
-            my $table = $table_info->{TABLE_NAME};
-            next if defined $re && $table =~ /$re/;
-            $self->$cb($table, $table_info);
-        }
-    }
+  my ($self, $cb, %option) = @_;
+  
+  my $user_table_infos = $self->user_table_info;
+  
+  # Iterate tables
+  if ($user_table_infos) {
+      $self->$cb($_->{table}, $_->{info}) for @$user_table_infos;
+  }
+  else {
+    my $re = $self->exclude_table || $option{exclude};
+    my $sth_tables = $self->dbh->table_info;
+    while (my $table_info = $sth_tables->fetchrow_hashref) {
+      # Table
+      my $table = $table_info->{TABLE_NAME};
+      next if defined $re && $table =~ /$re/;
+      $self->$cb($table, $table_info);
+    }
+  }
 }
 
 sub execute {
-    my $self = shift;
-    my $sql = shift;
-
-    # Options
-    my $params;
-    $params = shift if @_ % 2;
-    my %opt = @_;
-    warn "sqlfilter option is DEPRECATED" if $opt{sqlfilter};
-    $params ||= $opt{param} || {};
-    my $tables = $opt{table} || [];
-    $tables = [$tables] unless ref $tables eq 'ARRAY';
-    my $filter = ref $opt{filter} eq 'ARRAY' ?
-      _array_to_hash($opt{filter}) : $opt{filter};
-    
-    # Merge second parameter
-    my @cleanup;
-    my $saved_param;
-    if (($opt{statement} || '') ne 'insert' && ref $params eq 'ARRAY') {
-        my $params2 = $params->[1];
-        $params = $params->[0];
-        for my $column (keys %$params2) {
-            if (!exists $params->{$column}) {
-                $params->{$column} = $params2->{$column};
-                push @cleanup, $column;
-            }
-            else {
-                delete $params->{$_} for @cleanup;
-                @cleanup = ();
-                $saved_param  = $params;
-                $params = $self->merge_param($params, $params2);
-                delete $saved_param->{$_} for (@{$opt{cleanup} || []});
-                last;
-            }
-        }
-    }
-    $params = [$params] unless ref $params eq 'ARRAY';
-    
-    # Append
-    $sql .= $opt{append} if defined $opt{append} && !ref $sql;
-    
-    # Query
-    my $query;
-    if (ref $sql) {
-        $query = $sql;
-        warn "execute method receiving query object as first parameter is DEPRECATED!" .
-             "because this is very buggy.";
-    }
-    else {
-        $query = $opt{reuse}->{$sql} if $opt{reuse};
-        unless ($query) {
-            my $c = $self->{safety_character};
-            # Check unsafety keys
-            unless ((join('', keys %{$params->[0]}) || '') =~ /^[$c\.]+$/) {
-                for my $column (keys %{$params->[0]}) {
-                    croak qq{"$column" is not safety column name } . _subname
-                      unless $column =~ /^[$c\.]+$/;
-                }
-            }
-            $query = $self->_create_query($sql,$opt{after_build_sql} || $opt{sqlfilter});
+  my $self = shift;
+  my $sql = shift;
+
+  # Options
+  my $params;
+  $params = shift if @_ % 2;
+  my %opt = @_;
+  warn "sqlfilter option is DEPRECATED" if $opt{sqlfilter};
+  $params ||= $opt{param} || {};
+  my $tables = $opt{table} || [];
+  $tables = [$tables] unless ref $tables eq 'ARRAY';
+  my $filter = ref $opt{filter} eq 'ARRAY' ?
+    _array_to_hash($opt{filter}) : $opt{filter};
+  
+  # Merge second parameter
+  my @cleanup;
+  my $saved_param;
+  if (($opt{statement} || '') ne 'insert' && ref $params eq 'ARRAY') {
+    my $params2 = $params->[1];
+    $params = $params->[0];
+    for my $column (keys %$params2) {
+      if (!exists $params->{$column}) {
+        $params->{$column} = $params2->{$column};
+        push @cleanup, $column;
+      }
+      else {
+        delete $params->{$_} for @cleanup;
+        @cleanup = ();
+        $saved_param  = $params;
+        $params = $self->merge_param($params, $params2);
+        delete $saved_param->{$_} for (@{$opt{cleanup} || []});
+        last;
+      }
+    }
+  }
+  $params = [$params] unless ref $params eq 'ARRAY';
+  
+  # Append
+  $sql .= $opt{append} if defined $opt{append} && !ref $sql;
+  
+  # Query
+  my $query;
+  if (ref $sql) {
+    $query = $sql;
+    warn "execute method receiving query object as first parameter is DEPRECATED!" .
+      "because this is very buggy.";
+  }
+  else {
+    $query = $opt{reuse}->{$sql} if $opt{reuse};
+    unless ($query) {
+      my $c = $self->{safety_character};
+      # Check unsafety keys
+      unless ((join('', keys %{$params->[0]}) || '') =~ /^[$c\.]+$/) {
+        for my $column (keys %{$params->[0]}) {
+          croak qq{"$column" is not safety column name } . _subname
+            unless $column =~ /^[$c\.]+$/;
         }
-        $query->{statement} = $opt{statement} || '';
-        $opt{reuse}->{$sql} = $query if $opt{reuse};
+      }
+      $query = $self->_create_query($sql,$opt{after_build_sql} || $opt{sqlfilter});
+    }
+    $query->{statement} = $opt{statement} || '';
+    $opt{reuse}->{$sql} = $query if $opt{reuse};
+  }
+      
+  # Save query
+  $self->{last_sql} = $query->{sql};
+
+  # Return query
+  if ($opt{query}) {
+    for my $column (@cleanup, @{$opt{cleanup} || []}) {
+      delete $_->{$column} for @$params;
     }
-        
-    # Save query
-    $self->{last_sql} = $query->{sql};
-
-    # Return query
-    if ($opt{query}) {
-        for my $column (@cleanup, @{$opt{cleanup} || []}) {
-            delete $_->{$column} for @$params;
-        }
-        return $query;
+    return $query;
+  };
+  
+  # Merge query filter(DEPRECATED!)
+  $filter ||= $query->{filter} || {};
+  
+  # Tables
+  unshift @$tables, @{$query->{tables} || []};
+  my $main_table = @{$tables}[-1];
+
+  # Merge id to parameter
+  if (defined $opt{id}) {
+    my $statement = $query->{statement};
+    warn "execute method id option is DEPRECATED!" unless $statement;
+    croak "execute id option must be specified with primary_key option"
+      unless $opt{primary_key};
+    $opt{primary_key} = [$opt{primary_key}] unless ref $opt{primary_key};
+    $opt{id} = [$opt{id}] unless ref $opt{id};
+    for (my $i = 0; $i < @{$opt{id}}; $i++) {
+      my $key = $opt{primary_key}->[$i];
+      $key = "$main_table.$key" if $statement eq 'update' ||
+        $statement eq 'delete' || $statement eq 'select';
+      next if exists $params->[0]->{$key};
+      $params->[0]->{$key} = $opt{id}->[$i];
+      push @cleanup, $key;1
+    }
+  }
+  
+  # Cleanup tables(DEPRECATED!)
+  $tables = $self->_remove_duplicate_table($tables, $main_table)
+    if @$tables > 1;
+  
+  # Type rule
+  my $type_filters = {};
+  my $type_rule_off = !$self->{_type_rule_is_called} || $opt{type_rule_off};
+  unless ($type_rule_off) {
+    my $type_rule_off_parts = {
+      1 => $opt{type_rule1_off},
+      2 => $opt{type_rule2_off}
     };
-    
-    # Merge query filter(DEPRECATED!)
-    $filter ||= $query->{filter} || {};
-    
-    # Tables
-    unshift @$tables, @{$query->{tables} || []};
-    my $main_table = @{$tables}[-1];
-
-    # Merge id to parameter
-    if (defined $opt{id}) {
-        my $statement = $query->{statement};
-        warn "execute method id option is DEPRECATED!" unless $statement;
-        croak "execute id option must be specified with primary_key option"
-          unless $opt{primary_key};
-        $opt{primary_key} = [$opt{primary_key}] unless ref $opt{primary_key};
-        $opt{id} = [$opt{id}] unless ref $opt{id};
-        for (my $i = 0; $i < @{$opt{id}}; $i++) {
-           my $key = $opt{primary_key}->[$i];
-           $key = "$main_table.$key" if $statement eq 'update' ||
-             $statement eq 'delete' || $statement eq 'select';
-           next if exists $params->[0]->{$key};
-           $params->[0]->{$key} = $opt{id}->[$i];
-           push @cleanup, $key;1
+    for my $i (1, 2) {
+      unless ($type_rule_off_parts->{$i}) {
+        $type_filters->{$i} = {};
+        my $table_alias = $opt{table_alias} || {};
+        for my $alias (keys %$table_alias) {
+          my $table = $table_alias->{$alias};
+          
+          for my $column (keys %{$self->{"_into$i"}{key}{$table} || {}}) {
+            $type_filters->{$i}->{"$alias.$column"} = $self->{"_into$i"}{key}{$table}{$column};
+          }
         }
-    }
-    
-    # Cleanup tables(DEPRECATED!)
-    $tables = $self->_remove_duplicate_table($tables, $main_table)
-      if @$tables > 1;
-    
-    # Type rule
-    my $type_filters = {};
-    my $type_rule_off = !$self->{_type_rule_is_called} || $opt{type_rule_off};
-    unless ($type_rule_off) {
-        my $type_rule_off_parts = {
-            1 => $opt{type_rule1_off},
-            2 => $opt{type_rule2_off}
-        };
-        for my $i (1, 2) {
-            unless ($type_rule_off_parts->{$i}) {
-                $type_filters->{$i} = {};
-                my $table_alias = $opt{table_alias} || {};
-                for my $alias (keys %$table_alias) {
-                    my $table = $table_alias->{$alias};
-                    
-                    for my $column (keys %{$self->{"_into$i"}{key}{$table} || {}}) {
-                        $type_filters->{$i}->{"$alias.$column"} = $self->{"_into$i"}{key}{$table}{$column};
-                    }
-                }
-                $type_filters->{$i} = {%{$type_filters->{$i}}, %{$self->{"_into$i"}{key}{$main_table} || {}}}
-                  if $main_table;
-            }
-        }
-    }
-    
-    # Applied filter(DEPRECATED!)
-    if ($self->{filter}{on}) {
-        my $applied_filter = {};
-        for my $table (@$tables) {
-            $applied_filter = {
-                %$applied_filter,
-                %{$self->{filter}{out}->{$table} || {}}
-            }
-        }
-        $filter = {%$applied_filter, %$filter};
-    }
-    
-    # Replace filter name to code
-    for my $column (keys %$filter) {
-        my $name = $filter->{$column};
-        if (!defined $name) {
-            $filter->{$column} = undef;
-        }
-        elsif (ref $name ne 'CODE') {
-          croak qq{Filter "$name" is not registered" } . _subname
-            unless exists $self->filters->{$name};
-          $filter->{$column} = $self->filters->{$name};
-        }
-    }
-
-    # Execute
-    my $sth = $query->{sth};
-    my $affected;
-    if ((!$query->{duplicate} || $opt{bulk_insert}) && $type_rule_off
-      && !keys %$filter && !$self->{default_out_filter}
-      && !$opt{bind_type} && !$opt{type} && !$ENV{DBIX_CUSTOM_DEBUG})
-    {
-        eval {
-            if ($opt{bulk_insert}) {
-                my %count;
-                my $param = $params->[0];
-                $affected = $sth->execute(map { $param->{$_}->[++$count{$_} - 1] }
-                  @{$query->{columns}});
-            }
-            else {
-                for my $param (@$params) {
-                    $affected = $sth->execute(map { $param->{$_} }
-                      @{$query->{columns}});
-                }
-            }
-        };
-    }
-    else {
+        $type_filters->{$i} = {%{$type_filters->{$i}}, %{$self->{"_into$i"}{key}{$main_table} || {}}}
+          if $main_table;
+      }
+    }
+  }
+  
+  # Applied filter(DEPRECATED!)
+  if ($self->{filter}{on}) {
+    my $applied_filter = {};
+    for my $table (@$tables) {
+      $applied_filter = {
+        %$applied_filter,
+        %{$self->{filter}{out}->{$table} || {}}
+      }
+    }
+    $filter = {%$applied_filter, %$filter};
+  }
+  
+  # Replace filter name to code
+  for my $column (keys %$filter) {
+    my $name = $filter->{$column};
+    if (!defined $name) {
+      $filter->{$column} = undef;
+    }
+    elsif (ref $name ne 'CODE') {
+      croak qq{Filter "$name" is not registered" } . _subname
+        unless exists $self->filters->{$name};
+      $filter->{$column} = $self->filters->{$name};
+    }
+  }
+
+  # Execute
+  my $sth = $query->{sth};
+  my $affected;
+  if ((!$query->{duplicate} || $opt{bulk_insert}) && $type_rule_off
+    && !keys %$filter && !$self->{default_out_filter}
+    && !$opt{bind_type} && !$opt{type} && !$ENV{DBIX_CUSTOM_DEBUG})
+  {
+    eval {
+      if ($opt{bulk_insert}) {
+        my %count;
+        my $param = $params->[0];
+        $affected = $sth->execute(map { $param->{$_}->[++$count{$_} - 1] }
+          @{$query->{columns}});
+      }
+      else {
         for my $param (@$params) {
-            # Create bind values
-            my ($bind, $bind_types) = $self->_create_bind_values($param, $query->{columns},
-              $filter, $type_filters, $opt{bind_type} || $opt{type} || {});
-
-            # Execute
-            eval {
-                if ($opt{bind_type} || $opt{type}) {
-                    $sth->bind_param($_ + 1, $bind->[$_],
-                        $bind_types->[$_] ? $bind_types->[$_] : ())
-                      for (0 .. @$bind - 1);
-                    $affected = $sth->execute;
-                }
-                else {
-                    $affected = $sth->execute(@$bind);
-                }
-
-                # DEBUG message
-                if ($ENV{DBIX_CUSTOM_DEBUG}) {
-                    warn "SQL:\n" . $query->{sql} . "\n";
-                    my @output;
-                    for my $value (@$bind) {
-                        $value = 'undef' unless defined $value;
-                        $value = encode($ENV{DBIX_CUSTOM_DEBUG_ENCODING} || 'UTF-8', $value)
-                          if utf8::is_utf8($value);
-                        push @output, $value;
-                    }
-                    warn "Bind values: " . join(', ', @output) . "\n\n";
-                }
-            };
+          $affected = $sth->execute(map { $param->{$_} }
+            @{$query->{columns}});
         }
-    }
-    
-    $self->_croak($@, qq{. Following SQL is executed.\n}
-      . qq{$query->{sql}\n} . _subname) if $@;
-
-    # Remove id from parameter
-    for my $column (@cleanup, @{$opt{cleanup} || []}) {
-        delete $_->{$column} for @$params;
-    }
-    
-    # Not select statement
-    return $affected unless $sth->{NUM_OF_FIELDS};
-
-    # Filter(DEPRECATED!)
-    my $infilter = {};
-    if ($self->{filter}{on}) {
-        $infilter->{in}  = {};
-        $infilter->{end} = {};
-        push @$tables, $main_table if $main_table;
-        for my $table (@$tables) {
-            for my $way (qw/in end/) {
-                $infilter->{$way} = {%{$infilter->{$way}},
-                  %{$self->{filter}{$way}{$table} || {}}};
-            }
+      }
+    };
+  }
+  else {
+    for my $param (@$params) {
+      # Create bind values
+      my ($bind, $bind_types) = $self->_create_bind_values($param, $query->{columns},
+        $filter, $type_filters, $opt{bind_type} || $opt{type} || {});
+
+      # Execute
+      eval {
+        if ($opt{bind_type} || $opt{type}) {
+          $sth->bind_param($_ + 1, $bind->[$_],
+              $bind_types->[$_] ? $bind_types->[$_] : ())
+            for (0 .. @$bind - 1);
+          $affected = $sth->execute;
         }
-    }
-    
-    # Result
-    $self->result_class->new(
-        sth => $sth,
-        dbi => $self,
-        default_filter => $self->{default_in_filter},
-        filter => $infilter->{in} || {},
-        end_filter => $infilter->{end} || {},
-        type_rule => {
-            from1 => $self->type_rule->{from1},
-            from2 => $self->type_rule->{from2}
-        },
-    );
+        else { $affected = $sth->execute(@$bind) }
+
+        # DEBUG message
+        if ($ENV{DBIX_CUSTOM_DEBUG}) {
+          warn "SQL:\n" . $query->{sql} . "\n";
+          my @output;
+          for my $value (@$bind) {
+            $value = 'undef' unless defined $value;
+            $value = encode($ENV{DBIX_CUSTOM_DEBUG_ENCODING} || 'UTF-8', $value)
+              if utf8::is_utf8($value);
+            push @output, $value;
+          }
+          warn "Bind values: " . join(', ', @output) . "\n\n";
+        }
+      };
+    }
+  }
+  
+  $self->_croak($@, qq{. Following SQL is executed.\n}
+    . qq{$query->{sql}\n} . _subname) if $@;
+
+  # Remove id from parameter
+  for my $column (@cleanup, @{$opt{cleanup} || []}) {
+    delete $_->{$column} for @$params;
+  }
+  
+  # Not select statement
+  return $affected unless $sth->{NUM_OF_FIELDS};
+
+  # Filter(DEPRECATED!)
+  my $infilter = {};
+  if ($self->{filter}{on}) {
+    $infilter->{in}  = {};
+    $infilter->{end} = {};
+    push @$tables, $main_table if $main_table;
+    for my $table (@$tables) {
+      for my $way (qw/in end/) {
+        $infilter->{$way} = {%{$infilter->{$way}},
+          %{$self->{filter}{$way}{$table} || {}}};
+      }
+    }
+  }
+  
+  # Result
+  $self->result_class->new(
+    sth => $sth,
+    dbi => $self,
+    default_filter => $self->{default_in_filter},
+    filter => $infilter->{in} || {},
+    end_filter => $infilter->{end} || {},
+    type_rule => {
+      from1 => $self->type_rule->{from1},
+      from2 => $self->type_rule->{from2}
+    },
+  );
 }
 
 sub get_table_info {
-    my ($self, %opt) = @_;
-    
-    my $exclude = delete $opt{exclude};
-    croak qq/"$_" is wrong option/ for keys %opt;
-    
-    my $table_info = [];
-    $self->each_table(
-        sub { push @$table_info, {table => $_[1], info => $_[2] } },
-        exclude => $exclude
-    );
-    
-    return [sort {$a->{table} cmp $b->{table} } @$table_info];
+  my ($self, %opt) = @_;
+  
+  my $exclude = delete $opt{exclude};
+  croak qq/"$_" is wrong option/ for keys %opt;
+  
+  my $table_info = [];
+  $self->each_table(
+    sub { push @$table_info, {table => $_[1], info => $_[2] } },
+    exclude => $exclude
+  );
+  
+  return [sort {$a->{table} cmp $b->{table} } @$table_info];
 }
 
 sub get_column_info {
-    my ($self, %opt) = @_;
-    
-    my $exclude_table = delete $opt{exclude_table};
-    croak qq/"$_" is wrong option/ for keys %opt;
-    
-    my $column_info = [];
-    $self->each_column(
-        sub { push @$column_info, {table => $_[1], column => $_[2], info => $_[3] } },
-        exclude_table => $exclude_table
-    );
-    
-    return [
-      sort {$a->{table} cmp $b->{table} || $a->{column} cmp $b->{column} }
-        @$column_info];
+  my ($self, %opt) = @_;
+  
+  my $exclude_table = delete $opt{exclude_table};
+  croak qq/"$_" is wrong option/ for keys %opt;
+  
+  my $column_info = [];
+  $self->each_column(
+    sub { push @$column_info, {table => $_[1], column => $_[2], info => $_[3] } },
+    exclude_table => $exclude_table
+  );
+  
+  return [
+    sort {$a->{table} cmp $b->{table} || $a->{column} cmp $b->{column} }
+      @$column_info];
 }
 
 sub helper {
-    my $self = shift;
-    
-    # Register method
-    my $methods = ref $_[0] eq 'HASH' ? $_[0] : {@_};
-    $self->{_methods} = {%{$self->{_methods} || {}}, %$methods};
-    
-    return $self;
+  my $self = shift;
+  
+  # Register method
+  my $methods = ref $_[0] eq 'HASH' ? $_[0] : {@_};
+  $self->{_methods} = {%{$self->{_methods} || {}}, %$methods};
+  
+  return $self;
 }
 
 sub insert {
-    my $self = shift;
-    
-    # Options
-    my $params = @_ % 2 ? shift : undef;
-    my %opt = @_;
-    warn "insert method param option is DEPRECATED!" if $opt{param};
-    $params ||= delete $opt{param} || {};
-    
-    my $multi;
-    if (ref $params eq 'ARRAY') { $multi = 1 }
-    else { $params = [$params] }
-    
-    # Timestamp(DEPRECATED!)
-    if (!$multi && $opt{timestamp} && (my $insert_timestamp = $self->insert_timestamp)) {
-        warn "insert timestamp option is DEPRECATED! use created_at with now attribute";
-        my $columns = $insert_timestamp->[0];
-        $columns = [$columns] unless ref $columns eq 'ARRAY';
-        my $value = $insert_timestamp->[1];
-        $value = $value->() if ref $value eq 'CODE';
-        $params->[0]->{$_} = $value for @$columns;
-    }
-
-    # Created time and updated time
-    my @timestamp_cleanup;
-    if (defined $opt{created_at} || defined $opt{updated_at}) {
-        my $now = $self->now;
-        $now = $now->() if ref $now eq 'CODE';
-        if (defined $opt{created_at}) {
-            $_->{$opt{created_at}} = $now for @$params;
-            push @timestamp_cleanup, $opt{created_at};
-        }
-        if (defined $opt{updated_at}) {
-            $_->{$opt{updated_at}} = $now for @$params;
-            push @timestamp_cleanup, $opt{updated_at};
-        }
+  my $self = shift;
+  
+  # Options
+  my $params = @_ % 2 ? shift : undef;
+  my %opt = @_;
+  warn "insert method param option is DEPRECATED!" if $opt{param};
+  $params ||= delete $opt{param} || {};
+  
+  my $multi;
+  if (ref $params eq 'ARRAY') { $multi = 1 }
+  else { $params = [$params] }
+  
+  # Timestamp(DEPRECATED!)
+  if (!$multi && $opt{timestamp} && (my $insert_timestamp = $self->insert_timestamp)) {
+    warn "insert timestamp option is DEPRECATED! use created_at with now attribute";
+    my $columns = $insert_timestamp->[0];
+    $columns = [$columns] unless ref $columns eq 'ARRAY';
+    my $value = $insert_timestamp->[1];
+    $value = $value->() if ref $value eq 'CODE';
+    $params->[0]->{$_} = $value for @$columns;
+  }
+
+  # Created time and updated time
+  my @timestamp_cleanup;
+  if (defined $opt{created_at} || defined $opt{updated_at}) {
+    my $now = $self->now;
+    $now = $now->() if ref $now eq 'CODE';
+    if (defined $opt{created_at}) {
+      $_->{$opt{created_at}} = $now for @$params;
+      push @timestamp_cleanup, $opt{created_at};
     }
-    
-    # Merge id to parameter
-    my @cleanup;
-    my $id_param = {};
-    if (defined $opt{id} && !$multi) {
-        croak "insert id option must be specified with primary_key option"
-          unless $opt{primary_key};
-        $opt{primary_key} = [$opt{primary_key}] unless ref $opt{primary_key};
-        $opt{id} = [$opt{id}] unless ref $opt{id};
-        for (my $i = 0; $i < @{$opt{primary_key}}; $i++) {
-           my $key = $opt{primary_key}->[$i];
-           next if exists $params->[0]->{$key};
-           $params->[0]->{$key} = $opt{id}->[$i];
-           push @cleanup, $key;
-        }
-    }
-    
-    # Insert statement
-    my $sql = "insert ";
-    $sql .= "$opt{prefix} " if defined $opt{prefix};
-    $sql .= "into " . $self->q($opt{table}) . " ";
-    if ($opt{bulk_insert}) {
-        $sql .= $self->_multi_values_clause($params, {wrap => $opt{wrap}}) . " ";
-        my $new_param = {};
-        $new_param->{$_} = [] for keys %{$params->[0]};
-        for my $param (@$params) {
-            push @{$new_param->{$_}}, $param->{$_} for keys %$param;
-        }
-        $params = [$new_param];
-    }
-    else {
-        $sql .= $self->values_clause($params->[0], {wrap => $opt{wrap}}) . " ";
-    }
-
-    # Remove id from parameter
-    delete $params->[0]->{$_} for @cleanup;
-    
-    # Execute query
-    $opt{statement} = 'insert';
-    $opt{cleanup} = \@timestamp_cleanup;
-    $self->execute($sql, $params, %opt);
+    if (defined $opt{updated_at}) {
+      $_->{$opt{updated_at}} = $now for @$params;
+      push @timestamp_cleanup, $opt{updated_at};
+    }
+  }
+  
+  # Merge id to parameter
+  my @cleanup;
+  my $id_param = {};
+  if (defined $opt{id} && !$multi) {
+    croak "insert id option must be specified with primary_key option"
+      unless $opt{primary_key};
+    $opt{primary_key} = [$opt{primary_key}] unless ref $opt{primary_key};
+    $opt{id} = [$opt{id}] unless ref $opt{id};
+    for (my $i = 0; $i < @{$opt{primary_key}}; $i++) {
+      my $key = $opt{primary_key}->[$i];
+      next if exists $params->[0]->{$key};
+      $params->[0]->{$key} = $opt{id}->[$i];
+      push @cleanup, $key;
+    }
+  }
+  
+  # Insert statement
+  my $sql = "insert ";
+  $sql .= "$opt{prefix} " if defined $opt{prefix};
+  $sql .= "into " . $self->q($opt{table}) . " ";
+  if ($opt{bulk_insert}) {
+    $sql .= $self->_multi_values_clause($params, {wrap => $opt{wrap}}) . " ";
+    my $new_param = {};
+    $new_param->{$_} = [] for keys %{$params->[0]};
+    for my $param (@$params) {
+      push @{$new_param->{$_}}, $param->{$_} for keys %$param;
+    }
+    $params = [$new_param];
+  }
+  else {
+    $sql .= $self->values_clause($params->[0], {wrap => $opt{wrap}}) . " ";
+  }
+
+  # Remove id from parameter
+  delete $params->[0]->{$_} for @cleanup;
+  
+  # Execute query
+  $opt{statement} = 'insert';
+  $opt{cleanup} = \@timestamp_cleanup;
+  $self->execute($sql, $params, %opt);
 }
 
 sub insert_timestamp {
-    my $self = shift;
+  my $self = shift;
+  
+  warn "insert_timestamp method is DEPRECATED! use now attribute";
+  
+  if (@_) {
+    $self->{insert_timestamp} = [@_];
     
-    warn "insert_timestamp method is DEPRECATED! use now attribute";
-    
-    if (@_) {
-        $self->{insert_timestamp} = [@_];
-        
-        return $self;
-    }
-    return $self->{insert_timestamp};
+    return $self;
+  }
+  return $self->{insert_timestamp};
 }
 
 sub include_model {
-    my ($self, $name_space, $model_infos) = @_;
-    
-    # Name space
-    $name_space ||= '';
-    
-    # Get Model infomations
-    unless ($model_infos) {
-
-        # Load name space module
-        croak qq{"$name_space" is invalid class name } . _subname
-          if $name_space =~ /[^\w:]/;
-        eval "use $name_space";
-        croak qq{Name space module "$name_space.pm" is needed. $@ }
-            . _subname
-          if $@;
-        
-        # Search model modules
-        my $path = $INC{"$name_space.pm"};
-        $path =~ s/\.pm$//;
-        opendir my $dh, $path
-          or croak qq{Can't open directory "$path": $! } . _subname
-        $model_infos = [];
-        while (my $module = readdir $dh) {
-            push @$model_infos, $module
-              if $module =~ s/\.pm$//;
-        }
-        close $dh;
+  my ($self, $name_space, $model_infos) = @_;
+  
+  # Name space
+  $name_space ||= '';
+  
+  # Get Model infomations
+  unless ($model_infos) {
+
+    # Load name space module
+    croak qq{"$name_space" is invalid class name } . _subname
+      if $name_space =~ /[^\w:]/;
+    eval "use $name_space";
+    croak qq{Name space module "$name_space.pm" is needed. $@ }
+        . _subname
+      if $@;
+    
+    # Search model modules
+    my $path = $INC{"$name_space.pm"};
+    $path =~ s/\.pm$//;
+    opendir my $dh, $path
+      or croak qq{Can't open directory "$path": $! } . _subname
+    $model_infos = [];
+    while (my $module = readdir $dh) {
+      push @$model_infos, $module
+        if $module =~ s/\.pm$//;
+    }
+    close $dh;
+  }
+  
+  # Include models
+  for my $model_info (@$model_infos) {
+    
+    # Load model
+    my $model_class;
+    my $model_name;
+    my $model_table;
+    if (ref $model_info eq 'HASH') {
+      $model_class = $model_info->{class};
+      $model_name  = $model_info->{name};
+      $model_table = $model_info->{table};
+      
+      $model_name  ||= $model_class;
+      $model_table ||= $model_name;
+    }
+    else { $model_class = $model_name = $model_table = $model_info }
+    my $mclass = "${name_space}::$model_class";
+    croak qq{"$mclass" is invalid class name } . _subname
+      if $mclass =~ /[^\w:]/;
+    unless ($mclass->can('isa')) {
+      eval "use $mclass";
+      croak "$@ " . _subname if $@;
     }
     
-    # Include models
-    for my $model_info (@$model_infos) {
-        
-        # Load model
-        my $model_class;
-        my $model_name;
-        my $model_table;
-        if (ref $model_info eq 'HASH') {
-            $model_class = $model_info->{class};
-            $model_name  = $model_info->{name};
-            $model_table = $model_info->{table};
-            
-            $model_name  ||= $model_class;
-            $model_table ||= $model_name;
-        }
-        else { $model_class = $model_name = $model_table = $model_info }
-        my $mclass = "${name_space}::$model_class";
-        croak qq{"$mclass" is invalid class name } . _subname
-          if $mclass =~ /[^\w:]/;
-        unless ($mclass->can('isa')) {
-            eval "use $mclass";
-            croak "$@ " . _subname if $@;
-        }
-        
-        # Create model
-        my $opt = {};
-        $opt->{model_class} = $mclass if $mclass;
-        $opt->{name}        = $model_name if $model_name;
-        $opt->{table}       = $model_table if $model_table;
-        $self->create_model($opt);
-    }
-    
-    return $self;
+    # Create model
+    my $opt = {};
+    $opt->{model_class} = $mclass if $mclass;
+    $opt->{name}        = $model_name if $model_name;
+    $opt->{table}       = $model_table if $model_table;
+    $self->create_model($opt);
+  }
+  
+  return $self;
 }
 
 sub like_value { sub { "%$_[0]%" } }
 
 sub mapper {
-    my $self = shift;
-    return DBIx::Custom::Mapper->new(@_);
+  my $self = shift;
+  return DBIx::Custom::Mapper->new(@_);
 }
 
 sub merge_param {
-    my ($self, @params) = @_;
-    
-    # Merge parameters
-    my $merge = {};
-    for my $param (@params) {
-        for my $column (keys %$param) {
-            my $param_is_array = ref $param->{$column} eq 'ARRAY' ? 1 : 0;
-            
-            if (exists $merge->{$column}) {
-                $merge->{$column} = [$merge->{$column}]
-                  unless ref $merge->{$column} eq 'ARRAY';
-                push @{$merge->{$column}},
-                  ref $param->{$column} ? @{$param->{$column}} : $param->{$column};
-            }
-            else {
-                $merge->{$column} = $param->{$column};
-            }
-        }
-    }
-    
-    return $merge;
+  my ($self, @params) = @_;
+  
+  # Merge parameters
+  my $merge = {};
+  for my $param (@params) {
+    for my $column (keys %$param) {
+      my $param_is_array = ref $param->{$column} eq 'ARRAY' ? 1 : 0;
+      
+      if (exists $merge->{$column}) {
+        $merge->{$column} = [$merge->{$column}]
+          unless ref $merge->{$column} eq 'ARRAY';
+        push @{$merge->{$column}},
+          ref $param->{$column} ? @{$param->{$column}} : $param->{$column};
+      }
+      else { $merge->{$column} = $param->{$column} }
+    }
+  }
+  
+  return $merge;
 }
 
 sub model {
-    my ($self, $name, $model) = @_;
-    
-    # Set model
-    if ($model) {
-        $self->models->{$name} = $model;
-        return $self;
-    }
-    
-    # Check model existance
-    croak qq{Model "$name" is not included } . _subname
-      unless $self->models->{$name};
-    
-    # Get model
-    return $self->models->{$name};
+  my ($self, $name, $model) = @_;
+  
+  # Set model
+  if ($model) {
+    $self->models->{$name} = $model;
+    return $self;
+  }
+  
+  # Check model existance
+  croak qq{Model "$name" is not included } . _subname
+    unless $self->models->{$name};
+  
+  # Get model
+  return $self->models->{$name};
 }
 
 sub mycolumn {
-    my ($self, $table, $columns) = @_;
-    
-    # Create column clause
-    my @column;
-    $columns ||= [];
-    push @column, $self->q($table) . "." . $self->q($_) .
-      " as " . $self->q($_)
-      for @$columns;
-    
-    return join (', ', @column);
+  my ($self, $table, $columns) = @_;
+  
+  # Create column clause
+  my @column;
+  $columns ||= [];
+  push @column, $self->q($table) . "." . $self->q($_) . " as " . $self->q($_)
+    for @$columns;
+  
+  return join (', ', @column);
 }
 
 sub new {
-    my $self = shift->SUPER::new(@_);
-    
-    # Check attributes
-    my @attrs = keys %$self;
-    for my $attr (@attrs) {
-        croak qq{Invalid attribute: "$attr" } . _subname
-          unless $self->can($attr);
-    }
-    
-    $self->{safety_character} = 'a-zA-Z0-9_'
-      unless exists $self->{safety_character};
-
-    # DEPRECATED
-    $self->{_tags} = {
-        '?'     => \&DBIx::Custom::Tag::placeholder,
-        '='     => \&DBIx::Custom::Tag::equal,
-        '<>'    => \&DBIx::Custom::Tag::not_equal,
-        '>'     => \&DBIx::Custom::Tag::greater_than,
-        '<'     => \&DBIx::Custom::Tag::lower_than,
-        '>='    => \&DBIx::Custom::Tag::greater_than_equal,
-        '<='    => \&DBIx::Custom::Tag::lower_than_equal,
-        'like'  => \&DBIx::Custom::Tag::like,
-        'in'    => \&DBIx::Custom::Tag::in,
-        'insert_param' => \&DBIx::Custom::Tag::insert_param,
-        'update_param' => \&DBIx::Custom::Tag::update_param
-    };
-    $self->{tag_parse} = 1 unless exists $self->{tag_parse};
-    $self->{cache} = 0 unless exists $self->{cache};
-    
-    return $self;
+  my $self = shift->SUPER::new(@_);
+  
+  # Check attributes
+  my @attrs = keys %$self;
+  for my $attr (@attrs) {
+    croak qq{Invalid attribute: "$attr" } . _subname
+      unless $self->can($attr);
+  }
+  
+  $self->{safety_character} = 'a-zA-Z0-9_'
+    unless exists $self->{safety_character};
+
+  # DEPRECATED
+  $self->{_tags} = {
+    '?'     => \&DBIx::Custom::Tag::placeholder,
+    '='     => \&DBIx::Custom::Tag::equal,
+    '<>'    => \&DBIx::Custom::Tag::not_equal,
+    '>'     => \&DBIx::Custom::Tag::greater_than,
+    '<'     => \&DBIx::Custom::Tag::lower_than,
+    '>='    => \&DBIx::Custom::Tag::greater_than_equal,
+    '<='    => \&DBIx::Custom::Tag::lower_than_equal,
+    'like'  => \&DBIx::Custom::Tag::like,
+    'in'    => \&DBIx::Custom::Tag::in,
+    'insert_param' => \&DBIx::Custom::Tag::insert_param,
+    'update_param' => \&DBIx::Custom::Tag::update_param
+  };
+  $self->{tag_parse} = 1 unless exists $self->{tag_parse};
+  $self->{cache} = 0 unless exists $self->{cache};
+  
+  return $self;
 }
 
 sub not_exists { DBIx::Custom::NotExists->singleton }
 
 sub order {
-    my $self = shift;
-    return DBIx::Custom::Order->new(dbi => $self, @_);
+  my $self = shift;
+  return DBIx::Custom::Order->new(dbi => $self, @_);
 }
 
 sub q {
-    my ($self, $value, $quotemeta) = @_;
-    
-    my $quote = $self->{reserved_word_quote}
-      || $self->{quote} || $self->quote || '';
-    return "$quote$value$quote"
-      if !$quotemeta && ($quote eq '`' || $quote eq '"');
-    
-    my $q = substr($quote, 0, 1) || '';
-    my $p;
-    if (defined $quote && length $quote > 1) {
-        $p = substr($quote, 1, 1);
-    }
-    else { $p = $q }
-    
-    if ($quotemeta) {
-        $q = quotemeta($q);
-        $p = quotemeta($p);
-    }
-    
-    return "$q$value$p";
+  my ($self, $value, $quotemeta) = @_;
+  
+  my $quote = $self->{reserved_word_quote}
+    || $self->{quote} || $self->quote || '';
+  return "$quote$value$quote"
+    if !$quotemeta && ($quote eq '`' || $quote eq '"');
+  
+  my $q = substr($quote, 0, 1) || '';
+  my $p;
+  if (defined $quote && length $quote > 1) {
+    $p = substr($quote, 1, 1);
+  }
+  else { $p = $q }
+  
+  if ($quotemeta) {
+    $q = quotemeta($q);
+    $p = quotemeta($p);
+  }
+  
+  return "$q$value$p";
 }
 
 sub register_filter {
-    my $self = shift;
-    
-    # Register filter
-    my $filters = ref $_[0] eq 'HASH' ? $_[0] : {@_};
-    $self->filters({%{$self->filters}, %$filters});
-    
-    return $self;
+  my $self = shift;
+  
+  # Register filter
+  my $filters = ref $_[0] eq 'HASH' ? $_[0] : {@_};
+  $self->filters({%{$self->filters}, %$filters});
+  
+  return $self;
 }
 
 sub select {
-    my $self = shift;
-    my $column = shift if @_ % 2;
-    my %opt = @_;
-    $opt{column} = $column if defined $column;
-
-    # Options
-    my $tables = ref $opt{table} eq 'ARRAY' ? $opt{table}
-               : defined $opt{table} ? [$opt{table}]
-               : [];
-    $opt{table} = $tables;
-    my $where_param = $opt{where_param} || delete $opt{param} || {};
-    warn "select method where_param option is DEPRECATED!"
-      if $opt{where_param};
-    
-    # Add relation tables(DEPRECATED!);
-    if ($opt{relation}) {
-        warn "select() relation option is DEPRECATED!";
-        $self->_add_relation_table($tables, $opt{relation});
-    }
-    
-    # Select statement
-    my $sql = 'select ';
-    
-    # Prefix
-    $sql .= "$opt{prefix} " if defined $opt{prefix};
-    
-    # Column
-    if (defined $opt{column}) {
-        my $columns
-          = ref $opt{column} eq 'ARRAY' ? $opt{column} : [$opt{column}];
-        for my $column (@$columns) {
-            if (ref $column eq 'HASH') {
-                $column = $self->column(%$column) if ref $column eq 'HASH';
-            }
-            elsif (ref $column eq 'ARRAY') {
-                warn "select column option [COLUMN => ALIAS] syntax is DEPRECATED!" .
-                  "use q method to quote the value";
-                if (@$column == 3 && $column->[1] eq 'as') {
-                    warn "[COLUMN, as => ALIAS] is DEPRECATED! use [COLUMN => ALIAS]";
-                    splice @$column, 1, 1;
-                }
-                
-                $column = join(' ', $column->[0], 'as', $self->q($column->[1]));
-            }
-            unshift @$tables, @{$self->_search_tables($column)};
-            $sql .= "$column, ";
-        }
-        $sql =~ s/, $/ /;
-    }
-    else { $sql .= '* ' }
-    
-    # Table
-    $sql .= 'from ';
-    if ($opt{relation}) {
-        my $found = {};
-        for my $table (@$tables) {
-            $sql .= $self->q($table) . ', ' unless $found->{$table};
-            $found->{$table} = 1;
+  my $self = shift;
+  my $column = shift if @_ % 2;
+  my %opt = @_;
+  $opt{column} = $column if defined $column;
+
+  # Options
+  my $tables = ref $opt{table} eq 'ARRAY' ? $opt{table}
+    : defined $opt{table} ? [$opt{table}]
+    : [];
+  $opt{table} = $tables;
+  my $where_param = $opt{where_param} || delete $opt{param} || {};
+  warn "select method where_param option is DEPRECATED!"
+    if $opt{where_param};
+  
+  # Add relation tables(DEPRECATED!);
+  if ($opt{relation}) {
+    warn "select() relation option is DEPRECATED!";
+    $self->_add_relation_table($tables, $opt{relation});
+  }
+  
+  # Select statement
+  my $sql = 'select ';
+  
+  # Prefix
+  $sql .= "$opt{prefix} " if defined $opt{prefix};
+  
+  # Column
+  if (defined $opt{column}) {
+    my $columns
+      = ref $opt{column} eq 'ARRAY' ? $opt{column} : [$opt{column}];
+    for my $column (@$columns) {
+      if (ref $column eq 'HASH') {
+        $column = $self->column(%$column) if ref $column eq 'HASH';
+      }
+      elsif (ref $column eq 'ARRAY') {
+        warn "select column option [COLUMN => ALIAS] syntax is DEPRECATED!" .
+          "use q method to quote the value";
+        if (@$column == 3 && $column->[1] eq 'as') {
+          warn "[COLUMN, as => ALIAS] is DEPRECATED! use [COLUMN => ALIAS]";
+          splice @$column, 1, 1;
         }
+        
+        $column = join(' ', $column->[0], 'as', $self->q($column->[1]));
+      }
+      unshift @$tables, @{$self->_search_tables($column)};
+      $sql .= "$column, ";
     }
-    else { $sql .= $self->q($tables->[-1] || '') . ' ' }
     $sql =~ s/, $/ /;
-    croak "select method table option must be specified " . _subname
-      unless defined $tables->[-1];
-
-    # Add tables in parameter
-    unshift @$tables,
-            @{$self->_search_tables(join(' ', keys %$where_param) || '')};
-    
-    # Where
-    my $w = $self->_where_clause_and_param($opt{where}, $where_param,
-      delete $opt{id}, $opt{primary_key}, $tables->[-1]);
-    
-    # Add table names in where clause
-    unshift @$tables, @{$self->_search_tables($w->{clause})};
-    
-    # Join statement
-    $self->_push_join(\$sql, $opt{join}, $tables) if defined $opt{join};
-    
-    # Add where clause
-    $sql .= "$w->{clause} ";
-    
-    # Relation(DEPRECATED!);
-    $self->_push_relation(\$sql, $tables, $opt{relation}, $w->{clause} eq '' ? 1 : 0)
-      if $opt{relation};
-    
-    # Execute query
-    $opt{statement} = 'select';
-    my $result = $self->execute($sql, $w->{param}, %opt);
-    
-    $result;
+  }
+  else { $sql .= '* ' }
+  
+  # Table
+  $sql .= 'from ';
+  if ($opt{relation}) {
+    my $found = {};
+    for my $table (@$tables) {
+      $sql .= $self->q($table) . ', ' unless $found->{$table};
+      $found->{$table} = 1;
+    }
+  }
+  else { $sql .= $self->q($tables->[-1] || '') . ' ' }
+  $sql =~ s/, $/ /;
+  croak "select method table option must be specified " . _subname
+    unless defined $tables->[-1];
+
+  # Add tables in parameter
+  unshift @$tables,
+    @{$self->_search_tables(join(' ', keys %$where_param) || '')};
+  
+  # Where
+  my $w = $self->_where_clause_and_param($opt{where}, $where_param,
+    delete $opt{id}, $opt{primary_key}, $tables->[-1]);
+  
+  # Add table names in where clause
+  unshift @$tables, @{$self->_search_tables($w->{clause})};
+  
+  # Join statement
+  $self->_push_join(\$sql, $opt{join}, $tables) if defined $opt{join};
+  
+  # Add where clause
+  $sql .= "$w->{clause} ";
+  
+  # Relation(DEPRECATED!);
+  $self->_push_relation(\$sql, $tables, $opt{relation}, $w->{clause} eq '' ? 1 : 0)
+    if $opt{relation};
+  
+  # Execute query
+  $opt{statement} = 'select';
+  my $result = $self->execute($sql, $w->{param}, %opt);
+  
+  $result;
 }
 
 sub setup_model {
-    my $self = shift;
-    
-    # Setup model
-    $self->each_column(
-        sub {
-            my ($self, $table, $column, $column_info) = @_;
-            if (my $model = $self->models->{$table}) {
-                push @{$model->columns}, $column;
-            }
-        }
-    );
-    return $self;
+  my $self = shift;
+  
+  # Setup model
+  $self->each_column(
+    sub {
+      my ($self, $table, $column, $column_info) = @_;
+      if (my $model = $self->models->{$table}) {
+        push @{$model->columns}, $column;
+      }
+    }
+  );
+  return $self;
 }
 
 sub show_datatype {
-    my ($self, $table) = @_;
-    croak "Table name must be specified" unless defined $table;
-    print "$table\n";
-    
-    my $result = $self->select(table => $table, where => "'0' <> '0'");
-    my $sth = $result->sth;
-
-    my $columns = $sth->{NAME};
-    my $data_types = $sth->{TYPE};
-    
-    for (my $i = 0; $i < @$columns; $i++) {
-        my $column = $columns->[$i];
-        my $data_type = lc $data_types->[$i];
-        print "$column: $data_type\n";
-    }
+  my ($self, $table) = @_;
+  croak "Table name must be specified" unless defined $table;
+  print "$table\n";
+  
+  my $result = $self->select(table => $table, where => "'0' <> '0'");
+  my $sth = $result->sth;
+
+  my $columns = $sth->{NAME};
+  my $data_types = $sth->{TYPE};
+  
+  for (my $i = 0; $i < @$columns; $i++) {
+    my $column = $columns->[$i];
+    my $data_type = lc $data_types->[$i];
+    print "$column: $data_type\n";
+  }
 }
 
 sub show_typename {
-    my ($self, $t) = @_;
-    croak "Table name must be specified" unless defined $t;
-    print "$t\n";
-    
-    $self->each_column(sub {
-        my ($self, $table, $column, $infos) = @_;
-        return unless $table eq $t;
-        my $typename = lc $infos->{TYPE_NAME};
-        print "$column: $typename\n";
-    });
-    
-    return $self;
+  my ($self, $t) = @_;
+  croak "Table name must be specified" unless defined $t;
+  print "$t\n";
+  
+  $self->each_column(sub {
+    my ($self, $table, $column, $infos) = @_;
+    return unless $table eq $t;
+    my $typename = lc $infos->{TYPE_NAME};
+    print "$column: $typename\n";
+  });
+  
+  return $self;
 }
 
 sub show_tables {
-    my $self = shift;
-    
-    my %tables;
-    $self->each_table(sub { $tables{$_[1]}++ });
-    print join("\n", sort keys %tables) . "\n";
-    return $self;
+  my $self = shift;
+  
+  my %tables;
+  $self->each_table(sub { $tables{$_[1]}++ });
+  print join("\n", sort keys %tables) . "\n";
+  return $self;
 }
 
 sub type_rule {
-    my $self = shift;
-
-    $self->{_type_rule_is_called} = 1;
-    
-    if (@_) {
-        my $type_rule = ref $_[0] eq 'HASH' ? $_[0] : {@_};
+  my $self = shift;
+
+  $self->{_type_rule_is_called} = 1;
+  
+  if (@_) {
+    my $type_rule = ref $_[0] eq 'HASH' ? $_[0] : {@_};
+    
+    # Into
+    for my $i (1 .. 2) {
+      my $into = "into$i";
+      my $exists_into = exists $type_rule->{$into};
+      $type_rule->{$into} = _array_to_hash($type_rule->{$into});
+      $self->{type_rule} = $type_rule;
+      $self->{"_$into"} = {};
+      for my $type_name (keys %{$type_rule->{$into} || {}}) {
+        croak qq{type name of $into section must be lower case}
+          if $type_name =~ /[A-Z]/;
+      }
+      
+      $self->each_column(sub {
+        my ($dbi, $table, $column, $column_info) = @_;
         
-        # Into
-        for my $i (1 .. 2) {
-            my $into = "into$i";
-            my $exists_into = exists $type_rule->{$into};
-            $type_rule->{$into} = _array_to_hash($type_rule->{$into});
-            $self->{type_rule} = $type_rule;
-            $self->{"_$into"} = {};
-            for my $type_name (keys %{$type_rule->{$into} || {}}) {
-                croak qq{type name of $into section must be lower case}
-                  if $type_name =~ /[A-Z]/;
-            }
+        my $type_name = lc $column_info->{TYPE_NAME};
+        if ($type_rule->{$into} &&
+            (my $filter = $type_rule->{$into}->{$type_name}))
+        {
+          return unless exists $type_rule->{$into}->{$type_name};
+          if (defined $filter && ref $filter ne 'CODE') 
+          {
+            my $fname = $filter;
+            croak qq{Filter "$fname" is not registered" } . _subname
+              unless exists $self->filters->{$fname};
             
-            $self->each_column(sub {
-                my ($dbi, $table, $column, $column_info) = @_;
-                
-                my $type_name = lc $column_info->{TYPE_NAME};
-                if ($type_rule->{$into} &&
-                    (my $filter = $type_rule->{$into}->{$type_name}))
-                {
-                    return unless exists $type_rule->{$into}->{$type_name};
-                    if  (defined $filter && ref $filter ne 'CODE') 
-                    {
-                        my $fname = $filter;
-                        croak qq{Filter "$fname" is not registered" } . _subname
-                          unless exists $self->filters->{$fname};
-                        
-                        $filter = $self->filters->{$fname};
-                    }
-
-                    $self->{"_$into"}{key}{$table}{$column} = $filter;
-                    $self->{"_$into"}{dot}{"$table.$column"} = $filter;
-                }
-            });
-        }
+            $filter = $self->filters->{$fname};
+          }
 
-        # From
-        for my $i (1 .. 2) {
-            $type_rule->{"from$i"} = _array_to_hash($type_rule->{"from$i"});
-            for my $data_type (keys %{$type_rule->{"from$i"} || {}}) {
-                croak qq{data type of from$i section must be lower case or number}
-                  if $data_type =~ /[A-Z]/;
-                my $fname = $type_rule->{"from$i"}{$data_type};
-                if (defined $fname && ref $fname ne 'CODE') {
-                    croak qq{Filter "$fname" is not registered" } . _subname
-                      unless exists $self->filters->{$fname};
-                    
-                    $type_rule->{"from$i"}{$data_type} = $self->filters->{$fname};
-                }
-            }
+          $self->{"_$into"}{key}{$table}{$column} = $filter;
+          $self->{"_$into"}{dot}{"$table.$column"} = $filter;
         }
-        
-        return $self;
+      });
+    }
+
+    # From
+    for my $i (1 .. 2) {
+      $type_rule->{"from$i"} = _array_to_hash($type_rule->{"from$i"});
+      for my $data_type (keys %{$type_rule->{"from$i"} || {}}) {
+        croak qq{data type of from$i section must be lower case or number}
+          if $data_type =~ /[A-Z]/;
+        my $fname = $type_rule->{"from$i"}{$data_type};
+        if (defined $fname && ref $fname ne 'CODE') {
+          croak qq{Filter "$fname" is not registered" } . _subname
+            unless exists $self->filters->{$fname};
+          
+          $type_rule->{"from$i"}{$data_type} = $self->filters->{$fname};
+        }
+      }
     }
     
-    return $self->{type_rule} || {};
+    return $self;
+  }
+  
+  return $self->{type_rule} || {};
 }
 
 sub update {
-    my $self = shift;
-
-    # Options
-    my $param = @_ % 2 ? shift : undef;
-    my %opt = @_;
-    warn "update param option is DEPRECATED!" if $opt{param};
-    warn "update method where_param option is DEPRECATED!"
-      if $opt{where_param};
-    $param ||= $opt{param} || {};
-    
-    # Don't allow update all rows
-    croak qq{update method where option must be specified } . _subname
-      if !$opt{where} && !defined $opt{id} && !$opt{allow_update_all};
-    
-    # Timestamp(DEPRECATED!)
-    if ($opt{timestamp} && (my $update_timestamp = $self->update_timestamp)) {
-        warn "update timestamp option is DEPRECATED! use updated_at and now method";
-        my $columns = $update_timestamp->[0];
-        $columns = [$columns] unless ref $columns eq 'ARRAY';
-        my $value = $update_timestamp->[1];
-        $value = $value->() if ref $value eq 'CODE';
-        $param->{$_} = $value for @$columns;
-    }
-
-    # Created time and updated time
-    my @timestamp_cleanup;
-    if (defined $opt{updated_at}) {
-        my $now = $self->now;
-        $now = $now->() if ref $now eq 'CODE';
-        $param->{$opt{updated_at}} = $self->now->();
-        push @timestamp_cleanup, $opt{updated_at};
-    }
-
-    # Assign clause
-    my $assign_clause = $self->assign_clause($param, {wrap => $opt{wrap}});
-    
-    # Where
-    my $w = $self->_where_clause_and_param($opt{where}, $opt{where_param},
-      delete $opt{id}, $opt{primary_key}, $opt{table});
-    
-    # Update statement
-    my $sql = "update ";
-    $sql .= "$opt{prefix} " if defined $opt{prefix};
-    $sql .= $self->q($opt{table}) . " set $assign_clause $w->{clause} ";
-    
-    # Execute query
-    $opt{statement} = 'update';
-    $opt{cleanup} = \@timestamp_cleanup;
-    $self->execute($sql, [$param, $w->{param}], %opt);
+  my $self = shift;
+
+  # Options
+  my $param = @_ % 2 ? shift : undef;
+  my %opt = @_;
+  warn "update param option is DEPRECATED!" if $opt{param};
+  warn "update method where_param option is DEPRECATED!"
+    if $opt{where_param};
+  $param ||= $opt{param} || {};
+  
+  # Don't allow update all rows
+  croak qq{update method where option must be specified } . _subname
+    if !$opt{where} && !defined $opt{id} && !$opt{allow_update_all};
+  
+  # Timestamp(DEPRECATED!)
+  if ($opt{timestamp} && (my $update_timestamp = $self->update_timestamp)) {
+    warn "update timestamp option is DEPRECATED! use updated_at and now method";
+    my $columns = $update_timestamp->[0];
+    $columns = [$columns] unless ref $columns eq 'ARRAY';
+    my $value = $update_timestamp->[1];
+    $value = $value->() if ref $value eq 'CODE';
+    $param->{$_} = $value for @$columns;
+  }
+
+  # Created time and updated time
+  my @timestamp_cleanup;
+  if (defined $opt{updated_at}) {
+    my $now = $self->now;
+    $now = $now->() if ref $now eq 'CODE';
+    $param->{$opt{updated_at}} = $self->now->();
+    push @timestamp_cleanup, $opt{updated_at};
+  }
+
+  # Assign clause
+  my $assign_clause = $self->assign_clause($param, {wrap => $opt{wrap}});
+  
+  # Where
+  my $w = $self->_where_clause_and_param($opt{where}, $opt{where_param},
+    delete $opt{id}, $opt{primary_key}, $opt{table});
+  
+  # Update statement
+  my $sql = "update ";
+  $sql .= "$opt{prefix} " if defined $opt{prefix};
+  $sql .= $self->q($opt{table}) . " set $assign_clause $w->{clause} ";
+  
+  # Execute query
+  $opt{statement} = 'update';
+  $opt{cleanup} = \@timestamp_cleanup;
+  $self->execute($sql, [$param, $w->{param}], %opt);
 }
 
 sub update_all { shift->update(@_, allow_update_all => 1) };
 
 sub update_or_insert {
-    my ($self, $param, %opt) = @_;
-    croak "update_or_insert method need primary_key and id option "
-      unless defined $opt{id} && defined $opt{primary_key};
-    my $statement_opt = $opt{option} || {};
-
-    my $rows = $self->select(%opt, %{$statement_opt->{select} || {}})->all;
-    if (@$rows == 0) {
-        return $self->insert($param, %opt, %{$statement_opt->{insert} || {}});
-    }
-    elsif (@$rows == 1) {
-        return 0 unless keys %$param;
-        return $self->update($param, %opt, %{$statement_opt->{update} || {}});
-    }
-    else {
-        croak "selected row must be one " . _subname;
-    }
+  my ($self, $param, %opt) = @_;
+  croak "update_or_insert method need primary_key and id option "
+    unless defined $opt{id} && defined $opt{primary_key};
+  my $statement_opt = $opt{option} || {};
+
+  my $rows = $self->select(%opt, %{$statement_opt->{select} || {}})->all;
+  if (@$rows == 0) {
+    return $self->insert($param, %opt, %{$statement_opt->{insert} || {}});
+  }
+  elsif (@$rows == 1) {
+    return 0 unless keys %$param;
+    return $self->update($param, %opt, %{$statement_opt->{update} || {}});
+  }
+  else { croak "selected row must be one " . _subname }
 }
 
 sub update_timestamp {
-    my $self = shift;
+  my $self = shift;
+  
+  warn "update_timestamp method is DEPRECATED! use now method";
+  
+  if (@_) {
+    $self->{update_timestamp} = [@_];
     
-    warn "update_timestamp method is DEPRECATED! use now method";
-    
-    if (@_) {
-        $self->{update_timestamp} = [@_];
-        
-        return $self;
-    }
-    return $self->{update_timestamp};
+    return $self;
+  }
+  return $self->{update_timestamp};
 }
 
 sub values_clause {
-    my ($self, $param, $opts) = @_;
-    
-    my $wrap = $opts->{wrap} || {};
-    
-    # Create insert parameter tag
-    my ($q, $p) = split //, $self->q('');
-    
-    # values clause(performance is important)
-    '(' .
-    join(
-      ', ',
-      map { "$q$_$p" } sort keys %$param
-    ) .
-    ') values (' .
-    join(
-      ', ',
-      map {
-          ref $param->{$_} eq 'SCALAR' ? ${$param->{$_}} :
-          $wrap->{$_} ? $wrap->{$_}->(":$_") :
-          ":$_";
-      } sort keys %$param
-    ) .
-    ')'
+  my ($self, $param, $opts) = @_;
+  
+  my $wrap = $opts->{wrap} || {};
+  
+  # Create insert parameter tag
+  my ($q, $p) = split //, $self->q('');
+  
+  # values clause(performance is important)
+  '(' .
+  join(
+    ', ',
+    map { "$q$_$p" } sort keys %$param
+  ) .
+  ') values (' .
+  join(
+    ', ',
+    map {
+      ref $param->{$_} eq 'SCALAR' ? ${$param->{$_}} :
+      $wrap->{$_} ? $wrap->{$_}->(":$_") :
+      ":$_";
+    } sort keys %$param
+  ) .
+  ')'
 }
 
 sub _multi_values_clause {
-    my ($self, $params, $opts) = @_;
-    
-    my $wrap = $opts->{wrap} || {};
-    
-    # Create insert parameter tag
-    my ($q, $p) = split //, $self->q('');
-    
-    # Multi values clause
-    my $clause = '(' . join(', ', map { "$q$_$p" } sort keys %{$params->[0]}) . ') values ';
-    
-    for (1 .. @$params) {
-        $clause .= '(' . join(', ', 
-          map {
-              ref $params->[0]->{$_} eq 'SCALAR' ? ${$params->[0]->{$_}} :
-              $wrap->{$_} ? $wrap->{$_}->(":$_") :
-              ":$_";
-          } sort keys %{$params->[0]}
-        ) . '), '
-    }
-    $clause =~ s/, $//;
-    return $clause;
+  my ($self, $params, $opts) = @_;
+  
+  my $wrap = $opts->{wrap} || {};
+  
+  # Create insert parameter tag
+  my ($q, $p) = split //, $self->q('');
+  
+  # Multi values clause
+  my $clause = '(' . join(', ', map { "$q$_$p" } sort keys %{$params->[0]}) . ') values ';
+  
+  for (1 .. @$params) {
+    $clause .= '(' . join(', ', 
+      map {
+        ref $params->[0]->{$_} eq 'SCALAR' ? ${$params->[0]->{$_}} :
+        $wrap->{$_} ? $wrap->{$_}->(":$_") :
+        ":$_";
+      } sort keys %{$params->[0]}
+    ) . '), '
+  }
+  $clause =~ s/, $//;
+  return $clause;
 }
 
 sub where { DBIx::Custom::Where->new(dbi => shift, @_) }
 
 sub _create_query {
-    
-    my ($self, $source, $after_build_sql) = @_;
-    
-    # Cache
-    my $cache = $self->{cache};
-    
-    # Query
-    my $query;
-    
-    # Get cached query
-    if ($cache) {
-        
-        # Get query
-        my $q = $self->cache_method->($self, $source);
-        
-        # Create query
-        if ($q) {
-            $query = DBIx::Custom::Query->new($q);
-            $query->{filters} = $self->filters;
-        }
-    }
+  
+  my ($self, $source, $after_build_sql) = @_;
+  
+  # Cache
+  my $cache = $self->{cache};
+  
+  # Query
+  my $query;
+  
+  # Get cached query
+  if ($cache) {
+    
+    # Get query
+    my $q = $self->cache_method->($self, $source);
     
     # Create query
-    unless ($query) {
-
-        # Create query
-        my $tag_parse = exists $ENV{DBIX_CUSTOM_TAG_PARSE}
-          ? $ENV{DBIX_CUSTOM_TAG_PARSE} : $self->{tag_parse};
-
-        my $sql = " " . $source || '';
-        if ($tag_parse && ($sql =~ /\s\{/)) {
-            $query = $self->query_builder->build_query($sql);
-        }
-        else {
-            my @columns;
-            my $c = $self->{safety_character};
-            my $re = $c eq 'a-zA-Z0-9_'
-              ? qr/(.*?[^\\]):([$c\.]+)(?:\{(.*?)\})?(.*)/so
-              : qr/(.*?[^\\]):([$c\.]+)(?:\{(.*?)\})?(.*)/s;
-            my %duplicate;
-            my $duplicate;
-            # Parameter regex
-            $sql =~ s/([0-9]):/$1\\:/g;
-            my $new_sql = '';
-            while ($sql =~ /$re/) {
-                push @columns, $2;
-                $duplicate = 1 if ++$duplicate{$columns[-1]} > 1;
-                ($new_sql, $sql) = defined $3 ?
-                  ($new_sql . "$1$2 $3 ?", " $4") : ($new_sql . "$1?", " $4");
-            }
-            $new_sql .= $sql;
-            $new_sql =~ s/\\:/:/g if index($new_sql, "\\:") != -1;
-
-            # Create query
-            $query = {sql => $new_sql, columns => \@columns, duplicate => $duplicate};
-        }
-        
-        # Save query to cache
-        $self->cache_method->(
-            $self, $source,
-            {
-                sql     => $query->{sql}, 
-                columns => $query->{columns},
-                tables  => $query->{tables} || []
-            }
-        ) if $cache;
+    if ($q) {
+      $query = DBIx::Custom::Query->new($q);
+      $query->{filters} = $self->filters;
     }
+  }
+  
+  # Create query
+  unless ($query) {
 
-    # Filter SQL
-    $query->{sql} = $after_build_sql->($query->{sql}) if $after_build_sql;
-    
-    # Save sql
-    $self->{last_sql} = $query->{sql};
-    
-    # Prepare statement handle
-    my $sth;
-    eval { $sth = $self->dbh->prepare($query->{sql}) };
-    
-    if ($@) {
-        $self->_croak($@, qq{. Following SQL is executed.\n}
-                        . qq{$query->{sql}\n} . _subname);
+    # Create query
+    my $tag_parse = exists $ENV{DBIX_CUSTOM_TAG_PARSE}
+      ? $ENV{DBIX_CUSTOM_TAG_PARSE} : $self->{tag_parse};
+
+    my $sql = " " . $source || '';
+    if ($tag_parse && ($sql =~ /\s\{/)) {
+      $query = $self->query_builder->build_query($sql);
     }
-    
-    # Set statement handle
-    $query->{sth} = $sth;
-    
-    # Set filters
-    $query->{filters} = $self->{filters} || $self->filters;
-    
-    return $query;
+    else {
+      my @columns;
+      my $c = $self->{safety_character};
+      my $re = $c eq 'a-zA-Z0-9_'
+        ? qr/(.*?[^\\]):([$c\.]+)(?:\{(.*?)\})?(.*)/so
+        : qr/(.*?[^\\]):([$c\.]+)(?:\{(.*?)\})?(.*)/s;
+      my %duplicate;
+      my $duplicate;
+      # Parameter regex
+      $sql =~ s/([0-9]):/$1\\:/g;
+      my $new_sql = '';
+      while ($sql =~ /$re/) {
+        push @columns, $2;
+        $duplicate = 1 if ++$duplicate{$columns[-1]} > 1;
+        ($new_sql, $sql) = defined $3 ?
+          ($new_sql . "$1$2 $3 ?", " $4") : ($new_sql . "$1?", " $4");
+      }
+      $new_sql .= $sql;
+      $new_sql =~ s/\\:/:/g if index($new_sql, "\\:") != -1;
+
+      # Create query
+      $query = {sql => $new_sql, columns => \@columns, duplicate => $duplicate};
+    }
+    
+    # Save query to cache
+    $self->cache_method->(
+      $self, $source,
+      {
+        sql     => $query->{sql}, 
+        columns => $query->{columns},
+        tables  => $query->{tables} || []
+      }
+    ) if $cache;
+  }
+
+  # Filter SQL
+  $query->{sql} = $after_build_sql->($query->{sql}) if $after_build_sql;
+  
+  # Save sql
+  $self->{last_sql} = $query->{sql};
+  
+  # Prepare statement handle
+  my $sth;
+  eval { $sth = $self->dbh->prepare($query->{sql}) };
+  
+  if ($@) {
+    $self->_croak($@, qq{. Following SQL is executed.\n}
+                    . qq{$query->{sql}\n} . _subname);
+  }
+  
+  # Set statement handle
+  $query->{sth} = $sth;
+  
+  # Set filters
+  $query->{filters} = $self->{filters} || $self->filters;
+  
+  return $query;
 }
 
-sub _create_bind_values {
-    my ($self, $params, $columns, $filter, $type_filters, $bind_type) = @_;
-    
-    $bind_type = _array_to_hash($bind_type) if ref $bind_type eq 'ARRAY';
-    
-    # Create bind values
-    my @bind;
-    my @types;
-    my %count;
-    my %not_exists;
-    for my $column (@$columns) {
-        
-        # Bind value
-        if(ref $params->{$column} eq 'ARRAY') {
-            my $i = $count{$column} || 0;
-            $i += $not_exists{$column} || 0;
-            my $found;
-            for (my $k = $i; $i < @{$params->{$column}}; $k++) {
-                if (ref $params->{$column}->[$k] eq 'DBIx::Custom::NotExists') {
-                    $not_exists{$column}++;
-                }
-                else  {
-                    push @bind, $params->{$column}->[$k];
-                    $found = 1;
-                    last
-                }
-            }
-            next unless $found;
-        }
-        else { push @bind, $params->{$column} }
-        
-        # Filter
-        if (my $f = $filter->{$column} || $self->{default_out_filter} || '') {
-            $bind[-1] = $f->($bind[-1]);
+sub _create_bind_values {
+  my ($self, $params, $columns, $filter, $type_filters, $bind_type) = @_;
+  
+  $bind_type = _array_to_hash($bind_type) if ref $bind_type eq 'ARRAY';
+  
+  # Create bind values
+  my @bind;
+  my @types;
+  my %count;
+  my %not_exists;
+  for my $column (@$columns) {
+    
+    # Bind value
+    if(ref $params->{$column} eq 'ARRAY') {
+      my $i = $count{$column} || 0;
+      $i += $not_exists{$column} || 0;
+      my $found;
+      for (my $k = $i; $i < @{$params->{$column}}; $k++) {
+        if (ref $params->{$column}->[$k] eq 'DBIx::Custom::NotExists') {
+            $not_exists{$column}++;
         }
-        
-        # Type rule
-        if ($self->{_type_rule_is_called}) {
-            my $tf1 = $self->{"_into1"}->{dot}->{$column}
-              || $type_filters->{1}->{$column};
-            $bind[-1] = $tf1->($bind[-1]) if $tf1;
-            my $tf2 = $self->{"_into2"}->{dot}->{$column}
-              || $type_filters->{2}->{$column};
-            $bind[-1] = $tf2->($bind[-1]) if $tf2;
+        else  {
+          push @bind, $params->{$column}->[$k];
+          $found = 1;
+          last
         }
-       
-        # Bind types
-        push @types, $bind_type->{$column};
-        
-        # Count up 
-        $count{$column}++;
+      }
+      next unless $found;
     }
+    else { push @bind, $params->{$column} }
     
-    return (\@bind, \@types);
-}
-
-sub _id_to_param {
-    my ($self, $id, $primary_keys, $table) = @_;
-    
-    # Check primary key
-    croak "primary_key option " .
-          "must be specified when id option is used" . _subname
-      unless defined $primary_keys;
-    $primary_keys = [$primary_keys] unless ref $primary_keys eq 'ARRAY';
+    # Filter
+    if (my $f = $filter->{$column} || $self->{default_out_filter} || '') {
+      $bind[-1] = $f->($bind[-1]);
+    }
     
-    # Create parameter
-    my $param = {};
-    if (defined $id) {
-        $id = [$id] unless ref $id;
-        for(my $i = 0; $i < @$id; $i++) {
-           my $key = $primary_keys->[$i];
-           $key = "$table." . $key if $table;
-           $param->{$key} = $id->[$i];
-        }
+    # Type rule
+    if ($self->{_type_rule_is_called}) {
+      my $tf1 = $self->{"_into1"}->{dot}->{$column}
+        || $type_filters->{1}->{$column};
+      $bind[-1] = $tf1->($bind[-1]) if $tf1;
+      my $tf2 = $self->{"_into2"}->{dot}->{$column}
+        || $type_filters->{2}->{$column};
+      $bind[-1] = $tf2->($bind[-1]) if $tf2;
     }
+   
+    # Bind types
+    push @types, $bind_type->{$column};
     
-    return $param;
+    # Count up 
+    $count{$column}++;
+  }
+  
+  return (\@bind, \@types);
+}
+
+sub _id_to_param {
+  my ($self, $id, $primary_keys, $table) = @_;
+  
+  # Check primary key
+  croak "primary_key option " .
+        "must be specified when id option is used" . _subname
+    unless defined $primary_keys;
+  $primary_keys = [$primary_keys] unless ref $primary_keys eq 'ARRAY';
+  
+  # Create parameter
+  my $param = {};
+  if (defined $id) {
+    $id = [$id] unless ref $id;
+    for(my $i = 0; $i < @$id; $i++) {
+      my $key = $primary_keys->[$i];
+      $key = "$table." . $key if $table;
+      $param->{$key} = $id->[$i];
+    }
+  }
+  
+  return $param;
 }
 
 sub _connect {
-    my $self = shift;
-    
-    # Attributes
-    my $dsn = $self->data_source;
-    warn "data_source is DEPRECATED!\n"
-      if $dsn;
-    $dsn ||= $self->dsn;
-    croak qq{"dsn" must be specified } . _subname
-      unless $dsn;
-    my $user        = $self->user;
-    my $password    = $self->password;
-    my $option = $self->_option;
-    $option = {%{$self->default_option}, %$option};
-    
-    # Connect
-    my $dbh;
-    eval {
-        $dbh = DBI->connect(
-            $dsn,
-            $user,
-            $password,
-            $option
-        );
-    };
-    
-    # Connect error
-    croak "$@ " . _subname if $@;
-    
-    return $dbh;
+  my $self = shift;
+  
+  # Attributes
+  my $dsn = $self->data_source;
+  warn "data_source is DEPRECATED!\n"
+    if $dsn;
+  $dsn ||= $self->dsn;
+  croak qq{"dsn" must be specified } . _subname
+    unless $dsn;
+  my $user        = $self->user;
+  my $password    = $self->password;
+  my $option = $self->_option;
+  $option = {%{$self->default_option}, %$option};
+  
+  # Connect
+  my $dbh;
+  eval { $dbh = DBI->connect($dsn, $user, $password, $option) };
+  
+  # Connect error
+  croak "$@ " . _subname if $@;
+  
+  return $dbh;
 }
 
 sub _croak {
-    my ($self, $error, $append) = @_;
-    
-    # Append
-    $append ||= "";
-    
-    # Verbose
-    if ($Carp::Verbose) { croak $error }
-    
-    # Not verbose
-    else {
-        
-        # Remove line and module infromation
-        my $at_pos = rindex($error, ' at ');
-        $error = substr($error, 0, $at_pos);
-        $error =~ s/\s+$//;
-        croak "$error$append";
-    }
+  my ($self, $error, $append) = @_;
+  
+  # Append
+  $append ||= "";
+  
+  # Verbose
+  if ($Carp::Verbose) { croak $error }
+  
+  # Not verbose
+  else {
+    # Remove line and module infromation
+    my $at_pos = rindex($error, ' at ');
+    $error = substr($error, 0, $at_pos);
+    $error =~ s/\s+$//;
+    croak "$error$append";
+  }
 }
 
 sub _driver { lc shift->{dbh}->{Driver}->{Name} }
 
 sub _need_tables {
-    my ($self, $tree, $need_tables, $tables) = @_;
-    
-    # Get needed tables
-    for my $table (@$tables) {
-        if ($tree->{$table}) {
-            $need_tables->{$table} = 1;
-            $self->_need_tables($tree, $need_tables, [$tree->{$table}{parent}])
-        }
+  my ($self, $tree, $need_tables, $tables) = @_;
+  
+  # Get needed tables
+  for my $table (@$tables) {
+    if ($tree->{$table}) {
+      $need_tables->{$table} = 1;
+      $self->_need_tables($tree, $need_tables, [$tree->{$table}{parent}])
     }
+  }
 }
 
 sub _option {
-    my $self = shift;
-    my $option = {%{$self->dbi_options}, %{$self->dbi_option}, %{$self->option}};
-    warn "dbi_options is DEPRECATED! use option instead\n"
-      if keys %{$self->dbi_options};
-    warn "dbi_option is DEPRECATED! use option instead\n"
-      if keys %{$self->dbi_option};
-    return $option;
+  my $self = shift;
+  my $option = {%{$self->dbi_options}, %{$self->dbi_option}, %{$self->option}};
+  warn "dbi_options is DEPRECATED! use option instead\n"
+    if keys %{$self->dbi_options};
+  warn "dbi_option is DEPRECATED! use option instead\n"
+    if keys %{$self->dbi_option};
+  return $option;
 }
 
 sub _push_join {
-    my ($self, $sql, $join, $join_tables) = @_;
-    
-    $join = [$join] unless ref $join eq 'ARRAY';
-    
-    # No join
-    return unless @$join;
-    
-    # Push join clause
-    my $tree = {};
-    for (my $i = 0; $i < @$join; $i++) {
-        
-        # Arrange
-        my $join_clause;;
-        my $option;
-        if (ref $join->[$i] eq 'HASH') {
-            $join_clause = $join->[$i]->{clause};
-            $option = {table => $join->[$i]->{table}};
-        }
-        else {
-            $join_clause = $join->[$i];
-            $option = {};
-        };
-
-        # Find tables in join clause
-        my $table1;
-        my $table2;
-        if (my $table = $option->{table}) {
-            $table1 = $table->[0];
-            $table2 = $table->[1];
-        }
-        else {
-            my $q = $self->_quote;
-            my $j_clause = (split /\s+on\s+/, $join_clause)[-1];
-            $j_clause =~ s/'.+?'//g;
-            my $q_re = quotemeta($q);
-            $j_clause =~ s/[$q_re]//g;
-            
-            my @j_clauses = reverse split /\s(and|on)\s/, $j_clause;
-            my $c = $self->{safety_character};
-            my $join_re = qr/([$c]+)\.[$c]+[^$c].*?([$c]+)\.[$c]+/sm;
-            for my $clause (@j_clauses) {
-                if ($clause =~ $join_re) {
-                    $table1 = $1;
-                    $table2 = $2;
-                    last;
-                }                
-            }
-        }
-        croak qq{join clause must have two table name after "on" keyword. } .
-              qq{"$join_clause" is passed }  . _subname
-          unless defined $table1 && defined $table2;
-        croak qq{right side table of "$join_clause" must be unique }
-            . _subname
-          if exists $tree->{$table2};
-        croak qq{Same table "$table1" is specified} . _subname
-          if $table1 eq $table2;
-        $tree->{$table2}
-          = {position => $i, parent => $table1, join => $join_clause};
+  my ($self, $sql, $join, $join_tables) = @_;
+  
+  $join = [$join] unless ref $join eq 'ARRAY';
+  
+  # No join
+  return unless @$join;
+  
+  # Push join clause
+  my $tree = {};
+  for (my $i = 0; $i < @$join; $i++) {
+    
+    # Arrange
+    my $join_clause;;
+    my $option;
+    if (ref $join->[$i] eq 'HASH') {
+      $join_clause = $join->[$i]->{clause};
+      $option = {table => $join->[$i]->{table}};
     }
-    
-    # Search need tables
-    my $need_tables = {};
-    $self->_need_tables($tree, $need_tables, $join_tables);
-    my @need_tables = sort { $tree->{$a}{position} <=> $tree->{$b}{position} }
-      keys %$need_tables;
-    
-    # Add join clause
-    $$sql .= $tree->{$_}{join} . ' ' for @need_tables;
+    else {
+      $join_clause = $join->[$i];
+      $option = {};
+    };
+
+    # Find tables in join clause
+    my $table1;
+    my $table2;
+    if (my $table = $option->{table}) {
+      $table1 = $table->[0];
+      $table2 = $table->[1];
+    }
+    else {
+      my $q = $self->_quote;
+      my $j_clause = (split /\s+on\s+/, $join_clause)[-1];
+      $j_clause =~ s/'.+?'//g;
+      my $q_re = quotemeta($q);
+      $j_clause =~ s/[$q_re]//g;
+      
+      my @j_clauses = reverse split /\s(and|on)\s/, $j_clause;
+      my $c = $self->{safety_character};
+      my $join_re = qr/([$c]+)\.[$c]+[^$c].*?([$c]+)\.[$c]+/sm;
+      for my $clause (@j_clauses) {
+        if ($clause =~ $join_re) {
+          $table1 = $1;
+          $table2 = $2;
+          last;
+        }                
+      }
+    }
+    croak qq{join clause must have two table name after "on" keyword. } .
+        qq{"$join_clause" is passed }  . _subname
+      unless defined $table1 && defined $table2;
+    croak qq{right side table of "$join_clause" must be unique } . _subname
+      if exists $tree->{$table2};
+    croak qq{Same table "$table1" is specified} . _subname
+      if $table1 eq $table2;
+    $tree->{$table2}
+      = {position => $i, parent => $table1, join => $join_clause};
+  }
+  
+  # Search need tables
+  my $need_tables = {};
+  $self->_need_tables($tree, $need_tables, $join_tables);
+  my @need_tables = sort { $tree->{$a}{position} <=> $tree->{$b}{position} }
+    keys %$need_tables;
+  
+  # Add join clause
+  $$sql .= $tree->{$_}{join} . ' ' for @need_tables;
 }
 
 sub _quote {
-    my $self = shift;
-    return $self->{reserved_word_quote} || $self->quote || '';
+  my $self = shift;
+  return $self->{reserved_word_quote} || $self->quote || '';
 }
 
 sub _remove_duplicate_table {
-    my ($self, $tables, $main_table) = @_;
-    
-    # Remove duplicate table
-    my %tables = map {defined $_ ? ($_ => 1) : ()} @$tables;
-    delete $tables{$main_table} if $main_table;
-    
-    my $new_tables = [keys %tables, $main_table ? $main_table : ()];
-    if (my $q = $self->_quote) {
-        $q = quotemeta($q);
-        $_ =~ s/[$q]//g for @$new_tables;
-    }
+  my ($self, $tables, $main_table) = @_;
+  
+  # Remove duplicate table
+  my %tables = map {defined $_ ? ($_ => 1) : ()} @$tables;
+  delete $tables{$main_table} if $main_table;
+  
+  my $new_tables = [keys %tables, $main_table ? $main_table : ()];
+  if (my $q = $self->_quote) {
+    $q = quotemeta($q);
+    $_ =~ s/[$q]//g for @$new_tables;
+  }
 
-    return $new_tables;
+  return $new_tables;
 }
 
 sub _search_tables {
-    my ($self, $source) = @_;
-    
-    # Search tables
-    my $tables = [];
-    my $safety_character = $self->{safety_character};
-    my $q = $self->_quote;
-    my $quoted_safety_character_re = $self->q("?([$safety_character]+)", 1);
-    my $table_re = $q ? qr/(?:^|[^$safety_character])${quoted_safety_character_re}?\./
-                      : qr/(?:^|[^$safety_character])([$safety_character]+)\./;
-    while ($source =~ /$table_re/g) {
-        push @$tables, $1;
-    }
-    
-    return $tables;
+  my ($self, $source) = @_;
+  
+  # Search tables
+  my $tables = [];
+  my $safety_character = $self->{safety_character};
+  my $q = $self->_quote;
+  my $quoted_safety_character_re = $self->q("?([$safety_character]+)", 1);
+  my $table_re = $q ? qr/(?:^|[^$safety_character])${quoted_safety_character_re}?\./
+    : qr/(?:^|[^$safety_character])([$safety_character]+)\./;
+  while ($source =~ /$table_re/g) { push @$tables, $1 }
+  return $tables;
 }
 
 sub _where_clause_and_param {
-    my ($self, $where, $where_param, $id, $primary_key, $table) = @_;
-
-    $where ||= {};
-    $where = $self->_id_to_param($id, $primary_key, $table) if defined $id;
-    $where_param ||= {};
-    my $w = {};
-    my $where_clause = '';
-
-    my $obj;
-    
-    if (ref $where) {
-        if (ref $where eq 'HASH') {
-            my $clause = ['and'];
-            my $column_join = '';
-            for my $column (keys %$where) {
-                $column_join .= $column;
-                my $table;
-                my $c;
-                if ($column =~ /(?:(.*?)\.)?(.*)/) {
-                    $table = $1;
-                    $c = $2;
-                }
-                
-                my $table_quote;
-                $table_quote = $self->q($table) if defined $table;
-                my $column_quote = $self->q($c);
-                $column_quote = $table_quote . '.' . $column_quote
-                  if defined $table_quote;
-                push @$clause, "$column_quote = :$column";
-            }
-
-            # Check unsafety column
-            my $safety = $self->{safety_character};
-            unless ($column_join =~ /^[$safety\.]+$/) {
-                for my $column (keys %$where) {
-                    croak qq{"$column" is not safety column name } . _subname
-                      unless $column =~ /^[$safety\.]+$/;
-                }
-            }
-            
-            $obj = $self->where(clause => $clause, param => $where);
-        }
-        elsif (ref $where eq 'DBIx::Custom::Where') { $obj = $where }
-        elsif (ref $where eq 'ARRAY') {
-            $obj = $self->where(clause => $where->[0], param => $where->[1]);
+  my ($self, $where, $where_param, $id, $primary_key, $table) = @_;
+
+  $where ||= {};
+  $where = $self->_id_to_param($id, $primary_key, $table) if defined $id;
+  $where_param ||= {};
+  my $w = {};
+  my $where_clause = '';
+
+  my $obj;
+  
+  if (ref $where) {
+    if (ref $where eq 'HASH') {
+      my $clause = ['and'];
+      my $column_join = '';
+      for my $column (keys %$where) {
+        $column_join .= $column;
+        my $table;
+        my $c;
+        if ($column =~ /(?:(.*?)\.)?(.*)/) {
+          $table = $1;
+          $c = $2;
         }
         
-        # Check where argument
-        croak qq{"where" must be hash reference or DBIx::Custom::Where object}
-            . qq{or array reference, which contains where clause and parameter}
-            . _subname
-          unless ref $obj eq 'DBIx::Custom::Where';
-
-        $w->{param} = keys %$where_param
-                    ? $self->merge_param($where_param, $obj->param)
-                    : $obj->param;
-        $w->{clause} = $obj->to_string;
-    }
-    elsif ($where) {
-        $w->{clause} = "where $where";
-        $w->{param} = $where_param;
-    }
-    
-    return $w;
+        my $table_quote;
+        $table_quote = $self->q($table) if defined $table;
+        my $column_quote = $self->q($c);
+        $column_quote = $table_quote . '.' . $column_quote
+          if defined $table_quote;
+        push @$clause, "$column_quote = :$column";
+      }
+
+      # Check unsafety column
+      my $safety = $self->{safety_character};
+      unless ($column_join =~ /^[$safety\.]+$/) {
+        for my $column (keys %$where) {
+          croak qq{"$column" is not safety column name } . _subname
+            unless $column =~ /^[$safety\.]+$/;
+        }
+      }
+      
+      $obj = $self->where(clause => $clause, param => $where);
+    }
+    elsif (ref $where eq 'DBIx::Custom::Where') { $obj = $where }
+    elsif (ref $where eq 'ARRAY') {
+      $obj = $self->where(clause => $where->[0], param => $where->[1]);
+    }
+    
+    # Check where argument
+    croak qq{"where" must be hash reference or DBIx::Custom::Where object}
+        . qq{or array reference, which contains where clause and parameter}
+        . _subname
+      unless ref $obj eq 'DBIx::Custom::Where';
+
+    $w->{param} = keys %$where_param
+      ? $self->merge_param($where_param, $obj->param)
+      : $obj->param;
+    $w->{clause} = $obj->to_string;
+  }
+  elsif ($where) {
+    $w->{clause} = "where $where";
+    $w->{param} = $where_param;
+  }
+  
+  return $w;
 }
 
 sub _apply_filter {
-    my ($self, $table, @cinfos) = @_;
-
-    # Initialize filters
-    $self->{filter} ||= {};
-    $self->{filter}{on} = 1;
-    $self->{filter}{out} ||= {};
-    $self->{filter}{in} ||= {};
-    $self->{filter}{end} ||= {};
+  my ($self, $table, @cinfos) = @_;
+
+  # Initialize filters
+  $self->{filter} ||= {};
+  $self->{filter}{on} = 1;
+  $self->{filter}{out} ||= {};
+  $self->{filter}{in} ||= {};
+  $self->{filter}{end} ||= {};
+  
+  # Usage
+  my $usage = "Usage: \$dbi->apply_filter(" .
+    "TABLE, COLUMN1, {in => INFILTER1, out => OUTFILTER1, end => ENDFILTER1}, " .
+    "COLUMN2, {in => INFILTER2, out => OUTFILTER2, end => ENDFILTER2}, ...)";
+  
+  # Apply filter
+  for (my $i = 0; $i < @cinfos; $i += 2) {
     
-    # Usage
-    my $usage = "Usage: \$dbi->apply_filter(" .
-                "TABLE, COLUMN1, {in => INFILTER1, out => OUTFILTER1, end => ENDFILTER1}, " .
-                "COLUMN2, {in => INFILTER2, out => OUTFILTER2, end => ENDFILTER2}, ...)";
+    # Column
+    my $column = $cinfos[$i];
+    if (ref $column eq 'ARRAY') {
+      for my $c (@$column) { push @cinfos, $c, $cinfos[$i + 1] }
+      next;
+    }
     
-    # Apply filter
-    for (my $i = 0; $i < @cinfos; $i += 2) {
-        
-        # Column
-        my $column = $cinfos[$i];
-        if (ref $column eq 'ARRAY') {
-            for my $c (@$column) {
-                push @cinfos, $c, $cinfos[$i + 1];
-            }
-            next;
-        }
-        
-        # Filter infomation
-        my $finfo = $cinfos[$i + 1] || {};
-        croak "$usage (table: $table) " . _subname
-          unless  ref $finfo eq 'HASH';
-        for my $ftype (keys %$finfo) {
-            croak "$usage (table: $table) " . _subname
-              unless $ftype eq 'in' || $ftype eq 'out' || $ftype eq 'end'; 
-        }
-        
-        # Set filters
-        for my $way (qw/in out end/) {
-        
-            # Filter
-            my $filter = $finfo->{$way};
-            
-            # Filter state
-            my $state = !exists $finfo->{$way} ? 'not_exists'
-                      : !defined $filter        ? 'not_defined'
-                      : ref $filter eq 'CODE'   ? 'code'
-                      : 'name';
-            
-            # Filter is not exists
-            next if $state eq 'not_exists';
-            
-            # Check filter name
-            croak qq{Filter "$filter" is not registered } . _subname
-              if  $state eq 'name'
-               && ! exists $self->filters->{$filter};
-            
-            # Set filter
-            my $f = $state eq 'not_defined' ? undef
-                  : $state eq 'code'        ? $filter
-                  : $self->filters->{$filter};
-            $self->{filter}{$way}{$table}{$column} = $f;
-            $self->{filter}{$way}{$table}{"$table.$column"} = $f;
-            $self->{filter}{$way}{$table}{"${table}__$column"} = $f;
-            $self->{filter}{$way}{$table}{"${table}-$column"} = $f;
-        }
+    # Filter infomation
+    my $finfo = $cinfos[$i + 1] || {};
+    croak "$usage (table: $table) " . _subname
+      unless  ref $finfo eq 'HASH';
+    for my $ftype (keys %$finfo) {
+      croak "$usage (table: $table) " . _subname
+        unless $ftype eq 'in' || $ftype eq 'out' || $ftype eq 'end'; 
     }
     
-    return $self;
+    # Set filters
+    for my $way (qw/in out end/) {
+  
+      # Filter
+      my $filter = $finfo->{$way};
+      
+      # Filter state
+      my $state = !exists $finfo->{$way} ? 'not_exists'
+        : !defined $filter        ? 'not_defined'
+        : ref $filter eq 'CODE'   ? 'code'
+        : 'name';
+      
+      # Filter is not exists
+      next if $state eq 'not_exists';
+      
+      # Check filter name
+      croak qq{Filter "$filter" is not registered } . _subname
+        if  $state eq 'name' && ! exists $self->filters->{$filter};
+      
+      # Set filter
+      my $f = $state eq 'not_defined' ? undef
+        : $state eq 'code' ? $filter
+        : $self->filters->{$filter};
+      $self->{filter}{$way}{$table}{$column} = $f;
+      $self->{filter}{$way}{$table}{"$table.$column"} = $f;
+      $self->{filter}{$way}{$table}{"${table}__$column"} = $f;
+      $self->{filter}{$way}{$table}{"${table}-$column"} = $f;
+    }
+  }
+  
+  return $self;
 }
 
 # DEPRECATED!
@@ -1783,270 +1753,270 @@ has filter_check  => 1;
 has 'reserved_word_quote';
 has dbi_option => sub { {} };
 has default_dbi_option => sub {
-    warn "default_dbi_option is DEPRECATED! use default_option instead";
-    return shift->default_option;
+  warn "default_dbi_option is DEPRECATED! use default_option instead";
+  return shift->default_option;
 };
 
 # DEPRECATED
 sub tag_parse {
-   my $self = shift;
-   warn "tag_parse is DEPRECATED! use \$ENV{DBIX_CUSTOM_TAG_PARSE} " .
-         "environment variable";
-    if (@_) {
-        $self->{tag_parse} = $_[0];
-        return $self;
-    }
-    return $self->{tag_parse};
+ my $self = shift;
+ warn "tag_parse is DEPRECATED! use \$ENV{DBIX_CUSTOM_TAG_PARSE} " .
+   "environment variable";
+  if (@_) {
+    $self->{tag_parse} = $_[0];
+    return $self;
+  }
+  return $self->{tag_parse};
 }
 
 # DEPRECATED!
 sub method {
-    warn "method is DEPRECATED! use helper instead";
-    return shift->helper(@_);
+  warn "method is DEPRECATED! use helper instead";
+  return shift->helper(@_);
 }
 
 # DEPRECATED!
 sub assign_param {
-    my $self = shift;
-    warn "assing_param is DEPRECATED! use assign_clause instead";
-    return $self->assign_clause(@_);
+  my $self = shift;
+  warn "assing_param is DEPRECATED! use assign_clause instead";
+  return $self->assign_clause(@_);
 }
 
 # DEPRECATED
 sub update_param {
-    my ($self, $param, $opts) = @_;
-    
-    warn "update_param is DEPRECATED! use assign_clause instead.";
-    
-    # Create update parameter tag
-    my $tag = $self->assign_clause($param, $opts);
-    $tag = "set $tag" unless $opts->{no_set};
+  my ($self, $param, $opts) = @_;
+  
+  warn "update_param is DEPRECATED! use assign_clause instead.";
+  
+  # Create update parameter tag
+  my $tag = $self->assign_clause($param, $opts);
+  $tag = "set $tag" unless $opts->{no_set};
 
-    return $tag;
+  return $tag;
 }
 
 # DEPRECATED!
 sub create_query {
-    warn "create_query is DEPRECATED! use query option of each method";
-    shift->_create_query(@_);
+  warn "create_query is DEPRECATED! use query option of each method";
+  shift->_create_query(@_);
 }
 
 # DEPRECATED!
 sub apply_filter {
-    my $self = shift;
-    
-    warn "apply_filter is DEPRECATED!";
-    return $self->_apply_filter(@_);
+  my $self = shift;
+  
+  warn "apply_filter is DEPRECATED!";
+  return $self->_apply_filter(@_);
 }
 
 # DEPRECATED!
 sub select_at {
-    my ($self, %opt) = @_;
-
-    warn "select_at is DEPRECATED! use select method id option instead";
-
-    # Options
-    my $primary_keys = delete $opt{primary_key};
-    my $where = delete $opt{where};
-    my $param = delete $opt{param};
-    
-    # Table
-    croak qq{"table" option must be specified } . _subname
-      unless $opt{table};
-    my $table = ref $opt{table} ? $opt{table}->[-1] : $opt{table};
-    
-    # Create where parameter
-    my $where_param = $self->_id_to_param($where, $primary_keys);
-    
-    return $self->select(where => $where_param, %opt);
+  my ($self, %opt) = @_;
+
+  warn "select_at is DEPRECATED! use select method id option instead";
+
+  # Options
+  my $primary_keys = delete $opt{primary_key};
+  my $where = delete $opt{where};
+  my $param = delete $opt{param};
+  
+  # Table
+  croak qq{"table" option must be specified } . _subname
+    unless $opt{table};
+  my $table = ref $opt{table} ? $opt{table}->[-1] : $opt{table};
+  
+  # Create where parameter
+  my $where_param = $self->_id_to_param($where, $primary_keys);
+  
+  return $self->select(where => $where_param, %opt);
 }
 
 # DEPRECATED!
 sub delete_at {
-    my ($self, %opt) = @_;
+  my ($self, %opt) = @_;
 
-    warn "delete_at is DEPRECATED! use delete method id option instead";
-    
-    # Options
-    my $primary_keys = delete $opt{primary_key};
-    my $where = delete $opt{where};
-    
-    # Create where parameter
-    my $where_param = $self->_id_to_param($where, $primary_keys);
-    
-    return $self->delete(where => $where_param, %opt);
+  warn "delete_at is DEPRECATED! use delete method id option instead";
+  
+  # Options
+  my $primary_keys = delete $opt{primary_key};
+  my $where = delete $opt{where};
+  
+  # Create where parameter
+  my $where_param = $self->_id_to_param($where, $primary_keys);
+  
+  return $self->delete(where => $where_param, %opt);
 }
 
 # DEPRECATED!
 sub update_at {
-    my $self = shift;
-
-    warn "update_at is DEPRECATED! use update method id option instead";
-    
-    # Options
-    my $param;
-    $param = shift if @_ % 2;
-    my %opt = @_;
-    my $primary_keys = delete $opt{primary_key};
-    my $where = delete $opt{where};
-    my $p = delete $opt{param} || {};
-    $param  ||= $p;
-    
-    # Create where parameter
-    my $where_param = $self->_id_to_param($where, $primary_keys);
-    
-    return $self->update(where => $where_param, param => $param, %opt);
+  my $self = shift;
+
+  warn "update_at is DEPRECATED! use update method id option instead";
+  
+  # Options
+  my $param;
+  $param = shift if @_ % 2;
+  my %opt = @_;
+  my $primary_keys = delete $opt{primary_key};
+  my $where = delete $opt{where};
+  my $p = delete $opt{param} || {};
+  $param  ||= $p;
+  
+  # Create where parameter
+  my $where_param = $self->_id_to_param($where, $primary_keys);
+  
+  return $self->update(where => $where_param, param => $param, %opt);
 }
 
 # DEPRECATED!
 sub insert_at {
-    my $self = shift;
-    
-    warn "insert_at is DEPRECATED! use insert method id option instead";
-    
-    # Options
-    my $param;
-    $param = shift if @_ % 2;
-    my %opt = @_;
-    my $primary_key = delete $opt{primary_key};
-    $primary_key = [$primary_key] unless ref $primary_key;
-    my $where = delete $opt{where};
-    my $p = delete $opt{param} || {};
-    $param  ||= $p;
-    
-    # Create where parameter
-    my $where_param = $self->_id_to_param($where, $primary_key);
-    $param = $self->merge_param($where_param, $param);
-    
-    return $self->insert(param => $param, %opt);
+  my $self = shift;
+  
+  warn "insert_at is DEPRECATED! use insert method id option instead";
+  
+  # Options
+  my $param;
+  $param = shift if @_ % 2;
+  my %opt = @_;
+  my $primary_key = delete $opt{primary_key};
+  $primary_key = [$primary_key] unless ref $primary_key;
+  my $where = delete $opt{where};
+  my $p = delete $opt{param} || {};
+  $param  ||= $p;
+  
+  # Create where parameter
+  my $where_param = $self->_id_to_param($where, $primary_key);
+  $param = $self->merge_param($where_param, $param);
+  
+  return $self->insert(param => $param, %opt);
 }
 
 # DEPRECATED!
 sub register_tag {
-    my $self = shift;
-    
-    warn "register_tag is DEPRECATED!";
-    
-    # Merge tag
-    my $tags = ref $_[0] eq 'HASH' ? $_[0] : {@_};
-    $self->{_tags} = {%{$self->{_tags} || {}}, %$tags};
-    
-    return $self;
+  my $self = shift;
+  
+  warn "register_tag is DEPRECATED!";
+  
+  # Merge tag
+  my $tags = ref $_[0] eq 'HASH' ? $_[0] : {@_};
+  $self->{_tags} = {%{$self->{_tags} || {}}, %$tags};
+  
+  return $self;
 }
 
 # DEPRECATED!
 sub register_tag_processor {
-    my $self = shift;
-    warn "register_tag_processor is DEPRECATED!";
-    # Merge tag
-    my $tag_processors = ref $_[0] eq 'HASH' ? $_[0] : {@_};
-    $self->{_tags} = {%{$self->{_tags} || {}}, %{$tag_processors}};
-    return $self;
+  my $self = shift;
+  warn "register_tag_processor is DEPRECATED!";
+  # Merge tag
+  my $tag_processors = ref $_[0] eq 'HASH' ? $_[0] : {@_};
+  $self->{_tags} = {%{$self->{_tags} || {}}, %{$tag_processors}};
+  return $self;
 }
 
 # DEPRECATED!
 sub default_bind_filter {
-    my $self = shift;
-    
-    warn "default_bind_filter is DEPRECATED!";
+  my $self = shift;
+  
+  warn "default_bind_filter is DEPRECATED!";
+  
+  if (@_) {
+    my $fname = $_[0];
     
-    if (@_) {
-        my $fname = $_[0];
-        
-        if (@_ && !$fname) {
-            $self->{default_out_filter} = undef;
-        }
-        else {
-            croak qq{Filter "$fname" is not registered}
-              unless exists $self->filters->{$fname};
-        
-            $self->{default_out_filter} = $self->filters->{$fname};
-        }
-        return $self;
+    if (@_ && !$fname) {
+      $self->{default_out_filter} = undef;
     }
-    
-    return $self->{default_out_filter};
+    else {
+      croak qq{Filter "$fname" is not registered}
+        unless exists $self->filters->{$fname};
+  
+      $self->{default_out_filter} = $self->filters->{$fname};
+    }
+    return $self;
+  }
+  
+  return $self->{default_out_filter};
 }
 
 # DEPRECATED!
 sub default_fetch_filter {
-    my $self = shift;
+  my $self = shift;
 
-    warn "default_fetch_filter is DEPRECATED!";
-    
-    if (@_) {
-        my $fname = $_[0];
+  warn "default_fetch_filter is DEPRECATED!";
+  
+  if (@_) {
+    my $fname = $_[0];
 
-        if (@_ && !$fname) {
-            $self->{default_in_filter} = undef;
-        }
-        else {
-            croak qq{Filter "$fname" is not registered}
-              unless exists $self->filters->{$fname};
-        
-            $self->{default_in_filter} = $self->filters->{$fname};
-        }
-        
-        return $self;
+    if (@_ && !$fname) {
+      $self->{default_in_filter} = undef;
+    }
+    else {
+      croak qq{Filter "$fname" is not registered}
+        unless exists $self->filters->{$fname};
+  
+      $self->{default_in_filter} = $self->filters->{$fname};
     }
     
-    return $self->{default_in_filter};
+    return $self;
+  }
+  
+  return $self->{default_in_filter};
 }
 
 # DEPRECATED!
 sub insert_param {
-    my $self = shift;
-    warn "insert_param is DEPRECATED! use values_clause instead";
-    return $self->values_clause(@_);
+  my $self = shift;
+  warn "insert_param is DEPRECATED! use values_clause instead";
+  return $self->values_clause(@_);
 }
 
 # DEPRECATED!
 sub insert_param_tag {
-    warn "insert_param_tag is DEPRECATED! " .
-         "use insert_param instead!";
-    return shift->insert_param(@_);
+  warn "insert_param_tag is DEPRECATED! " .
+    "use insert_param instead!";
+  return shift->insert_param(@_);
 }
 
 # DEPRECATED!
 sub update_param_tag {
-    warn "update_param_tag is DEPRECATED! " .
-         "use update_param instead";
-    return shift->update_param(@_);
+  warn "update_param_tag is DEPRECATED! " .
+    "use update_param instead";
+  return shift->update_param(@_);
 }
 # DEPRECATED!
 sub _push_relation {
-    my ($self, $sql, $tables, $relation, $need_where) = @_;
-    
-    if (keys %{$relation || {}}) {
-        $$sql .= $need_where ? 'where ' : 'and ';
-        for my $rcolumn (keys %$relation) {
-            my $table1 = (split (/\./, $rcolumn))[0];
-            my $table2 = (split (/\./, $relation->{$rcolumn}))[0];
-            push @$tables, ($table1, $table2);
-            $$sql .= "$rcolumn = " . $relation->{$rcolumn} .  'and ';
-        }
+  my ($self, $sql, $tables, $relation, $need_where) = @_;
+  
+  if (keys %{$relation || {}}) {
+    $$sql .= $need_where ? 'where ' : 'and ';
+    for my $rcolumn (keys %$relation) {
+      my $table1 = (split (/\./, $rcolumn))[0];
+      my $table2 = (split (/\./, $relation->{$rcolumn}))[0];
+      push @$tables, ($table1, $table2);
+      $$sql .= "$rcolumn = " . $relation->{$rcolumn} .  'and ';
     }
-    $$sql =~ s/and $/ /;
+  }
+  $$sql =~ s/and $/ /;
 }
 
 # DEPRECATED!
 sub _add_relation_table {
-    my ($self, $tables, $relation) = @_;
-    
-    if (keys %{$relation || {}}) {
-        for my $rcolumn (keys %$relation) {
-            my $table1 = (split (/\./, $rcolumn))[0];
-            my $table2 = (split (/\./, $relation->{$rcolumn}))[0];
-            my $table1_exists;
-            my $table2_exists;
-            for my $table (@$tables) {
-                $table1_exists = 1 if $table eq $table1;
-                $table2_exists = 1 if $table eq $table2;
-            }
-            unshift @$tables, $table1 unless $table1_exists;
-            unshift @$tables, $table2 unless $table2_exists;
-        }
-    }
+  my ($self, $tables, $relation) = @_;
+  
+  if (keys %{$relation || {}}) {
+    for my $rcolumn (keys %$relation) {
+      my $table1 = (split (/\./, $rcolumn))[0];
+      my $table2 = (split (/\./, $relation->{$rcolumn}))[0];
+      my $table1_exists;
+      my $table2_exists;
+      for my $table (@$tables) {
+        $table1_exists = 1 if $table eq $table1;
+        $table2_exists = 1 if $table eq $table2;
+      }
+      unshift @$tables, $table1 unless $table1_exists;
+      unshift @$tables, $table2 unless $table2_exists;
+    }
+  }
 }
 
 1;
@@ -2057,58 +2027,58 @@ DBIx::Custom - DBI extension to execute insert, update, delete, and select easil
 
 =head1 SYNOPSIS
 
-    use DBIx::Custom;
-    
-    # Connect
-    my $dbi = DBIx::Custom->connect(
-        dsn => "dbi:mysql:database=dbname",
-        user => 'ken',
-        password => '!LFKD%$&',
-        option => {mysql_enable_utf8 => 1}
-    );
-
-    # Insert 
-    $dbi->insert({title => 'Perl', author => 'Ken'}, table  => 'book');
-    
-    # Update 
-    $dbi->update({title => 'Perl', author => 'Ken'}, table  => 'book',
-      where  => {id => 5});
-    
-    # Delete
-    $dbi->delete(table  => 'book', where => {author => 'Ken'});
-
-    # Select
-    my $result = $dbi->select(table  => 'book',
-      column => ['title', 'author'], where  => {author => 'Ken'});
-
-    # Select, more complex
-    my $result = $dbi->select(
-        table  => 'book',
-        column => [
-            {book => [qw/title author/]},
-            {company => ['name']}
-        ],
-        where  => {'book.author' => 'Ken'},
-        join => ['left outer join company on book.company_id = company.id'],
-        append => 'order by id limit 5'
-    );
-    
-    # Fetch
-    while (my $row = $result->fetch) {
-        
-    }
-    
-    # Fetch as hash
-    while (my $row = $result->fetch_hash) {
-        
-    }
-    
-    # Execute SQL with parameter.
-    $dbi->execute(
-        "select id from book where author = :author and title like :title",
-        {author => 'ken', title => '%Perl%'}
-    );
-    
+  use DBIx::Custom;
+  
+  # Connect
+  my $dbi = DBIx::Custom->connect(
+    dsn => "dbi:mysql:database=dbname",
+    user => 'ken',
+    password => '!LFKD%$&',
+    option => {mysql_enable_utf8 => 1}
+  );
+
+  # Insert 
+  $dbi->insert({title => 'Perl', author => 'Ken'}, table  => 'book');
+  
+  # Update 
+  $dbi->update({title => 'Perl', author => 'Ken'}, table  => 'book',
+    where  => {id => 5});
+  
+  # Delete
+  $dbi->delete(table  => 'book', where => {author => 'Ken'});
+
+  # Select
+  my $result = $dbi->select(table  => 'book',
+    column => ['title', 'author'], where  => {author => 'Ken'});
+
+  # Select, more complex
+  my $result = $dbi->select(
+    table  => 'book',
+    column => [
+      {book => [qw/title author/]},
+      {company => ['name']}
+    ],
+    where  => {'book.author' => 'Ken'},
+    join => ['left outer join company on book.company_id = company.id'],
+    append => 'order by id limit 5'
+  );
+  
+  # Fetch
+  while (my $row = $result->fetch) {
+      
+  }
+  
+  # Fetch as hash
+  while (my $row = $result->fetch_hash) {
+      
+  }
+  
+  # Execute SQL with parameter.
+  $dbi->execute(
+    "select id from book where author = :author and title like :title",
+    {author => 'ken', title => '%Perl%'}
+  );
+  
 =head1 DESCRIPTION
 
 L<DBIx::Custom> is L<DBI> wrapper module to execute SQL easily.
@@ -2170,8 +2140,8 @@ L<DBIx::Custom::Order>
 
 =head2 C<connector>
 
-    my $connector = $dbi->connector;
-    $dbi = $dbi->connector($connector);
+  my $connector = $dbi->connector;
+  $dbi = $dbi->connector($connector);
 
 Connection manager object. if C<connector> is set, you can get C<dbh>
 through connection manager. Conection manager object must have C<dbh> mehtod.
@@ -2179,50 +2149,50 @@ through connection manager. Conection manager object must have C<dbh> mehtod.
 This is L<DBIx::Connector> example. Please pass
 C<default_option> to L<DBIx::Connector> C<new> method.
 
-    my $connector = DBIx::Connector->new(
-        "dbi:mysql:database=$database",
-        $user,
-        $password,
-        DBIx::Custom->new->default_option
-    );
-    
-    my $dbi = DBIx::Custom->connect(connector => $connector);
+  my $connector = DBIx::Connector->new(
+    "dbi:mysql:database=$database",
+    $user,
+    $password,
+    DBIx::Custom->new->default_option
+  );
+  
+  my $dbi = DBIx::Custom->connect(connector => $connector);
 
 If C<connector> is set to 1 when connect method is called,
 L<DBIx::Connector> is automatically set to C<connector>
 
-    my $dbi = DBIx::Custom->connect(
-      dsn => $dsn, user => $user, password => $password, connector => 1);
-    
-    my $connector = $dbi->connector; # DBIx::Connector
+  my $dbi = DBIx::Custom->connect(
+    dsn => $dsn, user => $user, password => $password, connector => 1);
+  
+  my $connector = $dbi->connector; # DBIx::Connector
 
 Note that L<DBIx::Connector> must be installed.
 
 =head2 C<dsn>
 
-    my $dsn = $dbi->dsn;
-    $dbi = $dbi->dsn("DBI:mysql:database=dbname");
+  my $dsn = $dbi->dsn;
+  $dbi = $dbi->dsn("DBI:mysql:database=dbname");
 
 Data source name, used when C<connect> method is executed.
 
 =head2 C<default_option>
 
-    my $default_option = $dbi->default_option;
-    $dbi = $dbi->default_option($default_option);
+  my $default_option = $dbi->default_option;
+  $dbi = $dbi->default_option($default_option);
 
 L<DBI> default option, used when C<connect> method is executed,
 default to the following values.
 
-    {
-        RaiseError => 1,
-        PrintError => 0,
-        AutoCommit => 1,
-    }
+  {
+    RaiseError => 1,
+    PrintError => 0,
+    AutoCommit => 1,
+  }
 
 =head2 C<exclude_table>
 
-    my $exclude_table = $dbi->exclude_table;
-    $dbi = $dbi->exclude_table(qr/pg_/);
+  my $exclude_table = $dbi->exclude_table;
+  $dbi = $dbi->exclude_table(qr/pg_/);
 
 Excluded table regex.
 C<each_column>, C<each_table>, C<type_rule>,
@@ -2230,31 +2200,31 @@ and C<setup_model> methods ignore matching tables.
 
 =head2 C<filters>
 
-    my $filters = $dbi->filters;
-    $dbi = $dbi->filters(\%filters);
+  my $filters = $dbi->filters;
+  $dbi = $dbi->filters(\%filters);
 
 Filters, registered by C<register_filter> method.
 
 =head2 C<last_sql>
 
-    my $last_sql = $dbi->last_sql;
-    $dbi = $dbi->last_sql($last_sql);
+  my $last_sql = $dbi->last_sql;
+  $dbi = $dbi->last_sql($last_sql);
 
 Get last successed SQL executed by C<execute> method.
 
 =head2 C<now>
 
-    my $now = $dbi->now;
-    $dbi = $dbi->now($now);
+  my $now = $dbi->now;
+  $dbi = $dbi->now($now);
 
 Code reference which return current time, default to the following code reference.
 
-    sub {
-        my ($sec, $min, $hour, $mday, $mon, $year) = localtime;
-        $mon++;
-        $year += 1900;
-        return sprintf("%04d-%02d-%02d %02d:%02d:%02d");
-    }
+  sub {
+    my ($sec, $min, $hour, $mday, $mon, $year) = localtime;
+    $mon++;
+    $year += 1900;
+    return sprintf("%04d-%02d-%02d %02d:%02d:%02d");
+  }
 
 This return the time like C<2011-10-14 05:05:27>.
 
@@ -2263,36 +2233,36 @@ and C<update> method's C<updated_at> option.
 
 =head2 C<models>
 
-    my $models = $dbi->models;
-    $dbi = $dbi->models(\%models);
+  my $models = $dbi->models;
+  $dbi = $dbi->models(\%models);
 
 Models, included by C<include_model> method.
 
 =head2 C<option>
 
-    my $option = $dbi->option;
-    $dbi = $dbi->option($option);
+  my $option = $dbi->option;
+  $dbi = $dbi->option($option);
 
 L<DBI> option, used when C<connect> method is executed.
 Each value in option override the value of C<default_option>.
 
 =head2 C<password>
 
-    my $password = $dbi->password;
-    $dbi = $dbi->password('lkj&le`@s');
+  my $password = $dbi->password;
+  $dbi = $dbi->password('lkj&le`@s');
 
 Password, used when C<connect> method is executed.
 
 =head2 C<query_builder>
 
-    my $builder = $dbi->query_builder;
+  my $builder = $dbi->query_builder;
 
 Creat query builder. This is L<DBIx::Custom::QueryBuilder>.
 
 =head2 C<quote>
 
-     my quote = $dbi->quote;
-     $dbi = $dbi->quote('"');
+  my quote = $dbi->quote;
+  $dbi = $dbi->quote('"');
 
 Reserved word quote.
 Default to double quote '"' except for mysql.
@@ -2300,27 +2270,27 @@ In mysql, default to back quote '`'
 
 You can set quote pair.
 
-    $dbi->quote('[]');
+  $dbi->quote('[]');
 
 =head2 C<result_class>
 
-    my $result_class = $dbi->result_class;
-    $dbi = $dbi->result_class('DBIx::Custom::Result');
+  my $result_class = $dbi->result_class;
+  $dbi = $dbi->result_class('DBIx::Custom::Result');
 
 Result class, default to L<DBIx::Custom::Result>.
 
 =head2 C<safety_character>
 
-    my $safety_character = $dbi->safety_character;
-    $dbi = $dbi->safety_character($character);
+  my $safety_character = $dbi->safety_character;
+  $dbi = $dbi->safety_character($character);
 
 Regex of safety character for table and column name, default to '\w'.
 Note that you don't have to specify like '[\w]'.
 
 =head2 C<separator>
 
-    my $separator = $dbi->separator;
-    $dbi = $dbi->separator('-');
+  my $separator = $dbi->separator;
+  $dbi = $dbi->separator('-');
 
 Separator which join table name and column name.
 This have effect to C<column> and C<mycolumn> method,
@@ -2330,56 +2300,56 @@ Default to C<.>.
 
 =head2 C<tag_parse>
 
-    my $tag_parse = $dbi->tag_parse(0);
-    $dbi = $dbi->tag_parse;
+  my $tag_parse = $dbi->tag_parse(0);
+  $dbi = $dbi->tag_parse;
 
 Enable DEPRECATED tag parsing functionality, default to 1.
 If you want to disable tag parsing functionality, set to 0.
 
 =head2 C<user>
 
-    my $user = $dbi->user;
-    $dbi = $dbi->user('Ken');
+  my $user = $dbi->user;
+  $dbi = $dbi->user('Ken');
 
 User name, used when C<connect> method is executed.
 
 =head2 C<user_column_info>
 
-    my $user_column_info = $dbi->user_column_info;
-    $dbi = $dbi->user_column_info($user_column_info);
+  my $user_column_info = $dbi->user_column_info;
+  $dbi = $dbi->user_column_info($user_column_info);
 
 You can set the date like the following one.
 
-    [
-        {table => 'book', column => 'title', info => {...}},
-        {table => 'author', column => 'name', info => {...}}
-    ]
+  [
+    {table => 'book', column => 'title', info => {...}},
+    {table => 'author', column => 'name', info => {...}}
+  ]
 
 Usually, you set return value of C<get_column_info>.
 
-    my $user_column_info
-      = $dbi->get_column_info(exclude_table => qr/^system/);
-    $dbi->user_column_info($user_column_info);
+  my $user_column_info
+    = $dbi->get_column_info(exclude_table => qr/^system/);
+  $dbi->user_column_info($user_column_info);
 
 If C<user_column_info> is set, C<each_column> use C<user_column_info>
 to find column info. this is very fast.
 
 =head2 C<user_table_info>
 
-    my $user_table_info = $dbi->user_table_info;
-    $dbi = $dbi->user_table_info($user_table_info);
+  my $user_table_info = $dbi->user_table_info;
+  $dbi = $dbi->user_table_info($user_table_info);
 
 You can set the following data.
 
-    [
-        {table => 'book', info => {...}},
-        {table => 'author', info => {...}}
-    ]
+  [
+    {table => 'book', info => {...}},
+    {table => 'author', info => {...}}
+  ]
 
 Usually, you can set return value of C<get_table_info>.
 
-    my $user_table_info = $dbi->get_table_info(exclude => qr/^system/);
-    $dbi->user_table_info($user_table_info);
+  my $user_table_info = $dbi->get_table_info(exclude => qr/^system/);
+  $dbi->user_table_info($user_table_info);
 
 If C<user_table_info> is set, C<each_table> use C<user_table_info>
 to find table info.
@@ -2392,55 +2362,55 @@ and implements the following new ones.
 
 =head2 C<available_datatype>
 
-    print $dbi->available_datatype;
+  print $dbi->available_datatype;
 
 Get available data types. You can use these data types
 in C<type rule>'s C<from1> and C<from2> section.
 
 =head2 C<available_typename>
 
-    print $dbi->available_typename;
+  print $dbi->available_typename;
 
 Get available type names. You can use these type names in
 C<type_rule>'s C<into1> and C<into2> section.
 
 =head2 C<assign_clause>
 
-    my $assign_clause = $dbi->assign_clause({title => 'a', age => 2});
+  my $assign_clause = $dbi->assign_clause({title => 'a', age => 2});
 
 Create assign clause
 
-    title = :title, author = :author
+  title = :title, author = :author
 
 This is used to create update clause.
 
-    "update book set " . $dbi->assign_clause({title => 'a', age => 2});
+  "update book set " . $dbi->assign_clause({title => 'a', age => 2});
 
 =head2 C<column>
 
-    my $column = $dbi->column(book => ['author', 'title']);
+  my $column = $dbi->column(book => ['author', 'title']);
 
 Create column clause. The follwoing column clause is created.
 
-    book.author as "book.author",
-    book.title as "book.title"
+  book.author as "book.author",
+  book.title as "book.title"
 
 You can change separator by C<separator> attribute.
 
-    # Separator is hyphen
-    $dbi->separator('-');
-    
-    book.author as "book-author",
-    book.title as "book-title"
-    
+  # Separator is hyphen
+  $dbi->separator('-');
+  
+  book.author as "book-author",
+  book.title as "book-title"
+  
 =head2 C<connect>
 
-    my $dbi = DBIx::Custom->connect(
-        dsn => "dbi:mysql:database=dbname",
-        user => 'ken',
-        password => '!LFKD%$&',
-        option => {mysql_enable_utf8 => 1}
-    );
+  my $dbi = DBIx::Custom->connect(
+    dsn => "dbi:mysql:database=dbname",
+    user => 'ken',
+    password => '!LFKD%$&',
+    option => {mysql_enable_utf8 => 1}
+  );
 
 Connect to the database and create a new L<DBIx::Custom> object.
 
@@ -2450,7 +2420,7 @@ and C<PrintError> option is false by default.
 
 =head2 C<count>
 
-    my $count = $dbi->count(table => 'book');
+  my $count = $dbi->count(table => 'book');
 
 Get rows count.
 
@@ -2458,29 +2428,29 @@ Options is same as C<select> method's ones.
 
 =head2 C<create_model>
 
-    my $model = $dbi->create_model(
-        table => 'book',
-        primary_key => 'id',
-        join => [
-            'inner join company on book.comparny_id = company.id'
-        ],
-    );
+  my $model = $dbi->create_model(
+    table => 'book',
+    primary_key => 'id',
+    join => [
+      'inner join company on book.comparny_id = company.id'
+    ],
+  );
 
 Create L<DBIx::Custom::Model> object and initialize model.
 the module is also used from C<model> method.
 
-   $dbi->model('book')->select(...);
+ $dbi->model('book')->select(...);
 
 =head2 C<dbh>
 
-    my $dbh = $dbi->dbh;
+  my $dbh = $dbi->dbh;
 
 Get L<DBI> database handle. if C<connector> is set, you can get
 database handle through C<connector> object.
 
 =head2 C<delete>
 
-    $dbi->delete(table => 'book', where => {title => 'Perl'});
+  $dbi->delete(table => 'book', where => {title => 'Perl'});
 
 Execute delete statement.
 
@@ -2495,33 +2465,33 @@ and use the following new ones.
 
 =item C<id>
 
-    id => 4
-    id => [4, 5]
+  id => 4
+  id => [4, 5]
 
 ID corresponding to C<primary_key>.
 You can delete rows by C<id> and C<primary_key>.
 
-    $dbi->delete(
-        primary_key => ['id1', 'id2'],
-        id => [4, 5],
-        table => 'book',
-    );
+  $dbi->delete(
+    primary_key => ['id1', 'id2'],
+    id => [4, 5],
+    table => 'book',
+  );
 
 The above is same as the followin one.
 
-    $dbi->delete(where => {id1 => 4, id2 => 5}, table => 'book');
+  $dbi->delete(where => {id1 => 4, id2 => 5}, table => 'book');
 
 =item C<prefix>
 
-    prefix => 'some'
+  prefix => 'some'
 
 prefix before table name section.
 
-    delete some from book
+  delete some from book
 
 =item C<table>
 
-    table => 'book'
+  table => 'book'
 
 Table name.
 
@@ -2533,24 +2503,24 @@ Same as C<select> method's C<where> option.
 
 =head2 C<delete_all>
 
-    $dbi->delete_all(table => $table);
+  $dbi->delete_all(table => $table);
 
 Execute delete statement for all rows.
 Options is same as C<delete>.
 
 =head2 C<each_column>
 
-    $dbi->each_column(
-        sub {
-            my ($dbi, $table, $column, $column_info) = @_;
-            
-            my $type = $column_info->{TYPE_NAME};
-            
-            if ($type eq 'DATE') {
-                # ...
-            }
-        }
-    );
+  $dbi->each_column(
+    sub {
+      my ($dbi, $table, $column, $column_info) = @_;
+      
+      my $type = $column_info->{TYPE_NAME};
+      
+      if ($type eq 'DATE') {
+          # ...
+      }
+    }
+  );
 
 Iterate all column informations in database.
 Argument is callback which is executed when one column is found.
@@ -2561,19 +2531,19 @@ If C<user_column_info> is set, C<each_column> method use C<user_column_info>
 infromation, you can improve the performance of C<each_column> in
 the following way.
 
-    my $column_infos = $dbi->get_column_info(exclude_table => qr/^system_/);
-    $dbi->user_column_info($column_info);
-    $dbi->each_column(sub { ... });
+  my $column_infos = $dbi->get_column_info(exclude_table => qr/^system_/);
+  $dbi->user_column_info($column_info);
+  $dbi->each_column(sub { ... });
 
 =head2 C<each_table>
 
-    $dbi->each_table(
-        sub {
-            my ($dbi, $table, $table_info) = @_;
-            
-            my $table_name = $table_info->{TABLE_NAME};
-        }
-    );
+  $dbi->each_table(
+    sub {
+      my ($dbi, $table, $table_info) = @_;
+      
+      my $table_name = $table_info->{TABLE_NAME};
+    }
+  );
 
 Iterate all table informationsfrom in database.
 Argument is callback which is executed when one table is found.
@@ -2584,21 +2554,21 @@ If C<user_table_info> is set, C<each_table> method use C<user_table_info>
 infromation, you can improve the performance of C<each_table> in
 the following way.
 
-    my $table_infos = $dbi->get_table_info(exclude => qr/^system_/);
-    $dbi->user_table_info($table_info);
-    $dbi->each_table(sub { ... });
+  my $table_infos = $dbi->get_table_info(exclude => qr/^system_/);
+  $dbi->user_table_info($table_info);
+  $dbi->each_table(sub { ... });
 
 =head2 C<execute>
 
-    my $result = $dbi->execute(
-      "select * from book where title = :title and author like :author",
-      {title => 'Perl', author => '%Ken%'}
-    );
+  my $result = $dbi->execute(
+    "select * from book where title = :title and author like :author",
+    {title => 'Perl', author => '%Ken%'}
+  );
 
-    my $result = $dbi->execute(
-      "select * from book where title = :book.title and author like :book.author",
-      {'book.title' => 'Perl', 'book.author' => '%Ken%'}
-    );
+  my $result = $dbi->execute(
+    "select * from book where title = :book.title and author like :book.author",
+    {'book.title' => 'Perl', 'book.author' => '%Ken%'}
+  );
 
 Execute SQL. SQL can contain column parameter such as :author and :title.
 You can append table name to column name such as :book.title and :book.author.
@@ -2607,27 +2577,27 @@ Return value is L<DBIx::Custom::Result> object when select statement is executed
 or the count of affected rows when insert, update, delete statement is executed.
 
 Named placeholder such as C<:title> is replaced by placeholder C<?>.
-    
-    # Original
-    select * from book where title = :title and author like :author
-    
-    # Replaced
-    select * from where title = ? and author like ?;
+  
+  # Original
+  select * from book where title = :title and author like :author
+  
+  # Replaced
+  select * from where title = ? and author like ?;
 
 You can specify operator with named placeholder
 by C<name{operator}> syntax.
 
-    # Original
-    select * from book where :title{=} and :author{like}
-    
-    # Replaced
-    select * from where title = ? and author like ?;
+  # Original
+  select * from book where :title{=} and :author{like}
+  
+  # Replaced
+  select * from where title = ? and author like ?;
 
 Note that colons in time format such as 12:13:15 is exeption,
 it is not parsed as named placeholder.
 If you want to use colon generally, you must escape it by C<\\>
 
-    select * from where title = "aa\\:bb";
+  select * from where title = "aa\\:bb";
 
 B<OPTIONS>
 
@@ -2639,25 +2609,25 @@ The following opitons are available.
 
 You can filter sql after the sql is build.
 
-    after_build_sql => $code_ref
+  after_build_sql => $code_ref
 
 The following one is one example.
 
-    $dbi->select(
-        table => 'book',
-        column => 'distinct(name)',
-        after_build_sql => sub {
-            "select count(*) from ($_[0]) as t1"
-        }
-    );
+  $dbi->select(
+    table => 'book',
+    column => 'distinct(name)',
+    after_build_sql => sub {
+      "select count(*) from ($_[0]) as t1"
+    }
+  );
 
 The following SQL is executed.
 
-    select count(*) from (select distinct(name) from book) as t1;
+  select count(*) from (select distinct(name) from book) as t1;
 
 =item C<append>
 
-    append => 'order by name'
+  append => 'order by name'
 
 Append some statement after SQL.
 
@@ -2665,30 +2635,30 @@ Append some statement after SQL.
 
 Specify database bind data type.
 
-    bind_type => [image => DBI::SQL_BLOB]
-    bind_type => [[qw/image audio/] => DBI::SQL_BLOB]
+  bind_type => [image => DBI::SQL_BLOB]
+  bind_type => [[qw/image audio/] => DBI::SQL_BLOB]
 
 This is used to bind parameter by C<bind_param> of statment handle.
 
-    $sth->bind_param($pos, $value, DBI::SQL_BLOB);
+  $sth->bind_param($pos, $value, DBI::SQL_BLOB);
 
 =item C<filter>
-    
-    filter => {
-        title  => sub { uc $_[0] }
-        author => sub { uc $_[0] }
-    }
-
-    # Filter name
-    filter => {
-        title  => 'upper_case',
-        author => 'upper_case'
-    }
-        
-    # At once
-    filter => [
-        [qw/title author/]  => sub { uc $_[0] }
-    ]
+  
+  filter => {
+    title  => sub { uc $_[0] }
+    author => sub { uc $_[0] }
+  }
+
+  # Filter name
+  filter => {
+    title  => 'upper_case',
+    author => 'upper_case'
+  }
+      
+  # At once
+  filter => [
+    [qw/title author/]  => sub { uc $_[0] }
+  ]
 
 Filter. You can set subroutine or filter name
 registered by by C<register_filter>.
@@ -2697,52 +2667,52 @@ and before type rule filter is executed.
 
 =item C<query>
 
-    query => 1
+  query => 1
 
 C<execute> method return hash reference which contain SQL and column
 infromation
 
-    my $sql = $query->{sql};
-    my $columns = $query->{columns};
-    
+  my $sql = $query->{sql};
+  my $columns = $query->{columns};
+  
 =item C<reuse>
-    
-    reuse => $hash_ref
+  
+  reuse => $hash_ref
 
 Reuse query object if the hash reference variable is set.
-    
-    my $queries = {};
-    $dbi->execute($sql, $param, reuse => $queries);
+  
+  my $queries = {};
+  $dbi->execute($sql, $param, reuse => $queries);
 
 This will improved performance when you want to execute same query repeatedly
 because generally creating query object is slow.
 
 =item C<primary_key>
 
-    primary_key => 'id'
-    primary_key => ['id1', 'id2']
+  primary_key => 'id'
+  primary_key => ['id1', 'id2']
 
 Priamry key. This is used for C<id> option.
 
 =item C<table>
-    
-    table => 'author'
+  
+  table => 'author'
 
 If you want to omit table name in column name
 and enable C<into1> and C<into2> type filter,
 You must set C<table> option.
 
-    $dbi->execute("select * from book where title = :title and author = :author",
-        {title => 'Perl', author => 'Ken', table => 'book');
+  $dbi->execute("select * from book where title = :title and author = :author",
+    {title => 'Perl', author => 'Ken', table => 'book');
 
-    # Same
-    $dbi->execute(
-      "select * from book where title = :book.title and author = :book.author",
-      {title => 'Perl', author => 'Ken');
+  # Same
+  $dbi->execute(
+    "select * from book where title = :book.title and author = :book.author",
+    {title => 'Perl', author => 'Ken');
 
 =item C<table_alias>
 
-    table_alias => {user => 'worker'}
+  table_alias => {user => 'worker'}
 
 Table alias. Key is real table name, value is alias table name.
 If you set C<table_alias>, you can enable C<into1> and C<into2> type rule
@@ -2750,19 +2720,19 @@ on alias table name.
 
 =item C<type_rule_off>
 
-    type_rule_off => 1
+  type_rule_off => 1
 
 Turn C<into1> and C<into2> type rule off.
 
 =item C<type_rule1_off>
 
-    type_rule1_off => 1
+  type_rule1_off => 1
 
 Turn C<into1> type rule off.
 
 =item C<type_rule2_off>
 
-    type_rule2_off => 1
+  type_rule2_off => 1
 
 Turn C<into2> type rule off.
 
@@ -2770,46 +2740,46 @@ Turn C<into2> type rule off.
 
 =head2 C<get_column_info>
 
-    my $column_infos = $dbi->get_column_info(exclude_table => qr/^system_/);
+  my $column_infos = $dbi->get_column_info(exclude_table => qr/^system_/);
 
 get column infomation except for one which match C<exclude_table> pattern.
 
-    [
-        {table => 'book', column => 'title', info => {...}},
-        {table => 'author', column => 'name' info => {...}}
-    ]
+  [
+    {table => 'book', column => 'title', info => {...}},
+    {table => 'author', column => 'name' info => {...}}
+  ]
 
 =head2 C<get_table_info>
 
-    my $table_infos = $dbi->get_table_info(exclude => qr/^system_/);
+  my $table_infos = $dbi->get_table_info(exclude => qr/^system_/);
 
 get table infomation except for one which match C<exclude> pattern.
 
-    [
-        {table => 'book', info => {...}},
-        {table => 'author', info => {...}}
-    ]
+  [
+    {table => 'book', info => {...}},
+    {table => 'author', info => {...}}
+  ]
 
 You can set this value to C<user_table_info>.
 
 =head2 C<helper>
 
-    $dbi->helper(
-        find_or_create   => sub {
-            my $self = shift;
-            
-            # Process
-        },
-        ...
-    );
+  $dbi->helper(
+    find_or_create   => sub {
+      my $self = shift;
+      
+      # Process
+    },
+    ...
+  );
 
 Register helper. These helper is called directly from L<DBIx::Custom> object.
 
-    $dbi->find_or_create;
+  $dbi->find_or_create;
 
 =head2 C<insert>
 
-    $dbi->insert({title => 'Perl', author => 'Ken'}, table  => 'book');
+  $dbi->insert({title => 'Perl', author => 'Ken'}, table  => 'book');
 
 Execute insert statement. First argument is row data. Return value is
 affected row count.
@@ -2817,18 +2787,18 @@ affected row count.
 If you want to set constant value to row data, use scalar reference
 as parameter value.
 
-    {date => \"NOW()"}
+  {date => \"NOW()"}
 
 You can pass multiple parameters, this is very fast.
 This is EXPERIMETNAL.
 
-    $dbi->insert(
-        [
-            {title => 'Perl', author => 'Ken'},
-            {title => 'Ruby', author => 'Tom'}
-        ],
-        table  => 'book'
-    );
+  $dbi->insert(
+    [
+      {title => 'Perl', author => 'Ken'},
+      {title => 'Ruby', author => 'Tom'}
+    ],
+    table  => 'book'
+  );
 
 In multiple insert, you can't use C<id> option.
 and only first parameter is used by creating sql.
@@ -2842,17 +2812,17 @@ and use the following new ones.
 b
 =item C<bulk_insert> EXPERIMENTAL
 
-    bulk_insert => 1
+  bulk_insert => 1
 
 bulk insert is executed if database support bulk insert and 
 multiple parameters is passed to C<insert>.
 The SQL like the following one is executed.
 
-    insert into book (id, title) values (?, ?), (?, ?);
+  insert into book (id, title) values (?, ?), (?, ?);
 
 =item C<created_at>
 
-    created_at => 'created_datetime'
+  created_at => 'created_datetime'
 
 Created timestamp column name. time when row is created is set to the column.
 default time format is "YYYY-mm-dd HH:MM:SS", which can be changed by
@@ -2860,37 +2830,37 @@ C<now> attribute.
 
 =item C<id>
 
-    id => 4
-    id => [4, 5]
+  id => 4
+  id => [4, 5]
 
 ID corresponding to C<primary_key>.
 You can insert a row by C<id> and C<primary_key>.
 
-    $dbi->insert(
-        {title => 'Perl', author => 'Ken'}
-        primary_key => ['id1', 'id2'],
-        id => [4, 5],
-        table => 'book'
-    );
+  $dbi->insert(
+    {title => 'Perl', author => 'Ken'}
+    primary_key => ['id1', 'id2'],
+    id => [4, 5],
+    table => 'book'
+  );
 
 The above is same as the followin one.
 
-    $dbi->insert(
-        {id1 => 4, id2 => 5, title => 'Perl', author => 'Ken'},
-        table => 'book'
-    );
+  $dbi->insert(
+    {id1 => 4, id2 => 5, title => 'Perl', author => 'Ken'},
+    table => 'book'
+  );
 
 =item C<prefix>
 
-    prefix => 'or replace'
+  prefix => 'or replace'
 
 prefix before table name section
 
-    insert or replace into book
+  insert or replace into book
 
 =item C<table>
 
-    table => 'book'
+  table => 'book'
 
 Table name.
 
@@ -2900,18 +2870,18 @@ This option is same as C<update> method C<updated_at> option.
 
 =item C<wrap>
 
-    wrap => {price => sub { "max($_[0])" }}
+  wrap => {price => sub { "max($_[0])" }}
 
 placeholder wrapped string.
 
 If the following statement
 
-    $dbi->insert({price => 100}, table => 'book',
-      {price => sub { "$_[0] + 5" }});
+  $dbi->insert({price => 100}, table => 'book',
+    {price => sub { "$_[0] + 5" }});
 
 is executed, the following SQL is executed.
 
-    insert into book price values ( ? + 5 );
+  insert into book price values ( ? + 5 );
 
 =back
 
@@ -2919,150 +2889,150 @@ is executed, the following SQL is executed.
 
 =head2 C<include_model>
 
-    $dbi->include_model('MyModel');
+  $dbi->include_model('MyModel');
 
 Include models from specified namespace,
 the following layout is needed to include models.
 
-    lib / MyModel.pm
-        / MyModel / book.pm
-                  / company.pm
+  lib / MyModel.pm
+      / MyModel / book.pm
+                / company.pm
 
 Name space module, extending L<DBIx::Custom::Model>.
 
 B<MyModel.pm>
 
-    package MyModel;
-    use DBIx::Custom::Model -base;
-    
-    1;
+  package MyModel;
+  use DBIx::Custom::Model -base;
+  
+  1;
 
 Model modules, extending name space module.
 
 B<MyModel/book.pm>
 
-    package MyModel::book;
-    use MyModel -base;
-    
-    1;
+  package MyModel::book;
+  use MyModel -base;
+  
+  1;
 
 B<MyModel/company.pm>
 
-    package MyModel::company;
-    use MyModel -base;
-    
-    1;
-    
+  package MyModel::company;
+  use MyModel -base;
+  
+  1;
+  
 MyModel::book and MyModel::company is included by C<include_model>.
 
 You can get model object by C<model>.
 
-    my $book_model = $dbi->model('book');
-    my $company_model = $dbi->model('company');
+  my $book_model = $dbi->model('book');
+  my $company_model = $dbi->model('company');
 
 See L<DBIx::Custom::Model> to know model features.
 
 =head2 C<like_value>
 
-    my $like_value = $dbi->like_value
+  my $like_value = $dbi->like_value
 
 Code reference which return a value for the like value.
 
-    sub { "%$_[0]%" }
+  sub { "%$_[0]%" }
 
 =head2 C<mapper>
 
-    my $mapper = $dbi->mapper(param => $param);
+  my $mapper = $dbi->mapper(param => $param);
 
 Create a new L<DBIx::Custom::Mapper> object.
 
 =head2 C<merge_param>
 
-    my $param = $dbi->merge_param({key1 => 1}, {key1 => 1, key2 => 2});
+  my $param = $dbi->merge_param({key1 => 1}, {key1 => 1, key2 => 2});
 
 Merge parameters. The following new parameter is created.
 
-    {key1 => [1, 1], key2 => 2}
+  {key1 => [1, 1], key2 => 2}
 
 If same keys contains, the value is converted to array reference.
 
 =head2 C<model>
 
-    my $model = $dbi->model('book');
+  my $model = $dbi->model('book');
 
 Get a L<DBIx::Custom::Model> object
 create by C<create_model> or C<include_model>
 
 =head2 C<mycolumn>
 
-    my $column = $dbi->mycolumn(book => ['author', 'title']);
+  my $column = $dbi->mycolumn(book => ['author', 'title']);
 
 Create column clause for myself. The follwoing column clause is created.
 
-    book.author as author,
-    book.title as title
+  book.author as author,
+  book.title as title
 
 =head2 C<new>
 
-    my $dbi = DBIx::Custom->new(
-        dsn => "dbi:mysql:database=dbname",
-        user => 'ken',
-        password => '!LFKD%$&',
-        option => {mysql_enable_utf8 => 1}
-    );
+  my $dbi = DBIx::Custom->new(
+    dsn => "dbi:mysql:database=dbname",
+    user => 'ken',
+    password => '!LFKD%$&',
+    option => {mysql_enable_utf8 => 1}
+  );
 
 Create a new L<DBIx::Custom> object.
 
 =head2 C<not_exists>
 
-    my $not_exists = $dbi->not_exists;
+  my $not_exists = $dbi->not_exists;
 
 DBIx::Custom::NotExists object, indicating the column is not exists.
 This is used in C<param> of L<DBIx::Custom::Where> .
 
 =head2 C<order>
 
-    my $order = $dbi->order;
+  my $order = $dbi->order;
 
 Create a new L<DBIx::Custom::Order> object.
 
 =head2 C<q>
 
-    my $quooted = $dbi->q("title");
+  my $quooted = $dbi->q("title");
 
 Quote string by value of C<quote>.
 
 =head2 C<register_filter>
 
-    $dbi->register_filter(
-        # Time::Piece object to database DATE format
-        tp_to_date => sub {
-            my $tp = shift;
-            return $tp->strftime('%Y-%m-%d');
-        },
-        # database DATE format to Time::Piece object
-        date_to_tp => sub {
-           my $date = shift;
-           return Time::Piece->strptime($date, '%Y-%m-%d');
-        }
-    );
-    
+  $dbi->register_filter(
+    # Time::Piece object to database DATE format
+    tp_to_date => sub {
+      my $tp = shift;
+      return $tp->strftime('%Y-%m-%d');
+    },
+    # database DATE format to Time::Piece object
+    date_to_tp => sub {
+      my $date = shift;
+      return Time::Piece->strptime($date, '%Y-%m-%d');
+    }
+  );
+  
 Register filters, used by C<filter> option of many methods.
 
 =head2 C<select>
 
-    my $result = $dbi->select(
-        column => ['author', 'title'],
-        table  => 'book',
-        where  => {author => 'Ken'},
-    );
-    
+  my $result = $dbi->select(
+    column => ['author', 'title'],
+    table  => 'book',
+    where  => {author => 'Ken'},
+  );
+  
 Execute select statement.
 
 You can pass odd number arguments. first argument is C<column>.
 This is EXPERIMENTAL.
 
-    my $result = $dbi->select(['author', 'title'], table => 'book');
+  my $result = $dbi->select(['author', 'title'], table => 'book');
 
 B<OPTIONS>
 
@@ -3072,186 +3042,186 @@ and use the following new ones.
 =over 4
 
 =item C<column>
-    
-    column => 'author'
-    column => ['author', 'title']
+  
+  column => 'author'
+  column => ['author', 'title']
 
 Column clause.
-    
+  
 if C<column> is not specified, '*' is set.
 
-    column => '*'
+  column => '*'
 
 You can specify hash of array reference.
 
-    column => [
-        {book => [qw/author title/]},
-        {person => [qw/name age/]}
-    ]
+  column => [
+    {book => [qw/author title/]},
+    {person => [qw/name age/]}
+  ]
 
 This is expanded to the following one by using C<colomn> method.
 
-    book.author as "book.author",
-    book.title as "book.title",
-    person.name as "person.name",
-    person.age as "person.age"
+  book.author as "book.author",
+  book.title as "book.title",
+  person.name as "person.name",
+  person.age as "person.age"
 
 You can specify array of array reference, first argument is
 column name, second argument is alias.
 
-    column => [
-        ['date(book.register_datetime)' => 'book.register_date']
-    ];
+  column => [
+    ['date(book.register_datetime)' => 'book.register_date']
+  ];
 
 Alias is quoted properly and joined.
 
-    date(book.register_datetime) as "book.register_date"
+  date(book.register_datetime) as "book.register_date"
 
 =item C<id>
 
-    id => 4
-    id => [4, 5]
+  id => 4
+  id => [4, 5]
 
 ID corresponding to C<primary_key>.
 You can select rows by C<id> and C<primary_key>.
 
-    $dbi->select(
-        primary_key => ['id1', 'id2'],
-        id => [4, 5],
-        table => 'book'
-    );
+  $dbi->select(
+    primary_key => ['id1', 'id2'],
+    id => [4, 5],
+    table => 'book'
+  );
 
 The above is same as the followin one.
 
-    $dbi->select(
-        where => {id1 => 4, id2 => 5},
-        table => 'book'
-    );
-    
+  $dbi->select(
+    where => {id1 => 4, id2 => 5},
+    table => 'book'
+  );
+  
 =item C<param>
 
-    param => {'table2.key3' => 5}
+  param => {'table2.key3' => 5}
 
 Parameter shown before where clause.
-    
+  
 For example, if you want to contain tag in join clause, 
 you can pass parameter by C<param> option.
 
-    join  => ['inner join (select * from table2 where table2.key3 = :table2.key3)' . 
-              ' as table2 on table1.key1 = table2.key1']
+  join  => ['inner join (select * from table2 where table2.key3 = :table2.key3)' . 
+            ' as table2 on table1.key1 = table2.key1']
 
 =itme C<prefix>
 
-    prefix => 'SQL_CALC_FOUND_ROWS'
+  prefix => 'SQL_CALC_FOUND_ROWS'
 
 Prefix of column cluase
 
-    select SQL_CALC_FOUND_ROWS title, author from book;
+  select SQL_CALC_FOUND_ROWS title, author from book;
 
 =item C<join>
 
-    join => [
-        'left outer join company on book.company_id = company_id',
-        'left outer join location on company.location_id = location.id'
-    ]
-        
+  join => [
+    'left outer join company on book.company_id = company_id',
+    'left outer join location on company.location_id = location.id'
+  ]
+      
 Join clause. If column cluase or where clause contain table name like "company.name",
 join clausees needed when SQL is created is used automatically.
 
-    $dbi->select(
-        table => 'book',
-        column => ['company.location_id as location_id'],
-        where => {'company.name' => 'Orange'},
-        join => [
-            'left outer join company on book.company_id = company.id',
-            'left outer join location on company.location_id = location.id'
-        ]
-    );
+  $dbi->select(
+    table => 'book',
+    column => ['company.location_id as location_id'],
+    where => {'company.name' => 'Orange'},
+    join => [
+      'left outer join company on book.company_id = company.id',
+      'left outer join location on company.location_id = location.id'
+    ]
+  );
 
 In above select, column and where clause contain "company" table,
 the following SQL is created
 
-    select company.location_id as location_id
-    from book
-      left outer join company on book.company_id = company.id
-    where company.name = ?;
+  select company.location_id as location_id
+  from book
+    left outer join company on book.company_id = company.id
+  where company.name = ?;
 
 You can specify two table by yourself. This is useful when join parser can't parse
 the join clause correctly.
 
-    $dbi->select(
-        table => 'book',
-        column => ['company.location_id as location_id'],
-        where => {'company.name' => 'Orange'},
-        join => [
-            {
-                clause => 'left outer join location on company.location_id = location.id',
-                table => ['company', 'location']
-            }
-        ]
-    );
+  $dbi->select(
+    table => 'book',
+    column => ['company.location_id as location_id'],
+    where => {'company.name' => 'Orange'},
+    join => [
+      {
+        clause => 'left outer join location on company.location_id = location.id',
+        table => ['company', 'location']
+      }
+    ]
+  );
 
 =item C<table>
 
-    table => 'book'
+  table => 'book'
 
 Table name.
 
 =item C<where>
-    
-    # Hash refrence
-    where => {author => 'Ken', 'title' => 'Perl'}
-    
-    # DBIx::Custom::Where object
-    where => $dbi->where(
-        clause => ['and', ':author{=}', ':title{like}'],
-        param  => {author => 'Ken', title => '%Perl%'}
-    );
-    
-    # Array reference, this is same as above
-    where => [
-        ['and', ':author{=}', ':title{like}'],
-        {author => 'Ken', title => '%Perl%'}
-    ];
-    
-    # String
-    where => 'title is null'
+  
+  # Hash refrence
+  where => {author => 'Ken', 'title' => 'Perl'}
+  
+  # DBIx::Custom::Where object
+  where => $dbi->where(
+    clause => ['and', ':author{=}', ':title{like}'],
+    param  => {author => 'Ken', title => '%Perl%'}
+  );
+  
+  # Array reference, this is same as above
+  where => [
+    ['and', ':author{=}', ':title{like}'],
+    {author => 'Ken', title => '%Perl%'}
+  ];
+  
+  # String
+  where => 'title is null'
 
 Where clause. See L<DBIx::Custom::Where>.
-    
+  
 =back
 
 =head2 C<setup_model>
 
-    $dbi->setup_model;
+  $dbi->setup_model;
 
 Setup all model objects.
 C<columns> of model object is automatically set, parsing database information.
 
 =head2 C<type_rule>
 
-    $dbi->type_rule(
-        into1 => {
-            date => sub { ... },
-            datetime => sub { ... }
-        },
-        into2 => {
-            date => sub { ... },
-            datetime => sub { ... }
-        },
-        from1 => {
-            # DATE
-            9 => sub { ... },
-            # DATETIME or TIMESTAMP
-            11 => sub { ... },
-        }
-        from2 => {
-            # DATE
-            9 => sub { ... },
-            # DATETIME or TIMESTAMP
-            11 => sub { ... },
-        }
-    );
+  $dbi->type_rule(
+    into1 => {
+      date => sub { ... },
+      datetime => sub { ... }
+    },
+    into2 => {
+      date => sub { ... },
+      datetime => sub { ... }
+    },
+    from1 => {
+      # DATE
+      9 => sub { ... },
+      # DATETIME or TIMESTAMP
+      11 => sub { ... },
+    }
+    from2 => {
+      # DATE
+      9 => sub { ... },
+      # DATETIME or TIMESTAMP
+      11 => sub { ... },
+    }
+  );
 
 Filtering rule when data is send into and get from database.
 This has a little complex problem.
@@ -3272,46 +3242,46 @@ column name.
 
 =item 1. column name
 
-    issue_date
-    issue_datetime
+  issue_date
+  issue_datetime
 
 This need C<table> option in each method.
 
 =item 2. table name and column name, separator is dot
 
-    book.issue_date
-    book.issue_datetime
+  book.issue_date
+  book.issue_datetime
 
 =back
 
 You get all type name used in database by C<available_typename>.
 
-    print $dbi->available_typename;
+  print $dbi->available_typename;
 
 In C<from1> and C<from2> you specify data type, not type name.
 C<from2> is executed after C<from1>.
 You get all data type by C<available_datatype>.
 
-    print $dbi->available_datatype;
+  print $dbi->available_datatype;
 
 You can also specify multiple types at once.
 
-    $dbi->type_rule(
-        into1 => [
-            [qw/DATE DATETIME/] => sub { ... },
-        ],
-    );
+  $dbi->type_rule(
+    into1 => [
+      [qw/DATE DATETIME/] => sub { ... },
+    ],
+  );
 
 =head2 C<update>
 
-    $dbi->update({title => 'Perl'}, table  => 'book', where  => {id => 4});
+  $dbi->update({title => 'Perl'}, table  => 'book', where  => {id => 4});
 
 Execute update statement. First argument is update row data.
 
 If you want to set constant value to row data, use scalar reference
 as parameter value.
 
-    {date => \"NOW()"}
+  {date => \"NOW()"}
 
 B<OPTIONS>
 
@@ -3322,38 +3292,38 @@ and use the following new ones.
 
 =item C<id>
 
-    id => 4
-    id => [4, 5]
+  id => 4
+  id => [4, 5]
 
 ID corresponding to C<primary_key>.
 You can update rows by C<id> and C<primary_key>.
 
-    $dbi->update(
-        {title => 'Perl', author => 'Ken'}
-        primary_key => ['id1', 'id2'],
-        id => [4, 5],
-        table => 'book'
-    );
+  $dbi->update(
+    {title => 'Perl', author => 'Ken'}
+    primary_key => ['id1', 'id2'],
+    id => [4, 5],
+    table => 'book'
+  );
 
 The above is same as the followin one.
 
-    $dbi->update(
-        {title => 'Perl', author => 'Ken'}
-        where => {id1 => 4, id2 => 5},
-        table => 'book'
-    );
+  $dbi->update(
+    {title => 'Perl', author => 'Ken'}
+    where => {id1 => 4, id2 => 5},
+    table => 'book'
+  );
 
 =item C<prefix>
 
-    prefix => 'or replace'
+  prefix => 'or replace'
 
 prefix before table name section
 
-    update or replace book
+  update or replace book
 
 =item C<table>
 
-    table => 'book'
+  table => 'book'
 
 Table name.
 
@@ -3363,22 +3333,22 @@ Same as C<select> method's C<where> option.
 
 =item C<wrap>
 
-    wrap => {price => sub { "max($_[0])" }}
+  wrap => {price => sub { "max($_[0])" }}
 
 placeholder wrapped string.
 
 If the following statement
 
-    $dbi->update({price => 100}, table => 'book',
-      {price => sub { "$_[0] + 5" }});
+  $dbi->update({price => 100}, table => 'book',
+    {price => sub { "$_[0] + 5" }});
 
 is executed, the following SQL is executed.
 
-    update book set price =  ? + 5;
+  update book set price =  ? + 5;
 
 =item C<updated_at>
 
-    updated_at => 'updated_datetime'
+  updated_at => 'updated_datetime'
 
 Updated timestamp column name. time when row is updated is set to the column.
 default time format is C<YYYY-mm-dd HH:MM:SS>, which can be changed by
@@ -3388,25 +3358,25 @@ C<now> attribute.
 
 =head2 C<update_all>
 
-    $dbi->update_all({title => 'Perl'}, table => 'book', );
+  $dbi->update_all({title => 'Perl'}, table => 'book', );
 
 Execute update statement for all rows.
 Options is same as C<update> method.
 
 =head2 C<update_or_insert>
-    
-    # ID
-    $dbi->update_or_insert(
-        {title => 'Perl'},
-        table => 'book',
-        id => 1,
-        primary_key => 'id',
-        option => {
-            select => {
-                 append => 'for update'
-            }
-        }
-    );
+  
+  # ID
+  $dbi->update_or_insert(
+    {title => 'Perl'},
+    table => 'book',
+    id => 1,
+    primary_key => 'id',
+    option => {
+      select => {
+         append => 'for update'
+      }
+    }
+  );
 
 Update or insert.
 
@@ -3423,17 +3393,17 @@ in C<select>, C<update>, C<delete>, and has the following new ones.
 
 =item C<option>
 
-    option => {
-        select => {
-            append => '...'
-        },
-        insert => {
-            prefix => '...'
-        },
-        update => {
-            filter => {}
-        }
+  option => {
+    select => {
+      append => '...'
+    },
+    insert => {
+      prefix => '...'
+    },
+    update => {
+      filter => {}
     }
+  }
 
 If you want to pass option to each method,
 you can use C<option> option.
@@ -3442,59 +3412,59 @@ you can use C<option> option.
 
 =item C<select_option>
 
-    select_option => {append => 'for update'}
+  select_option => {append => 'for update'}
 
 select method option,
 select method is used to check the row is already exists.
 
 =head2 C<show_datatype>
 
-    $dbi->show_datatype($table);
+  $dbi->show_datatype($table);
 
 Show data type of the columns of specified table.
 
-    book
-    title: 5
-    issue_date: 91
+  book
+  title: 5
+  issue_date: 91
 
 This data type is used in C<type_rule>'s C<from1> and C<from2>.
 
 =head2 C<show_tables>
 
-    $dbi->show_tables;
+  $dbi->show_tables;
 
 Show tables.
 
 =head2 C<show_typename>
 
-    $dbi->show_typename($table);
+  $dbi->show_typename($table);
 
 Show type name of the columns of specified table.
 
-    book
-    title: varchar
-    issue_date: date
+  book
+  title: varchar
+  issue_date: date
 
 This type name is used in C<type_rule>'s C<into1> and C<into2>.
 
 =head2 C<values_clause>
 
-    my $values_clause = $dbi->values_clause({title => 'a', age => 2});
+  my $values_clause = $dbi->values_clause({title => 'a', age => 2});
 
 Create values clause.
 
-    (title, author) values (title = :title, age = :age);
+  (title, author) values (title = :title, age = :age);
 
 You can use this in insert statement.
 
-    my $insert_sql = "insert into book $values_clause";
+  my $insert_sql = "insert into book $values_clause";
 
 =head2 C<where>
 
-    my $where = $dbi->where(
-        clause => ['and', 'title = :title', 'author = :author'],
-        param => {title => 'Perl', author => 'Ken'}
-    );
+  my $where = $dbi->where(
+    clause => ['and', 'title = :title', 'author = :author'],
+    param => {title => 'Perl', author => 'Ken'}
+  );
 
 Create a new L<DBIx::Custom::Where> object.
 
@@ -3522,121 +3492,121 @@ L<DBIx::Custom::Model> execute method call L<DBIx::Custom> execute.
 
 L<DBIx::Custom>
 
-    # Attribute methods
-    tag_parse # will be removed 2017/1/1
-    default_dbi_option # will be removed 2017/1/1
-    dbi_option # will be removed 2017/1/1
-    data_source # will be removed at 2017/1/1
-    dbi_options # will be removed at 2017/1/1
-    filter_check # will be removed at 2017/1/1
-    reserved_word_quote # will be removed at 2017/1/1
-    cache_method # will be removed at 2017/1/1
-    
-    # Methods
-    update_timestamp # will be removed at 2017/1/1
-    insert_timestamp # will be removed at 2017/1/1
-    method # will be removed at 2017/1/1
-    assign_param # will be removed at 2017/1/1
-    update_param # will be removed at 2017/1/1
-    insert_param # will be removed at 2017/1/1
-    create_query # will be removed at 2017/1/1
-    apply_filter # will be removed at 2017/1/1
-    select_at # will be removed at 2017/1/1
-    delete_at # will be removed at 2017/1/1
-    update_at # will be removed at 2017/1/1
-    insert_at # will be removed at 2017/1/1
-    register_tag # will be removed at 2017/1/1
-    default_bind_filter # will be removed at 2017/1/1
-    default_fetch_filter # will be removed at 2017/1/1
-    insert_param_tag # will be removed at 2017/1/1
-    register_tag # will be removed at 2017/1/1
-    register_tag_processor # will be removed at 2017/1/1
-    update_param_tag # will be removed at 2017/1/1
-    
-    # Options
-    select column option [COLUMN => ALIAS] syntax # will be removed 2017/1/1
-    execute method id option # will be removed 2017/1/1
-    update timestamp option # will be removed 2017/1/1
-    insert timestamp option # will be removed 2017/1/1
-    select method where_param option # will be removed 2017/1/1
-    delete method where_param option # will be removed 2017/1/1
-    update method where_param option # will be removed 2017/1/1
-    insert method param option # will be removed at 2017/1/1
-    insert method id option # will be removed at 2017/1/1
-    select method relation option # will be removed at 2017/1/1
-    select method column option [COLUMN, as => ALIAS] format
-      # will be removed at 2017/1/1
-    execute method's sqlfilter option # will be removed at 2017/1/1
-    
-    # Others
-    execute($query, ...) # execute method receiving query object.
-                         # this is removed at 2017/1/1
-    execute("select * from {= title}"); # execute method's
-                                        # tag parsing functionality
-                                        # will be removed at 2017/1/1
-    Query caching # will be removed at 2017/1/1
+  # Attribute methods
+  tag_parse # will be removed 2017/1/1
+  default_dbi_option # will be removed 2017/1/1
+  dbi_option # will be removed 2017/1/1
+  data_source # will be removed at 2017/1/1
+  dbi_options # will be removed at 2017/1/1
+  filter_check # will be removed at 2017/1/1
+  reserved_word_quote # will be removed at 2017/1/1
+  cache_method # will be removed at 2017/1/1
+  
+  # Methods
+  update_timestamp # will be removed at 2017/1/1
+  insert_timestamp # will be removed at 2017/1/1
+  method # will be removed at 2017/1/1
+  assign_param # will be removed at 2017/1/1
+  update_param # will be removed at 2017/1/1
+  insert_param # will be removed at 2017/1/1
+  create_query # will be removed at 2017/1/1
+  apply_filter # will be removed at 2017/1/1
+  select_at # will be removed at 2017/1/1
+  delete_at # will be removed at 2017/1/1
+  update_at # will be removed at 2017/1/1
+  insert_at # will be removed at 2017/1/1
+  register_tag # will be removed at 2017/1/1
+  default_bind_filter # will be removed at 2017/1/1
+  default_fetch_filter # will be removed at 2017/1/1
+  insert_param_tag # will be removed at 2017/1/1
+  register_tag # will be removed at 2017/1/1
+  register_tag_processor # will be removed at 2017/1/1
+  update_param_tag # will be removed at 2017/1/1
+  
+  # Options
+  select column option [COLUMN => ALIAS] syntax # will be removed 2017/1/1
+  execute method id option # will be removed 2017/1/1
+  update timestamp option # will be removed 2017/1/1
+  insert timestamp option # will be removed 2017/1/1
+  select method where_param option # will be removed 2017/1/1
+  delete method where_param option # will be removed 2017/1/1
+  update method where_param option # will be removed 2017/1/1
+  insert method param option # will be removed at 2017/1/1
+  insert method id option # will be removed at 2017/1/1
+  select method relation option # will be removed at 2017/1/1
+  select method column option [COLUMN, as => ALIAS] format
+    # will be removed at 2017/1/1
+  execute method's sqlfilter option # will be removed at 2017/1/1
+  
+  # Others
+  execute($query, ...) # execute method receiving query object.
+                       # this is removed at 2017/1/1
+  execute("select * from {= title}"); # execute method's
+                                      # tag parsing functionality
+                                      # will be removed at 2017/1/1
+  Query caching # will be removed at 2017/1/1
 
 L<DBIx::Custom::Model>
 
-    # Attribute methods
-    execute # will be removed at 2017/1/1
-    method # will be removed at 2017/1/1
-    filter # will be removed at 2017/1/1
-    name # will be removed at 2017/1/1
-    type # will be removed at 2017/1/1
+  # Attribute methods
+  execute # will be removed at 2017/1/1
+  method # will be removed at 2017/1/1
+  filter # will be removed at 2017/1/1
+  name # will be removed at 2017/1/1
+  type # will be removed at 2017/1/1
 
 L<DBIx::Custom::Query>
 
 This module is DEPRECATED! # will be removed at 2017/1/1
-    
-    # Attribute methods
-    default_filter # will be removed at 2017/1/1
-    table # will be removed at 2017/1/1
-    filters # will be removed at 2017/1/1
-    
-    # Methods
-    filter # will be removed at 2017/1/1
+  
+  # Attribute methods
+  default_filter # will be removed at 2017/1/1
+  table # will be removed at 2017/1/1
+  filters # will be removed at 2017/1/1
+  
+  # Methods
+  filter # will be removed at 2017/1/1
 
 L<DBIx::Custom::QueryBuilder>
 
 This module is DEPRECATED! # will be removed at 2017/1/1
-    
-    # Attribute methods
-    tags # will be removed at 2017/1/1
-    tag_processors # will be removed at 2017/1/1
-    
-    # Methods
-    register_tag # will be removed at 2017/1/1
-    register_tag_processor # will be removed at 2017/1/1
-    
-    # Others
-    build_query("select * from {= title}"); # tag parsing functionality
-                                            # will be removed at 2017/1/1
+  
+  # Attribute methods
+  tags # will be removed at 2017/1/1
+  tag_processors # will be removed at 2017/1/1
+  
+  # Methods
+  register_tag # will be removed at 2017/1/1
+  register_tag_processor # will be removed at 2017/1/1
+  
+  # Others
+  build_query("select * from {= title}"); # tag parsing functionality
+                                          # will be removed at 2017/1/1
 
 L<DBIx::Custom::Result>
-    
-    # Attribute methods
-    filter_check # will be removed at 2017/1/1
-    
-    # Methods
-    fetch_first # will be removed at 2017/2/1
-    fetch_hash_first # will be removed 2017/2/1
-    filter_on # will be removed at 2017/1/1
-    filter_off # will be removed at 2017/1/1
-    end_filter # will be removed at 2017/1/1
-    remove_end_filter # will be removed at 2017/1/1
-    remove_filter # will be removed at 2017/1/1
-    default_filter # will be removed at 2017/1/1
+  
+  # Attribute methods
+  filter_check # will be removed at 2017/1/1
+  
+  # Methods
+  fetch_first # will be removed at 2017/2/1
+  fetch_hash_first # will be removed 2017/2/1
+  filter_on # will be removed at 2017/1/1
+  filter_off # will be removed at 2017/1/1
+  end_filter # will be removed at 2017/1/1
+  remove_end_filter # will be removed at 2017/1/1
+  remove_filter # will be removed at 2017/1/1
+  default_filter # will be removed at 2017/1/1
 
 L<DBIx::Custom::Tag>
 
-    This module is DEPRECATED! # will be removed at 2017/1/1
+  This module is DEPRECATED! # will be removed at 2017/1/1
 
 L<DBIx::Custom::Order>
 
-    # Other
-    prepend method array reference receiving
-      $order->prepend(['book', 'desc']); # will be removed 2017/1/1
+  # Other
+  prepend method array reference receiving
+    $order->prepend(['book', 'desc']); # will be removed 2017/1/1
 
 =head1 BACKWARDS COMPATIBILITY POLICY
 

+144 -146

lib/DBIx/Custom/Mapper.pm

View

@@ -10,119 +10,117 @@ use DBIx::Custom::Util '_subname';
 push @DBIx::Custom::CARP_NOT, __PACKAGE__;
 
 has [qw/param/],
-    condition => sub {
-        sub { defined $_[0] && length $_[0] }
-    },
-    pass => sub { [] };
+  condition => sub {
+    sub { defined $_[0] && length $_[0] }
+  },
+  pass => sub { [] };
 
 sub map {
-    my ($self, %rule) = @_;
-    my $param = $self->param;
-    $rule{$_} = {key => $_} for @{$self->pass};
+  my ($self, %rule) = @_;
+  my $param = $self->param;
+  $rule{$_} = {key => $_} for @{$self->pass};
+  
+  # Mapping
+  my $new_param = {};
+  for my $key (keys %rule) {
     
-    # Mapping
-    my $new_param = {};
-    for my $key (keys %rule) {
-        
-        my $mapping = $rule{$key};
-        
-        # Get mapping information
-        my $new_key;
-        my $value;
-        my $condition;
-        
-        if (ref $mapping eq 'ARRAY') {
-            $new_key = $mapping->[0];
-            $value = $mapping->[1];
-            $condition = ref $mapping->[2] eq 'HASH' ? $mapping->[2]->{condition} : $mapping->[2];
-        }
-        elsif (ref $mapping eq 'HASH') {
-            $new_key = $mapping->{key};
-            $value = $mapping->{value};
-            $condition = $mapping->{condition};
-        }
-        elsif (!ref $mapping) {
-            $new_key = $mapping;
-            warn qq/map method's string value "$mapping" is DEPRECATED. / .
-                 qq/use {key => ...} syntax instead/
+    my $mapping = $rule{$key};
+    
+    # Get mapping information
+    my $new_key;
+    my $value;
+    my $condition;
+    
+    if (ref $mapping eq 'ARRAY') {
+      $new_key = $mapping->[0];
+      $value = $mapping->[1];
+      $condition = ref $mapping->[2] eq 'HASH' ? $mapping->[2]->{condition} : $mapping->[2];
+    }
+    elsif (ref $mapping eq 'HASH') {
+      $new_key = $mapping->{key};
+      $value = $mapping->{value};
+      $condition = $mapping->{condition};
+    }
+    elsif (!ref $mapping) {
+      $new_key = $mapping;
+      warn qq/map method's string value "$mapping" is DEPRECATED. / .
+           qq/use {key => ...} syntax instead/
+    }
+    elsif (ref $mapping eq 'CODE') {
+      $value = $mapping;
+      warn qq/map method's code reference value "$mapping" is DEPRECATED. / .
+           qq/use {value => ...} syntax instead/
+    }
+    
+    $new_key = $key unless defined $new_key;
+    $condition ||= $self->condition;
+    $condition = $self->_condition_to_sub($condition);
+
+    # Map parameter
+    if (ref $condition eq 'CODE') {
+      if (ref $param->{$key} eq 'ARRAY') {
+        $new_param->{$new_key} = [];
+        for (my $i = 0; $i < @{$param->{$key}}; $i++) {
+          $new_param->{$new_key}->[$i]
+            = $condition->($param->{$key}->[$i]) ? $param->{$key}->[$i]
+            : DBIx::Custom::NotExists->singleton;
         }
-        elsif (ref $mapping eq 'CODE') {
-            $value = $mapping;
-            warn qq/map method's code reference value "$mapping" is DEPRECATED. / .
-                 qq/use {value => ...} syntax instead/
+      }
+      else {
+        if ($condition->($param->{$key})) {
+          $new_param->{$new_key} = defined $value
+            ? $value->($param->{$key}) : $param->{$key};
         }
-        
-        $new_key = $key unless defined $new_key;
-        $condition ||= $self->condition;
-        $condition = $self->_condition_to_sub($condition);
-
-        # Map parameter
-        if (ref $condition eq 'CODE') {
-            if (ref $param->{$key} eq 'ARRAY') {
-                $new_param->{$new_key} = [];
-                for (my $i = 0; $i < @{$param->{$key}}; $i++) {
-                    $new_param->{$new_key}->[$i]
-                      = $condition->($param->{$key}->[$i]) ? $param->{$key}->[$i]
-                      : DBIx::Custom::NotExists->singleton;
-                }
-            }
-            else {
-              if ($condition->($param->{$key})) {
-                  $new_param->{$new_key} = defined $value
-                                         ? $value->($param->{$key})
-                                         : $param->{$key};
-              }
-            }
+      }
+    }
+    elsif ($condition eq 'exists') {
+      if (ref $param->{$key} eq 'ARRAY') {
+        $new_param->{$new_key} = [];
+        for (my $i = 0; $i < @{$param->{$key}}; $i++) {
+          $new_param->{$new_key}->[$i]
+            = exists $param->{$key}->[$i] ? $param->{$key}->[$i]
+            : DBIx::Custom::NotExists->singleton;
         }
-        elsif ($condition eq 'exists') {
-            if (ref $param->{$key} eq 'ARRAY') {
-                $new_param->{$new_key} = [];
-                for (my $i = 0; $i < @{$param->{$key}}; $i++) {
-                    $new_param->{$new_key}->[$i]
-                      = exists $param->{$key}->[$i] ? $param->{$key}->[$i]
-                      : DBIx::Custom::NotExists->singleton;
-                }
-            }
-            else {
-                if (exists $param->{$key}) {
-                    $new_param->{$new_key} = defined $value
-                                           ? $value->($param->{$key})
-                                           : $param->{$key};
-                }
-            }
+      }
+      else {
+        if (exists $param->{$key}) {
+          $new_param->{$new_key} = defined $value
+            ? $value->($param->{$key}) : $param->{$key};
         }
-        else { croak qq/Condition must be code reference or "exists" / . _subname }
+      }
     }
-    
-    return $new_param;
+    else { croak qq/Condition must be code reference or "exists" / . _subname }
+  }
+  
+  return $new_param;
 }
 
 sub new {
-    my $self = shift->SUPER::new(@_);
-    
-    # Check attribute names
-    my @attrs = keys %$self;
-    for my $attr (@attrs) {
-        croak qq{"$attr" is invalid attribute name (} . _subname . ")"
-          unless $self->can($attr);
-    }
-    
-    return $self;
+  my $self = shift->SUPER::new(@_);
+  
+  # Check attribute names
+  my @attrs = keys %$self;
+  for my $attr (@attrs) {
+    croak qq{"$attr" is invalid attribute name (} . _subname . ")"
+      unless $self->can($attr);
+  }
+  
+  return $self;
 }
 
 
 sub _condition_to_sub {
-    my ($self, $if) = @_;
-    $if = $if eq 'exists' ? $if
-            : $if eq 'defined' ? sub { defined $_[0] }
-            : $if eq 'length'  ? sub { defined $_[0] && length $_[0] }
-            : ref $if eq 'CODE' ? $if
-            : undef;
-
-    croak "You can must specify right value to C<condition> " . _subname
-      unless $if;
-    
-    return $if;
+  my ($self, $if) = @_;
+  $if = $if eq 'exists' ? $if
+    : $if eq 'defined' ? sub { defined $_[0] }
+    : $if eq 'length'  ? sub { defined $_[0] && length $_[0] }
+    : ref $if eq 'CODE' ? $if
+    : undef;
+
+  croak "You can must specify right value to C<condition> " . _subname
+    unless $if;
+  
+  return $if;
 }
 
 1;
@@ -133,33 +131,33 @@ DBIx::Custom::Mapper - Mapper of parameter
 
 =head1 SYNOPSYS
 
-    my $mapper = $dbi->mapper(param => $param);
-    my $new_param = $mapper->map(
-        title => 'book.title', # Key
-        author => sub { '%' . $_[0] . '%'} # Value
-        price => ['book.price' => sub { '%' . $_[0] . '%' }], # Key and value
-    );
+  my $mapper = $dbi->mapper(param => $param);
+  my $new_param = $mapper->map(
+    title => 'book.title', # Key
+    author => sub { '%' . $_[0] . '%'} # Value
+    price => ['book.price' => sub { '%' . $_[0] . '%' }], # Key and value
+  );
 
 =head1 ATTRIBUTES
 
 =head2 C<param>
 
-    my $param = $mapper->param;
-    $mapper = $mapper->param({title => 'Perl', author => 'Ken'});
+  my $param = $mapper->param;
+  $mapper = $mapper->param({title => 'Perl', author => 'Ken'});
 
 Parameter.
 
 =head2 C<pass>
 
-    my $pass = $mapper->pass;
-    $mapper = $mapper->pass([qw/title author/]);
+  my $pass = $mapper->pass;
+  $mapper = $mapper->pass([qw/title author/]);
 
 the key and value is copied without change when C<map> method is executed.
 
 =head2 C<condition>
 
-    my $condition = $mapper->condition;
-    $mapper = $mapper->condition('exists');
+  my $condition = $mapper->condition;
+  $mapper = $mapper->condition('exists');
 
 Mapping condtion, default to C<length>.
 
@@ -168,26 +166,26 @@ You can set the following values to C<condition>.
 =over 4
 
 =item * C<exists>
-   
-    condition => 'exists'
+ 
+  condition => 'exists'
 
 If key exists, key and value is mapped.
 
 =item * C<defined>
 
-    condition => 'defined';
+  condition => 'defined';
 
 If value is defined, key and value is mapped.
 
 =item * C<length>
 
-    condition => 'length';
+  condition => 'length';
 
 If value is defined and has length, key and value is mapped.
 
 =item * C<code reference>
 
-    condition => sub { defined $_[0] }
+  condition => sub { defined $_[0] }
 
 You can set code reference to C<condtion>.
 The subroutine return true, key and value is mapped.
@@ -199,61 +197,61 @@ and implements the following new ones.
 
 =head2 C<map>
 
-    my $new_param = $mapper->map(
-        price => {key => 'book.price'}
-        title => {value => sub { '%' . $_[0] . '%'}}
-        author => ['book.author' => sub { '%' . $_[0] . '%'}] # Key and value
-    );
+  my $new_param = $mapper->map(
+    price => {key => 'book.price'}
+    title => {value => sub { '%' . $_[0] . '%'}}
+    author => ['book.author' => sub { '%' . $_[0] . '%'}] # Key and value
+  );
 
 Map C<param> into new parameter.
 
 For example, if C<param> is set to
 
-    {
-        price => 1900,
-        title => 'Perl',
-        author => 'Ken',
-        issue_date => '2010-11-11'
-    }
+  {
+    price => 1900,
+    title => 'Perl',
+    author => 'Ken',
+    issue_date => '2010-11-11'
+  }
 
 The following hash reference is returned.
 
-    {
-        'book.price' => 1900,
-        title => '%Perl%',
-        'book.author' => '%Ken%',
-    }
+  {
+    'book.price' => 1900,
+    title => '%Perl%',
+    'book.author' => '%Ken%',
+  }
 
 By default, If the value has length, key and value is mapped.
 
-    title => 'Perl'  # Mapped
-    {title => '' }   # Not mapped
-    {title => undef} # Not mapped
-    {}               # Not mapped
+  title => 'Perl'  # Mapped
+  {title => '' }   # Not mapped
+  {title => undef} # Not mapped
+  {}               # Not mapped
 
 You can set change mapping condition by C<condition> attribute.
 
-    $mapper->condition('defined');
+  $mapper->condition('defined');
 
 Or you can set C<condtion> option for each key.
 
-    my $new_param = $mapper->map(
-        price => {key => 'book.price', condition => 'defined'}]
-        title => {value => sub { '%' . $_[0] . '%'}, condition => 'defined'}
-        author => ['book.author', sub { '%' . $_[0] . '%'}, 'exists']
-    );
+  my $new_param = $mapper->map(
+    price => {key => 'book.price', condition => 'defined'}]
+    title => {value => sub { '%' . $_[0] . '%'}, condition => 'defined'}
+    author => ['book.author', sub { '%' . $_[0] . '%'}, 'exists']
+  );
 
 If C<pass> attrivute is set, the keys and value is copied without change.
 
-    $mapper->pass([qw/title author/]);
-    my $new_param = $mapper->map(price => {key => 'book.price'});
+  $mapper->pass([qw/title author/]);
+  my $new_param = $mapper->map(price => {key => 'book.price'});
 
 The following hash reference
-    
-    {title => 'Perl', author => 'Ken', price => 1900}
+  
+  {title => 'Perl', author => 'Ken', price => 1900}
 
 is mapped to
 
-    {title => 'Perl', author => 'Ken', 'book.price' => 1900}
+  {title => 'Perl', author => 'Ken', 'book.price' => 1900}
 
 =cut

+173 -175

lib/DBIx/Custom/Model.pm

View

@@ -8,151 +8,149 @@ use DBIx::Custom::Util '_subname';
 push @DBIx::Custom::CARP_NOT, __PACKAGE__;
 
 has [qw/dbi table created_at updated_at bind_type join primary_key/],
-    columns => sub { [] };
+  columns => sub { [] };
 
 our $AUTOLOAD;
 
 sub AUTOLOAD {
-    my $self = shift;
-
-    # Method name
-    my ($package, $mname) = $AUTOLOAD =~ /^([\w\:]+)\:\:(\w+)$/;
-
-    # Method
-    $self->{_methods} ||= {};
-    if (my $method = $self->{_methods}->{$mname}) {
-        return $self->$method(@_)
-    }
-    elsif (my $dbi_method = $self->dbi->can($mname)) {
-        $self->dbi->$dbi_method(@_);
-    }
-    elsif ($self->{dbh} && (my $dbh_method = $self->dbh->can($mname))) {
-        $self->dbi->dbh->$dbh_method(@_);
-    }
-    else {
-        croak qq{Can't locate object method "$mname" via "$package" }
-            . _subname;
-    }
+  my $self = shift;
+
+  # Method name
+  my ($package, $mname) = $AUTOLOAD =~ /^([\w\:]+)\:\:(\w+)$/;
+
+  # Method
+  $self->{_methods} ||= {};
+  if (my $method = $self->{_methods}->{$mname}) {
+    return $self->$method(@_)
+  }
+  elsif (my $dbi_method = $self->dbi->can($mname)) {
+    $self->dbi->$dbi_method(@_);
+  }
+  elsif ($self->{dbh} && (my $dbh_method = $self->dbh->can($mname))) {
+    $self->dbi->dbh->$dbh_method(@_);
+  }
+  else {
+    croak qq{Can't locate object method "$mname" via "$package" }
+      . _subname;
+  }
 }
 
 my @methods = qw/insert insert_at update update_at update_all
-  delete delete_at delete_all select select_at count/;
+delete delete_at delete_all select select_at count/;
 for my $method (@methods) {
-    
-    my $code =
-         qq/sub {/ .
-         qq/my \$self = shift;/ .
-         qq/\$self->dbi->$method(/ .
-             qq/\@_ % 2 ? shift : (),/;
-
-    
-    my @attrs = qw/table type primary_key bind_type/;
-    my @insert_attrs = qw/created_at updated_at/;
-    my @update_attrs = qw/updated_at/;
-    my @select_attrs = qw/join/;
-    if ($method eq 'insert') { push @attrs, @insert_attrs }
-    elsif ($method eq 'update') { push @attrs, @update_attrs }
-    elsif (index($method, 'select') != -1 || $method eq 'count') {
-        push @attrs, @select_attrs
-    }
-    
-    for my $attr (@attrs) {
-        $code .= "exists \$self->{$attr} ? ($attr => \$self->{$attr}) : (),";
-    }
-    
-    $code .= qq/\@_);/ .
-         qq/}/;
-    
-    no strict 'refs';
-    *{__PACKAGE__ . "::$method"} = eval $code;
-    croak $code if $@;
+  
+  my $code =
+       qq/sub {/ .
+       qq/my \$self = shift;/ .
+       qq/\$self->dbi->$method(/ .
+           qq/\@_ % 2 ? shift : (),/;
+
+  
+  my @attrs = qw/table type primary_key bind_type/;
+  my @insert_attrs = qw/created_at updated_at/;
+  my @update_attrs = qw/updated_at/;
+  my @select_attrs = qw/join/;
+  if ($method eq 'insert') { push @attrs, @insert_attrs }
+  elsif ($method eq 'update') { push @attrs, @update_attrs }
+  elsif (index($method, 'select') != -1 || $method eq 'count') {
+    push @attrs, @select_attrs
+  }
+  
+  for my $attr (@attrs) {
+    $code .= "exists \$self->{$attr} ? ($attr => \$self->{$attr}) : (),";
+  }
+  
+  $code .= qq/\@_);/ .
+       qq/}/;
+  
+  no strict 'refs';
+  *{__PACKAGE__ . "::$method"} = eval $code;
+  croak $code if $@;
 }
 
 sub update_or_insert {
-    my ($self, $param, %opt) = @_;
-    
-    croak "update_or_insert method need primary_key and id option "
-      unless (defined $opt{id} || defined $self->{id})
-          && (defined $opt{primary_key} || defined $self->{primary_key});
-    
-    my $statement_opt = $opt{option} || {};
-    my $rows = $self->select(%opt, %{$statement_opt->{select} || {}})->all;
-    if (@$rows == 0) {
-        return $self->insert($param, %opt, %{$statement_opt->{insert} || {}});
-    }
-    elsif (@$rows == 1) {
-        return $self->update($param, %opt, %{$statement_opt->{update} || {}});
-    }
-    else {
-        croak "selected row must be one " . _subname;
-    }
+  my ($self, $param, %opt) = @_;
+  
+  croak "update_or_insert method need primary_key and id option "
+    unless (defined $opt{id} || defined $self->{id})
+        && (defined $opt{primary_key} || defined $self->{primary_key});
+  
+  my $statement_opt = $opt{option} || {};
+  my $rows = $self->select(%opt, %{$statement_opt->{select} || {}})->all;
+  if (@$rows == 0) {
+    return $self->insert($param, %opt, %{$statement_opt->{insert} || {}});
+  }
+  elsif (@$rows == 1) {
+    return $self->update($param, %opt, %{$statement_opt->{update} || {}});
+  }
+  else { croak "selected row must be one " . _subname }
 }
 
 sub execute {
-    my $self = shift;
-    
-    if ($ENV{DBIX_CUSTOM_DISABLE_MODEL_EXECUTE}) {
-        $self->dbi->execute(@_);
-    }
-    else {
-        warn "DBIx::Custom::Model execute method is DEPRECATED! " .
-             "use DBIx::Custom execute method. " .
-             "If you want to call DBIx::Custom execute method directory from model, " .
-             "set \$ENV{DBIX_CUSTOM_DISABLE_MODEL_EXECUTE} to 1 " .
-             "until DBIx::Custom::Model execute method is removed in the future." ;
-        return $self->dbi->execute(
-            shift,
-            shift,
-            table => $self->table,
-            bind_type => $self->bind_type,
-            primary_key => $self->primary_key,
-            type => $self->type,
-            @_
-        );    
-    }
+  my $self = shift;
+  
+  if ($ENV{DBIX_CUSTOM_DISABLE_MODEL_EXECUTE}) {
+      $self->dbi->execute(@_);
+  }
+  else {
+    warn "DBIx::Custom::Model execute method is DEPRECATED! " .
+     "use DBIx::Custom execute method. " .
+     "If you want to call DBIx::Custom execute method directory from model, " .
+     "set \$ENV{DBIX_CUSTOM_DISABLE_MODEL_EXECUTE} to 1 " .
+     "until DBIx::Custom::Model execute method is removed in the future." ;
+    return $self->dbi->execute(
+      shift,
+      shift,
+      table => $self->table,
+      bind_type => $self->bind_type,
+      primary_key => $self->primary_key,
+      type => $self->type,
+      @_
+    );    
+  }
 }
 
 sub DESTROY { }
 
 sub helper {
-    my $self = shift;
-    
-    # Merge
-    my $methods = ref $_[0] eq 'HASH' ? $_[0] : {@_};
-    $self->{_methods} = {%{$self->{_methods} || {}}, %$methods};
-    
-    return $self;
+  my $self = shift;
+  
+  # Merge
+  my $methods = ref $_[0] eq 'HASH' ? $_[0] : {@_};
+  $self->{_methods} = {%{$self->{_methods} || {}}, %$methods};
+  
+  return $self;
 }
 
 sub mycolumn {
-    my $self = shift;
-    my $table = shift unless ref $_[0];
-    my $columns = shift;
-    
-    $table ||= $self->table || '';
-    $columns ||= $self->columns;
-    
-    return $self->dbi->mycolumn($table, $columns);
+  my $self = shift;
+  my $table = shift unless ref $_[0];
+  my $columns = shift;
+  
+  $table ||= $self->table || '';
+  $columns ||= $self->columns;
+  
+  return $self->dbi->mycolumn($table, $columns);
 }
 
 sub new {
-    my $self = shift->SUPER::new(@_);
-    
-    # Check attribute names
-    my @attrs = keys %$self;
-    for my $attr (@attrs) {
-        croak qq{"$attr" is invalid attribute name } . _subname
-          unless $self->can($attr);
-    }
-    
-    # Cache
-    for my $attr (qw/dbi table created_at updated_at bind_type join primary_key/) {
-        $self->$attr;
-        $self->{$attr} = undef unless exists $self->{$attr};
-    }
-    $self->columns;
-    
-    return $self;
+  my $self = shift->SUPER::new(@_);
+  
+  # Check attribute names
+  my @attrs = keys %$self;
+  for my $attr (@attrs) {
+    croak qq{"$attr" is invalid attribute name } . _subname
+      unless $self->can($attr);
+  }
+  
+  # Cache
+  for my $attr (qw/dbi table created_at updated_at bind_type join primary_key/) {
+    $self->$attr;
+    $self->{$attr} = undef unless exists $self->{$attr};
+  }
+  $self->columns;
+  
+  return $self;
 }
 
 # DEPRECATED!
@@ -160,11 +158,10 @@ has 'filter';
 has 'name';
 has 'type';
 
-
 # DEPRECATED!
 sub method {
-    warn "method method is DEPRECATED! use helper instead";
-    return shift->helper(@_);
+  warn "method method is DEPRECATED! use helper instead";
+  return shift->helper(@_);
 }
 
 1;
@@ -183,55 +180,55 @@ my $model = DBIx::Custom::Model->new(table => 'books');
 
 =head2 C<dbi>
 
-    my $dbi = $model->dbi;
-    $model = $model->dbi($dbi);
+  my $dbi = $model->dbi;
+  $model = $model->dbi($dbi);
 
 L<DBIx::Custom> object.
 
 =head2 C<created_at EXPERIMENTAL>
 
-    my $created_at = $model->created_at;
-    $model = $model->created_at('created_datatime');
+  my $created_at = $model->created_at;
+  $model = $model->created_at('created_datatime');
 
 Create timestamp column, this is passed to C<insert> or C<update> method.
 
 =head2 C<join>
 
-    my $join = $model->join;
-    $model = $model->join(
-        ['left outer join company on book.company_id = company.id']
-    );
-    
+  my $join = $model->join;
+  $model = $model->join(
+    ['left outer join company on book.company_id = company.id']
+  );
+  
 Join clause, this value is passed to C<select> method.
 
 =head2 C<primary_key>
 
-    my $primary_key = $model->primary_key;
-    $model = $model->primary_key(['id', 'number']);
+  my $primary_key = $model->primary_key;
+  $model = $model->primary_key(['id', 'number']);
 
 Primary key,this is passed to C<insert>, C<update>,
 C<delete>, and C<select> method.
 
 =head2 C<table>
 
-    my $model = $model->table;
-    $model = $model->table('book');
+  my $model = $model->table;
+  $model = $model->table('book');
 
 Table name, this is passed to C<select> method.
 
 =head2 C<bind_type>
 
-    my $type = $model->bind_type;
-    $model = $model->bind_type(['image' => DBI::SQL_BLOB]);
-    
+  my $type = $model->bind_type;
+  $model = $model->bind_type(['image' => DBI::SQL_BLOB]);
+  
 Database data type, this is used as type optioon of C<insert>, 
 C<update>, C<update_all>, C<delete>, C<delete_all>,
 and C<select> method
 
 =head2 C<updated_at EXPERIMENTAL>
 
-    my $updated_at = $model->updated_at;
-    $model = $model->updated_at('updated_datatime');
+  my $updated_at = $model->updated_at;
+  $model = $model->updated_at('updated_datatime');
 
 Updated timestamp column, this is passed to C<update> method.
 
@@ -243,7 +240,7 @@ and implements the following new ones.
 
 =head2 C<count>
 
-    my $count = $model->count;
+  my $count = $model->count;
 
 Get rows count.
 
@@ -251,89 +248,90 @@ Options is same as C<select> method's ones.
 
 =head2 C<delete>
 
-    $model->delete(...);
-    
+  $model->delete(...);
+  
 Same as C<delete> of L<DBIx::Custom> except that
 you don't have to specify options if you set attribute in model.
 
 =head2 C<delete_all>
 
-    $model->delete_all(...);
-    
+  $model->delete_all(...);
+  
 Same as C<delete_all> of L<DBIx::Custom> except that
 you don't have to specify options if you set attribute in model.
 
 =head2 C<insert>
 
-    $model->insert(...);
-    
+  $model->insert(...);
+  
 Same as C<insert> of L<DBIx::Custom> except that
 you don't have to specify options if you set attribute in model.
 
 =head2 C<helper>
 
-    $model->helper(
-        update_or_insert => sub {
-            my $self = shift;
-            
-            # ...
-        },
-        find_or_create   => sub {
-            my $self = shift;
-            
-            # ...
-    );
+  $model->helper(
+    update_or_insert => sub {
+      my $self = shift;
+      
+      # ...
+    },
+    find_or_create   => sub {
+      my $self = shift;
+      
+      # ...
+    }
+  );
 
 Register helper. These helper is called directly from L<DBIx::Custom::Model> object.
 
-    $model->update_or_insert;
-    $model->find_or_create;
+  $model->update_or_insert;
+  $model->find_or_create;
 
 =head2 C<mycolumn>
 
-    my $column = $self->mycolumn;
-    my $column = $self->mycolumn(book => ['author', 'title']);
-    my $column = $self->mycolumn(['author', 'title']);
+  my $column = $self->mycolumn;
+  my $column = $self->mycolumn(book => ['author', 'title']);
+  my $column = $self->mycolumn(['author', 'title']);
 
 Create column clause for myself. The follwoing column clause is created.
 
-    book.author as author,
-    book.title as title
+  book.author as author,
+  book.title as title
 
 If table name is ommited, C<table> attribute of the model is used.
 If column names is omitted, C<columns> attribute of the model is used.
 
 =head2 C<new>
 
-    my $model = DBIx::Custom::Model->new;
+  my $model = DBIx::Custom::Model->new;
 
 Create a L<DBIx::Custom::Model> object.
 
 =head2 C<select>
 
-    $model->select(...);
-    
+  $model->select(...);
+  
 Same as C<select> of L<DBIx::Custom> except that
 you don't have to specify options if you set attribute in model.
 
 =head2 C<update>
 
-    $model->update(...);
-    
+  $model->update(...);
+  
 Same as C<update> of L<DBIx::Custom> except that
 you don't have to specify options if you set attribute in model.
 
 =head2 C<update_all>
 
-    $model->update_all(param => \%param);
-    
+  $model->update_all(param => \%param);
+  
 Same as C<update_all> of L<DBIx::Custom> except that
 you don't have to specify options if you set attribute in model.
 
 =head2 C<update_or_insert>
 
-    $model->update_or_insert(...);
-    
+  $model->update_or_insert(...);
+  
 Same as C<update> of L<DBIx::Custom> except that
 you don't have to specify options if you set attribute in model.
 

+2 -2

lib/DBIx/Custom/NotExists.pm

View

@@ -13,13 +13,13 @@ DBIx::Custom::NotExists
 
 =head1 SYNOPSYS
 
-    $not_exists = DBIx::Custom::NotExists->singleton;
+  $not_exists = DBIx::Custom::NotExists->singleton;
 
 =head1 METHODS
 
 =head2 C<singleton>
 
-    $not_exists = DBIx::Custom::NotExists->singleton;
+  $not_exists = DBIx::Custom::NotExists->singleton;
 
 L<DBIx::Custom::NotExists> singleton object.
 

+43 -43

lib/DBIx/Custom/Order.pm

View

@@ -6,43 +6,43 @@ use overload
   fallback => 1;
 
 has 'dbi',
-    orders => sub { [] };
+  orders => sub { [] };
 
 sub prepend {
-    my $self = shift;
-    
-    for my $order (reverse @_) {
-        if (ref $order eq 'ARRAY') {
-            warn "prepend method receiving array reference is DEPRECATED! " .
-                 "use q method to quote column name.";
-            my $column = shift @$order;
-            $column = $self->dbi->q($column) if defined $column;
-            my $derection = shift @$order;
-            $order = $column;
-            $order .= " $derection" if $derection;
-        }
-        unshift @{$self->orders}, $order;
+  my $self = shift;
+  
+  for my $order (reverse @_) {
+    if (ref $order eq 'ARRAY') {
+      warn "prepend method receiving array reference is DEPRECATED! " .
+           "use q method to quote column name.";
+      my $column = shift @$order;
+      $column = $self->dbi->q($column) if defined $column;
+      my $derection = shift @$order;
+      $order = $column;
+      $order .= " $derection" if $derection;
     }
-    
-    return $self;
+    unshift @{$self->orders}, $order;
+  }
+  
+  return $self;
 }
 
 sub to_string {
-    my $self = shift;
-    
-    my $exists = {};
-    my @orders;
-    for my $order (@{$self->orders}) {
-        next unless defined $order;
-        $order =~ s/^\s+//;
-        $order =~ s/\s+$//;
-        my ($column, $direction) = split /\s+/, $order;
-        push @orders, $order unless $exists->{$column};
-        $exists->{$column} = 1;
-    }
-    
-    return '' unless @orders;
-    return 'order by ' . join(', ', @orders);
+  my $self = shift;
+  
+  my $exists = {};
+  my @orders;
+  for my $order (@{$self->orders}) {
+    next unless defined $order;
+    $order =~ s/^\s+//;
+    $order =~ s/\s+$//;
+    my ($column, $direction) = split /\s+/, $order;
+    push @orders, $order unless $exists->{$column};
+    $exists->{$column} = 1;
+  }
+  
+  return '' unless @orders;
+  return 'order by ' . join(', ', @orders);
 }
 
 1;
@@ -53,24 +53,24 @@ DBIx::Custom::Order - Order by
 
 =head1 SYNOPSIS
 
-    # Result
-    my $order = DBIx::Custom::Order->new;
-    $order->prepend('title', 'author desc');
-    my $order_by = "$order";
-    
+  # Result
+  my $order = DBIx::Custom::Order->new;
+  $order->prepend('title', 'author desc');
+  my $order_by = "$order";
+  
 =head1 ATTRIBUTES
 
 =head2 C<dbi>
 
-    my $dbi = $order->dbi;
-    $order = $order->dbi($dbi);
+  my $dbi = $order->dbi;
+  $order = $order->dbi($dbi);
 
 L<DBIx::Custom> object.
 
 =head2 C<orders>
 
-    my $orders = $result->orders;
-    $result = $result->orders(\%orders);
+  my $orders = $result->orders;
+  $result = $result->orders(\%orders);
 
 Parts of order by clause
 
@@ -81,18 +81,18 @@ and implements the following new ones.
 
 =head2 C<prepend>
 
-    $order->prepend('title', 'author desc');
+  $order->prepend('title', 'author desc');
 
 Prepend order parts to C<orders>.
 
 =head2 C<to_string>
 
-    my $order_by = $order->to_string;
+  my $order_by = $order->to_string;
 
 Create order by clause. If column name is duplicated, First one is used.
 C<to_string> override stringification. so you can write the follwoing way.
 
-    my $order_by = "$order";
+  my $order_by = "$order";
 
 =cut
 

+48 -52

lib/DBIx/Custom/Query.pm

View

@@ -5,72 +5,68 @@ use Carp 'croak';
 use DBIx::Custom::Util '_subname';
 
 has [qw/sth statement/],
-    sql => '',
-    columns => sub { [] };
+  sql => '',
+  columns => sub { [] };
 
 # DEPRECATED!
 has 'default_filter';
 sub filters {
-    warn "DBIx::Custom::Query filters attribute method is DEPRECATED!";
-    my $self = shift;
-    if (@_) {
-        $self->{filters} = $_[0];
-        return $self;
-    }
-    return $self->{filters};
+  warn "DBIx::Custom::Query filters attribute method is DEPRECATED!";
+  my $self = shift;
+  if (@_) {
+    $self->{filters} = $_[0];
+    return $self;
+  }
+  return $self->{filters};
 }
 
 # DEPRECATED!
 sub tables {
-    warn "DBIx::Custom::Query tables attribute method is DEPRECATED!";
-    my $self = shift;
-    if (@_) {
-        $self->{tables} = $_[0];
-        return $self;
-    }
-    return $self->{tables} ||= [];
+  warn "DBIx::Custom::Query tables attribute method is DEPRECATED!";
+  my $self = shift;
+  if (@_) {
+    $self->{tables} = $_[0];
+    return $self;
+  }
+  return $self->{tables} ||= [];
 }
 
 #DEPRECATED!
 sub filter {
-    Carp::carp "DBIx::Custom::Query filter method is DEPRECATED!";
-    my $self = shift;
-    if (@_) {
-        my $filter = {};
-        if (ref $_[0] eq 'HASH') {
-            $filter = $_[0];
-        }
-        else {
-            my $ef = @_ > 1 ? [@_] : $_[0];
-            for (my $i = 0; $i < @$ef; $i += 2) {
-                my $column = $ef->[$i];
-                my $f = $ef->[$i + 1];
-                if (ref $column eq 'ARRAY') {
-                    for my $c (@$column) {
-                        $filter->{$c} = $f;
-                    }
-                }
-                else {
-                    $filter->{$column} = $f;
-                }
-            }
-        }
-        for my $column (keys %$filter) {
-            my $fname = $filter->{$column};
-            if  (exists $filter->{$column}
-              && defined $fname
-              && ref $fname ne 'CODE') 
-            {
-                my $filters = $self->{filters} || {};
-                croak qq{Filter "$fname" is not registered" } . _subname
-                  unless exists $filters->{$fname};
-                $filter->{$column} = $filters->{$fname};
-            }
+  Carp::carp "DBIx::Custom::Query filter method is DEPRECATED!";
+  my $self = shift;
+  if (@_) {
+    my $filter = {};
+    if (ref $_[0] eq 'HASH') {
+        $filter = $_[0];
+    }
+    else {
+      my $ef = @_ > 1 ? [@_] : $_[0];
+      for (my $i = 0; $i < @$ef; $i += 2) {
+        my $column = $ef->[$i];
+        my $f = $ef->[$i + 1];
+        if (ref $column eq 'ARRAY') {
+          for my $c (@$column) { $filter->{$c} = $f }
         }
-        $self->{filter} = {%{$self->{filter} || {}}, %$filter};
-        return $self;
+        else { $filter->{$column} = $f }
+      }
+    }
+    for my $column (keys %$filter) {
+      my $fname = $filter->{$column};
+      if (exists $filter->{$column}
+        && defined $fname
+        && ref $fname ne 'CODE') 
+      {
+        my $filters = $self->{filters} || {};
+        croak qq{Filter "$fname" is not registered" } . _subname
+          unless exists $filters->{$fname};
+        $filter->{$column} = $filters->{$fname};
+      }
     }
-    return $self->{filter} ||= {};
+    $self->{filter} = {%{$self->{filter} || {}}, %$filter};
+    return $self;
+  }
+  return $self->{filter} ||= {};
 }
 
 1;

+215 -215

lib/DBIx/Custom/QueryBuilder.pm

View

@@ -13,51 +13,51 @@ push @DBIx::Custom::Where::CARP_NOT, __PACKAGE__;
 
 # DEPRECATED!
 sub build_query {
-    my ($self, $sql) = @_;
+  my ($self, $sql) = @_;
 
-    my $query = $self->_parse_tag($sql);
-    my $tag_count = delete $query->{tag_count};
-    warn qq/Tag system such as {? name} is DEPRECATED! / .
-         qq/use parameter system such as :name instead/
-      if $tag_count;
-    my $query2 = $self->_parse_parameter($query->sql);
-    $query->sql($query2->sql);
-    for (my $i =0; $i < @{$query->columns}; $i++) {
-        my $column = $query->columns->[$i];
-        if ($column eq 'RESERVED_PARAMETER') {
-            my $column2 = shift @{$query2->columns};
-            croak ":name syntax is wrong"
-              unless defined $column2;
-            $query->columns->[$i] = $column2;
-        }
+  my $query = $self->_parse_tag($sql);
+  my $tag_count = delete $query->{tag_count};
+  warn qq/Tag system such as {? name} is DEPRECATED! / .
+      qq/use parameter system such as :name instead/
+    if $tag_count;
+  my $query2 = $self->_parse_parameter($query->sql);
+  $query->sql($query2->sql);
+  for (my $i =0; $i < @{$query->columns}; $i++) {
+    my $column = $query->columns->[$i];
+    if ($column eq 'RESERVED_PARAMETER') {
+      my $column2 = shift @{$query2->columns};
+      croak ":name syntax is wrong"
+        unless defined $column2;
+      $query->columns->[$i] = $column2;
     }
-    return $query;
+  }
+  return $query;
 }
 
 # DEPRECATED!
 sub _parse_parameter {
-    my ($self, $source) = @_;
-    
-    # Get and replace parameters
-    my $sql = $source || '';
-    my $columns = [];
-    my $c = $self->dbi->safety_character;
-    # Parameter regex
-    $sql =~ s/([^:]):(\d+):([^:])/$1\\:$2\\:$3/g;
-    my $re = qr/(^|.*?[^\\]):([$c\.]+)(?:\{(.*?)\})?(.*)/s;
-    while ($sql =~ /$re/g) {
-        push @$columns, $2;
-        $sql = defined $3 ? "$1$2 $3 ?$4" : "$1?$4";
-    }
-    $sql =~ s/\\:/:/g;
+  my ($self, $source) = @_;
+  
+  # Get and replace parameters
+  my $sql = $source || '';
+  my $columns = [];
+  my $c = $self->dbi->safety_character;
+  # Parameter regex
+  $sql =~ s/([^:]):(\d+):([^:])/$1\\:$2\\:$3/g;
+  my $re = qr/(^|.*?[^\\]):([$c\.]+)(?:\{(.*?)\})?(.*)/s;
+  while ($sql =~ /$re/g) {
+    push @$columns, $2;
+    $sql = defined $3 ? "$1$2 $3 ?$4" : "$1?$4";
+  }
+  $sql =~ s/\\:/:/g;
 
-    # Create query
-    my $query = DBIx::Custom::Query->new(
-        sql => $sql,
-        columns => $columns
-    );
-    
-    return $query;
+  # Create query
+  my $query = DBIx::Custom::Query->new(
+    sql => $sql,
+    columns => $columns
+  );
+  
+  return $query;
 }
 
 # DEPRECATED
@@ -68,190 +68,190 @@ has tags => sub { {} };
 
 # DEPRECATED!
 sub register_tag {
-    my $self = shift;
-    
-    warn "register_tag is DEPRECATED!";
-    
-    # Merge tag
-    my $tags = ref $_[0] eq 'HASH' ? $_[0] : {@_};
-    $self->tags({%{$self->tags}, %$tags});
-    
-    return $self;
+  my $self = shift;
+  
+  warn "register_tag is DEPRECATED!";
+  
+  # Merge tag
+  my $tags = ref $_[0] eq 'HASH' ? $_[0] : {@_};
+  $self->tags({%{$self->tags}, %$tags});
+  
+  return $self;
 }
 
 # 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'};;
+  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 = '';
         }
-        # 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 }
+      }
+      # Tag end charactor
+      elsif ($c eq '}') {
+        # Escaped charactor
+        if ($before eq "\\") {
+          substr($value, -1, 1, '');
+          $value .= $c;
         }
-        # State is tags
+        # Unexpected
         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 }
+          croak qq{Parsing error. unexpected "\}". }
+            . qq{pos $pos of "$original" } . _subname
         }
-        # Save before charactor
-        $before = $c;
-        # increment position
-        $pos++;
+      }
+      # Normal charactor
+      else { $value .= $c }
     }
-    # 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 
-    for my $node (@tree) {
-        # Text
-        if ($node->{type} eq 'text') { $sql .= $node->{value} }
-        # Parameter
-        elsif ($node->{type} eq 'param') {
-            push @$all_columns, 'RESERVED_PARAMETER';
+    # State is tags
+    else {
+      # Tag start charactor
+      if ($c eq '{') {
+        # Escaped charactor
+        if ($before eq "\\") {
+          substr($value, -1, 1, '');
+          $value .= $c;
         }
-        # Tag
+        # Unexpected
         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];
-                push @$tables, $table;
-                $sql .= $table;
-                next;
-            }
-            # Get tag
-            $self->dbi->{_tags} ||= {};
-            my $tag = $self->tag_processors->{$tag_name}
-                             || $self->dbi->{_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;
+          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 
+  for 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];
+        push @$tables, $table;
+        $sql .= $table;
+        next;
+      }
+      # Get tag
+      $self->dbi->{_tags} ||= {};
+      my $tag = $self->tag_processors->{$tag_name}
+                       || $self->dbi->{_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,
-        columns => $all_columns,
-        tables => $tables,
-        tag_count => $tag_count
-    );
-    return $query;
+  }
+  # Query
+  my $query = DBIx::Custom::Query->new(
+    sql => $sql,
+    columns => $all_columns,
+    tables => $tables,
+    tag_count => $tag_count
+  );
+  return $query;
 }
 
 # DEPRECATED!
@@ -259,12 +259,12 @@ has tag_processors => sub { {} };
 
 # DEPRECATED!
 sub register_tag_processor {
-    my $self = shift;
-    warn "register_tag_processor is DEPRECATED!";
-    # Merge tag
-    my $tag_processors = ref $_[0] eq 'HASH' ? $_[0] : {@_};
-    $self->tag_processors({%{$self->tag_processors}, %{$tag_processors}});
-    return $self;
+  my $self = shift;
+  warn "register_tag_processor is DEPRECATED!";
+  # Merge tag
+  my $tag_processors = ref $_[0] eq 'HASH' ? $_[0] : {@_};
+  $self->tag_processors({%{$self->tag_processors}, %{$tag_processors}});
+  return $self;
 }
 
 1;

+395 -395

lib/DBIx/Custom/Result.pm

View

@@ -5,245 +5,245 @@ use Carp 'croak';
 use DBIx::Custom::Util qw/_array_to_hash _subname/;
 
 has [qw/dbi sth/],
-    stash => sub { {} };
+  stash => sub { {} };
 
 *all = \&fetch_hash_all;
 
 sub column {
-    my $self = shift;
-    
-    my $column = [];
-    my $rows = $self->fetch_all;
-    push @$column, $_->[0] for @$rows;
-    return $column;
+  my $self = shift;
+  
+  my $column = [];
+  my $rows = $self->fetch_all;
+  push @$column, $_->[0] for @$rows;
+  return $column;
 }
 
 sub filter {
-    my $self = shift;
-    
-    # Set
-    if (@_) {
-        
-        # Convert filter name to subroutine
-        my $filter = @_ == 1 ? $_[0] : [@_];
-        $filter = _array_to_hash($filter);
-        for my $column (keys %$filter) {
-            my $fname = $filter->{$column};
-            if  (exists $filter->{$column}
-              && defined $fname
-              && ref $fname ne 'CODE') 
-            {
-              croak qq{Filter "$fname" is not registered" } . _subname
-                unless exists $self->dbi->filters->{$fname};
-              $filter->{$column} = $self->dbi->filters->{$fname};
-            }
-        }
-        
-        # Merge
-        $self->{filter} = {%{$self->filter}, %$filter};
-        
-        return $self;
+  my $self = shift;
+  
+  # Set
+  if (@_) {
+    
+    # Convert filter name to subroutine
+    my $filter = @_ == 1 ? $_[0] : [@_];
+    $filter = _array_to_hash($filter);
+    for my $column (keys %$filter) {
+      my $fname = $filter->{$column};
+      if  (exists $filter->{$column}
+        && defined $fname
+        && ref $fname ne 'CODE') 
+      {
+        croak qq{Filter "$fname" is not registered" } . _subname
+          unless exists $self->dbi->filters->{$fname};
+        $filter->{$column} = $self->dbi->filters->{$fname};
+      }
     }
     
-    return $self->{filter} ||= {};
+    # Merge
+    $self->{filter} = {%{$self->filter}, %$filter};
+    
+    return $self;
+  }
+  
+  return $self->{filter} ||= {};
 }
 
 sub fetch {
-    my $self = shift;
-    
-    # Info
-    $self->_cache unless $self->{_cache};
-    
-    # Fetch
-    my @row = $self->{sth}->fetchrow_array;
-    return unless @row;
-    
-    # Type rule
-    if ($self->{type_rule}->{from1} && !$self->{type_rule_off} && !$self->{type_rule1_off}) {
-        my $from = $self->{type_rule}->{from1};
-        for my $type (keys %$from) {
-            for my $column (@{$self->{_type_map}->{$type}}) {
-                $row[$_] = $from->{$type}->($row[$_])
-                  for @{$self->{_pos}{$column} || []};
-            }
-        }
+  my $self = shift;
+  
+  # Info
+  $self->_cache unless $self->{_cache};
+  
+  # Fetch
+  my @row = $self->{sth}->fetchrow_array;
+  return unless @row;
+  
+  # Type rule
+  if ($self->{type_rule}->{from1} && !$self->{type_rule_off} && !$self->{type_rule1_off}) {
+    my $from = $self->{type_rule}->{from1};
+    for my $type (keys %$from) {
+      for my $column (@{$self->{_type_map}->{$type}}) {
+        $row[$_] = $from->{$type}->($row[$_])
+          for @{$self->{_pos}{$column} || []};
+      }
     }
-    if ($self->{type_rule}->{from2} && !$self->{type_rule_off} && !$self->{type_rule2_off}) {
-        my $from = $self->{type_rule}->{from2};
-        for my $type (keys %$from) {
-            for my $column (@{$self->{_type_map}->{$type}}) {
-                $row[$_] = $from->{$type}->($row[$_])
-                  for @{$self->{_pos}{$column} || []};
-            }
-        }
+  }
+  if ($self->{type_rule}->{from2} && !$self->{type_rule_off} && !$self->{type_rule2_off}) {
+    my $from = $self->{type_rule}->{from2};
+    for my $type (keys %$from) {
+      for my $column (@{$self->{_type_map}->{$type}}) {
+        $row[$_] = $from->{$type}->($row[$_])
+          for @{$self->{_pos}{$column} || []};
+      }
     }
-    
-    # Filter
-    if (($self->{filter} || $self->{default_filter}) && !$self->{filter_off}) {
-         my @columns = $self->{default_filter} ? keys %{$self->{_columns}}
-           : keys %{$self->{filter}};
-         
-         for my $column (@columns) {
-             my $filter = exists $self->{filter}->{$column} ? $self->{filter}->{$column}
-               : $self->{default_filter};
-             next unless $filter;
-             $row[$_] = $filter->($row[$_])
-               for @{$self->{_pos}{$column} || []};
-         }
-    }
-    if ($self->{end_filter} && !$self->{filter_off}) {
-         for my $column (keys %{$self->{end_filter}}) {
-             next unless $self->{end_filter}->{$column};
-             $row[$_] = $self->{end_filter}->{$column}->($row[$_])
-               for @{$self->{_pos}{$column} || []};
-         }
-    }
-
-    return \@row;
+  }
+  
+  # Filter
+  if (($self->{filter} || $self->{default_filter}) && !$self->{filter_off}) {
+     my @columns = $self->{default_filter} ? keys %{$self->{_columns}}
+       : keys %{$self->{filter}};
+     
+     for my $column (@columns) {
+       my $filter = exists $self->{filter}->{$column} ? $self->{filter}->{$column}
+         : $self->{default_filter};
+       next unless $filter;
+       $row[$_] = $filter->($row[$_])
+         for @{$self->{_pos}{$column} || []};
+     }
+  }
+  if ($self->{end_filter} && !$self->{filter_off}) {
+     for my $column (keys %{$self->{end_filter}}) {
+       next unless $self->{end_filter}->{$column};
+       $row[$_] = $self->{end_filter}->{$column}->($row[$_])
+         for @{$self->{_pos}{$column} || []};
+     }
+  }
+
+  return \@row;
 }
 
 sub fetch_hash {
-    my $self = shift;
-    
-    # Info
-    $self->_cache unless $self->{_cache};
-    
-    # Fetch
-    return unless my $row = $self->{sth}->fetchrow_hashref;
-    
-    # Type rule
-    if ($self->{type_rule}->{from1} &&
-      !$self->{type_rule_off} && !$self->{type_rule1_off})
-    {
-        my $from = $self->{type_rule}->{from1};
-        for my $type (keys %$from) {
-            $from->{$type} and $row->{$_} = $from->{$type}->($row->{$_})
-              for @{$self->{_type_map}->{$type}};
-        }
-    }
-    if ($self->{type_rule}->{from2} &&
-      !$self->{type_rule_off} && !$self->{type_rule2_off})
-    {
-        my $from = $self->{type_rule}->{from2};
-        for my $type (keys %{$self->{type_rule}->{from2}}) {
-            $from->{$type} and $row->{$_} = $from->{$type}->($row->{$_})
-              for @{$self->{_type_map}->{$type}};
-        }
-    }        
-    # Filter
-    if (($self->{filter} || $self->{default_filter}) &&
-      !$self->{filter_off})
-    {
-         my @columns = $self->{default_filter} ? keys %{$self->{_columns}}
-           : keys %{$self->{filter}};
-         
-         for my $column (@columns) {
-             next unless exists $row->{$column};
-             my $filter = exists $self->{filter}->{$column} ? $self->{filter}->{$column}
-               : $self->{default_filter};
-             $row->{$column} = $filter->($row->{$column}) if $filter;
-         }
+  my $self = shift;
+  
+  # Info
+  $self->_cache unless $self->{_cache};
+  
+  # Fetch
+  return unless my $row = $self->{sth}->fetchrow_hashref;
+  
+  # Type rule
+  if ($self->{type_rule}->{from1} &&
+    !$self->{type_rule_off} && !$self->{type_rule1_off})
+  {
+    my $from = $self->{type_rule}->{from1};
+    for my $type (keys %$from) {
+      $from->{$type} and $row->{$_} = $from->{$type}->($row->{$_})
+        for @{$self->{_type_map}->{$type}};
     }
-    if ($self->{end_filter} && !$self->{filter_off}) {
-         exists $self->{_columns}{$_} && $self->{end_filter}->{$_} and
-             $row->{$_} = $self->{end_filter}->{$_}->($row->{$_})
-           for keys %{$self->{end_filter}};
+  }
+  if ($self->{type_rule}->{from2} &&
+    !$self->{type_rule_off} && !$self->{type_rule2_off})
+  {
+    my $from = $self->{type_rule}->{from2};
+    for my $type (keys %{$self->{type_rule}->{from2}}) {
+      $from->{$type} and $row->{$_} = $from->{$type}->($row->{$_})
+        for @{$self->{_type_map}->{$type}};
     }
-    $row;
+  }        
+  # Filter
+  if (($self->{filter} || $self->{default_filter}) &&
+    !$self->{filter_off})
+  {
+     my @columns = $self->{default_filter} ? keys %{$self->{_columns}}
+       : keys %{$self->{filter}};
+     
+     for my $column (@columns) {
+       next unless exists $row->{$column};
+       my $filter = exists $self->{filter}->{$column} ? $self->{filter}->{$column}
+         : $self->{default_filter};
+       $row->{$column} = $filter->($row->{$column}) if $filter;
+     }
+  }
+  if ($self->{end_filter} && !$self->{filter_off}) {
+     exists $self->{_columns}{$_} && $self->{end_filter}->{$_} and
+         $row->{$_} = $self->{end_filter}->{$_}->($row->{$_})
+       for keys %{$self->{end_filter}};
+  }
+  $row;
 }
 
 sub fetch_all {
-    my $self = shift;
-    
-    # Fetch all rows
-    my $rows = [];
-    while(my $row = $self->fetch) { push @$rows, $row}
-    
-    return $rows;
+  my $self = shift;
+  
+  # Fetch all rows
+  my $rows = [];
+  while(my $row = $self->fetch) { push @$rows, $row}
+  
+  return $rows;
 }
 
 sub fetch_hash_all {
-    my $self = shift;
-    
-    # Fetch all rows as hash
-    my $rows = [];
-    while(my $row = $self->fetch_hash) { push @$rows, $row }
-    
-    return $rows;
+  my $self = shift;
+  
+  # Fetch all rows as hash
+  my $rows = [];
+  while(my $row = $self->fetch_hash) { push @$rows, $row }
+  
+  return $rows;
 }
 
 sub fetch_hash_one {
-    my $self = shift;
-    
-    # Fetch hash
-    my $row = $self->fetch_hash;
-    return unless $row;
-    
-    # Finish statement handle
-    $self->sth->finish;
-    
-    return $row;
+  my $self = shift;
+  
+  # Fetch hash
+  my $row = $self->fetch_hash;
+  return unless $row;
+  
+  # Finish statement handle
+  $self->sth->finish;
+  
+  return $row;
 }
 
 sub fetch_hash_multi {
-    my ($self, $count) = @_;
-    
-    # Fetch multiple rows
-    croak 'Row count must be specified ' . _subname
-      unless $count;
-    
-    return if $self->{_finished};
-
-    my $rows = [];
-    for (my $i = 0; $i < $count; $i++) {
-        my $row = $self->fetch_hash;
-        unless ($row) {
-            $self->{_finished} = 1;
-            last;
-        }
-        push @$rows, $row;
+  my ($self, $count) = @_;
+  
+  # Fetch multiple rows
+  croak 'Row count must be specified ' . _subname
+    unless $count;
+  
+  return if $self->{_finished};
+
+  my $rows = [];
+  for (my $i = 0; $i < $count; $i++) {
+    my $row = $self->fetch_hash;
+    unless ($row) {
+      $self->{_finished} = 1;
+      last;
     }
-    
-    return unless @$rows;
-    return $rows;
+    push @$rows, $row;
+  }
+  
+  return unless @$rows;
+  return $rows;
 }
 
 sub fetch_multi {
-    my ($self, $count) = @_;
-    
-    # Row count not specifed
-    croak 'Row count must be specified ' . _subname
-      unless $count;
-    
-    return if $self->{_finished};
-    
-    # Fetch multi rows
-    my $rows = [];
-    for (my $i = 0; $i < $count; $i++) {
-        my $row = $self->fetch;
-        unless ($row) {
-            $self->{_finished} = 1;
-            last;
-        }
-        push @$rows, $row;
+  my ($self, $count) = @_;
+  
+  # Row count not specifed
+  croak 'Row count must be specified ' . _subname
+    unless $count;
+  
+  return if $self->{_finished};
+  
+  # Fetch multi rows
+  my $rows = [];
+  for (my $i = 0; $i < $count; $i++) {
+    my $row = $self->fetch;
+    unless ($row) {
+      $self->{_finished} = 1;
+      last;
     }
-    
-    return unless @$rows;
-    return $rows;
+    push @$rows, $row;
+  }
+  
+  return unless @$rows;
+  return $rows;
 }
 
 
 sub fetch_one {
-    my $self = shift;
-    
-    # Fetch
-    my $row = $self->fetch;
-    return unless $row;
-    
-    # Finish statement handle
-    $self->sth->finish;
-    
-    return $row;
+  my $self = shift;
+  
+  # Fetch
+  my $row = $self->fetch;
+  return unless $row;
+  
+  # Finish statement handle
+  $self->sth->finish;
+  
+  return $row;
 }
 
 sub header { shift->sth->{NAME} }
@@ -251,183 +251,183 @@ sub header { shift->sth->{NAME} }
 *one = \&fetch_hash_one;
 
 sub type_rule {
-    my $self = shift;
-    
-    if (@_) {
-        my $type_rule = ref $_[0] eq 'HASH' ? $_[0] : {@_};
-
-        # From
-        for my $i (1 .. 2) {
-            $type_rule->{"from$i"} = _array_to_hash($type_rule->{"from$i"});
-            for my $data_type (keys %{$type_rule->{"from$i"} || {}}) {
-                croak qq{data type of from$i section must be lower case or number}
-                  if $data_type =~ /[A-Z]/;
-                my $fname = $type_rule->{"from$i"}{$data_type};
-                if (defined $fname && ref $fname ne 'CODE') {
-                    croak qq{Filter "$fname" is not registered" } . _subname
-                      unless exists $self->dbi->filters->{$fname};
-                    
-                    $type_rule->{"from$i"}{$data_type} = $self->dbi->filters->{$fname};
-                }
-            }
+  my $self = shift;
+  
+  if (@_) {
+    my $type_rule = ref $_[0] eq 'HASH' ? $_[0] : {@_};
+
+    # From
+    for my $i (1 .. 2) {
+      $type_rule->{"from$i"} = _array_to_hash($type_rule->{"from$i"});
+      for my $data_type (keys %{$type_rule->{"from$i"} || {}}) {
+        croak qq{data type of from$i section must be lower case or number}
+          if $data_type =~ /[A-Z]/;
+        my $fname = $type_rule->{"from$i"}{$data_type};
+        if (defined $fname && ref $fname ne 'CODE') {
+          croak qq{Filter "$fname" is not registered" } . _subname
+            unless exists $self->dbi->filters->{$fname};
+          
+          $type_rule->{"from$i"}{$data_type} = $self->dbi->filters->{$fname};
         }
-        $self->{type_rule} = $type_rule;
-        
-        return $self;
+      }
     }
+    $self->{type_rule} = $type_rule;
     
-    return $self->{type_rule} || {};
+    return $self;
+  }
+  
+  return $self->{type_rule} || {};
 }
 
 sub type_rule_off {
-    my $self = shift;
-    $self->{type_rule_off} = 1;
-    return $self;
+  my $self = shift;
+  $self->{type_rule_off} = 1;
+  return $self;
 }
 
 sub type_rule_on {
-    my $self = shift;
-    $self->{type_rule_off} = 0;
-    return $self;
+  my $self = shift;
+  $self->{type_rule_off} = 0;
+  return $self;
 }
 
 sub type_rule1_off {
-    my $self = shift;
-    $self->{type_rule1_off} = 1;
-    return $self;
+  my $self = shift;
+  $self->{type_rule1_off} = 1;
+  return $self;
 }
 
 sub type_rule1_on {
-    my $self = shift;
-    $self->{type_rule1_off} = 0;
-    return $self;
+  my $self = shift;
+  $self->{type_rule1_off} = 0;
+  return $self;
 }
 
 sub type_rule2_off {
-    my $self = shift;
-    $self->{type_rule2_off} = 1;
-    return $self;
+  my $self = shift;
+  $self->{type_rule2_off} = 1;
+  return $self;
 }
 
 sub type_rule2_on {
-    my $self = shift;
-    $self->{type_rule2_off} = 0;
-    return $self;
+  my $self = shift;
+  $self->{type_rule2_off} = 0;
+  return $self;
 }
 
 sub value {
-    my $self = shift;
-    my $row = $self->fetch_one;
-    my $value = $row ? $row->[0] : undef;
-    return $value;
+  my $self = shift;
+  my $row = $self->fetch_one;
+  my $value = $row ? $row->[0] : undef;
+  return $value;
 }
 
 sub _cache {
-    my $self = shift;
-    $self->{_type_map} = {};
-    $self->{_pos} = {};
-    $self->{_columns} = {};
-    for (my $i = 0; $i < @{$self->{sth}->{NAME}}; $i++) {
-        my $type = lc $self->{sth}{TYPE}[$i];
-        my $name = $self->{sth}{NAME}[$i];
-        $self->{_type_map}{$type} ||= [];
-        push @{$self->{_type_map}{$type}}, $name;
-        $self->{_pos}{$name} ||= [];
-        push @{$self->{_pos}{$name}}, $i;
-        $self->{_columns}{$name} = 1;
-    }
-    $self->{_cache} = 1;
+  my $self = shift;
+  $self->{_type_map} = {};
+  $self->{_pos} = {};
+  $self->{_columns} = {};
+  for (my $i = 0; $i < @{$self->{sth}->{NAME}}; $i++) {
+    my $type = lc $self->{sth}{TYPE}[$i];
+    my $name = $self->{sth}{NAME}[$i];
+    $self->{_type_map}{$type} ||= [];
+    push @{$self->{_type_map}{$type}}, $name;
+    $self->{_pos}{$name} ||= [];
+    push @{$self->{_pos}{$name}}, $i;
+    $self->{_columns}{$name} = 1;
+  }
+  $self->{_cache} = 1;
 }
 
 # DEPRECATED!
 sub fetch_hash_first {
-    my $self = shift;
-    warn "DBIx::Custom::Result::fetch_hash_first is DEPRECATED! use fetch_hash_one instead";
-    return $self->fetch_hash_one(@_);
+  my $self = shift;
+  warn "DBIx::Custom::Result::fetch_hash_first is DEPRECATED! use fetch_hash_one instead";
+  return $self->fetch_hash_one(@_);
 }
 
 # DEPRECATED!
 sub fetch_first {
-    my $self = shift;
-    warn "DBIx::Custom::Result::fetch_first is DEPRECATED! use fetch_one instead";
-    return $self->fetch_one(@_);
+  my $self = shift;
+  warn "DBIx::Custom::Result::fetch_first is DEPRECATED! use fetch_one instead";
+  return $self->fetch_one(@_);
 }
 
 # DEPRECATED!
 sub filter_off {
-    warn "filter_off method is DEPRECATED!";
-    my $self = shift;
-    $self->{filter_off} = 1;
-    return $self;
+  warn "filter_off method is DEPRECATED!";
+  my $self = shift;
+  $self->{filter_off} = 1;
+  return $self;
 }
 
 # DEPRECATED!
 sub filter_on {
-    warn "filter_on method is DEPRECATED!";
-    my $self = shift;
-    $self->{filter_off} = 0;
-    return $self;
+  warn "filter_on method is DEPRECATED!";
+  my $self = shift;
+  $self->{filter_off} = 0;
+  return $self;
 }
 
 # DEPRECATED!
 sub end_filter {
-    warn "end_filter method is DEPRECATED!";
-    my $self = shift;
-    if (@_) {
-        my $end_filter = {};
-        if (ref $_[0] eq 'HASH') { $end_filter = $_[0] }
-        else { 
-            $end_filter = _array_to_hash(
-                @_ > 1 ? [@_] : $_[0]
-            );
-        }
-        for my $column (keys %$end_filter) {
-            my $fname = $end_filter->{$column};
-            if  (exists $end_filter->{$column}
-              && defined $fname
-              && ref $fname ne 'CODE') 
-            {
-              croak qq{Filter "$fname" is not registered" } . _subname
-                unless exists $self->dbi->filters->{$fname};
-              $end_filter->{$column} = $self->dbi->filters->{$fname};
-            }
-        }
-        $self->{end_filter} = {%{$self->end_filter}, %$end_filter};
-        return $self;
+  warn "end_filter method is DEPRECATED!";
+  my $self = shift;
+  if (@_) {
+    my $end_filter = {};
+    if (ref $_[0] eq 'HASH') { $end_filter = $_[0] }
+    else { 
+      $end_filter = _array_to_hash(
+          @_ > 1 ? [@_] : $_[0]
+      );
+    }
+    for my $column (keys %$end_filter) {
+      my $fname = $end_filter->{$column};
+      if (exists $end_filter->{$column}
+        && defined $fname
+        && ref $fname ne 'CODE') 
+      {
+        croak qq{Filter "$fname" is not registered" } . _subname
+          unless exists $self->dbi->filters->{$fname};
+        $end_filter->{$column} = $self->dbi->filters->{$fname};
+      }
     }
-    return $self->{end_filter} ||= {};
+    $self->{end_filter} = {%{$self->end_filter}, %$end_filter};
+    return $self;
+  }
+  return $self->{end_filter} ||= {};
 }
 # DEPRECATED!
 sub remove_end_filter {
-    warn "remove_end_filter is DEPRECATED!";
-    my $self = shift;
-    $self->{end_filter} = {};
-    return $self;
+  warn "remove_end_filter is DEPRECATED!";
+  my $self = shift;
+  $self->{end_filter} = {};
+  return $self;
 }
 # DEPRECATED!
 sub remove_filter {
-    warn "remove_filter is DEPRECATED!";
-    my $self = shift;
-    $self->{filter} = {};
-    return $self;
+  warn "remove_filter is DEPRECATED!";
+  my $self = shift;
+  $self->{filter} = {};
+  return $self;
 }
 # DEPRECATED!
 sub default_filter {
-    warn "default_filter is DEPRECATED!";
-    my $self = shift;
-    if (@_) {
-        my $fname = $_[0];
-        if (@_ && !$fname) {
-            $self->{default_filter} = undef;
-        }
-        else {
-            croak qq{Filter "$fname" is not registered}
-              unless exists $self->dbi->filters->{$fname};
-            $self->{default_filter} = $self->dbi->filters->{$fname};
-        }
-        return $self;
+  warn "default_filter is DEPRECATED!";
+  my $self = shift;
+  if (@_) {
+    my $fname = $_[0];
+    if (@_ && !$fname) {
+      $self->{default_filter} = undef;
     }
-    return $self->{default_filter};
+    else {
+      croak qq{Filter "$fname" is not registered}
+        unless exists $self->dbi->filters->{$fname};
+      $self->{default_filter} = $self->dbi->filters->{$fname};
+    }
+    return $self;
+  }
+  return $self->{default_filter};
 }
 # DEPRECATED!
 has 'filter_check'; 
@@ -440,48 +440,48 @@ DBIx::Custom::Result - Result of select statement
 
 =head1 SYNOPSIS
 
-    # Result
-    my $result = $dbi->select(table => 'book');
-
-    # Fetch a row and put it into array reference
-    while (my $row = $result->fetch) {
-        my $author = $row->[0];
-        my $title  = $row->[1];
-    }
-    
-    # Fetch only a first row and put it into array reference
-    my $row = $result->fetch_one;
-    
-    # Fetch all rows and put them into array of array reference
-    my $rows = $result->fetch_all;
-
-    # Fetch a row and put it into hash reference
-    while (my $row = $result->fetch_hash) {
-        my $title  = $row->{title};
-        my $author = $row->{author};
-    }
-    
-    # Fetch only a first row and put it into hash reference
-    my $row = $result->fetch_hash_one;
-    my $row = $result->one; # Alias for "fetch_hash_one"
-    
-    # Fetch all rows and put them into array of hash reference
-    my $rows = $result->fetch_hash_all;
-    my $rows = $result->all; # Alias for "fetch_hash_all"
+  # Result
+  my $result = $dbi->select(table => 'book');
+
+  # Fetch a row and put it into array reference
+  while (my $row = $result->fetch) {
+    my $author = $row->[0];
+    my $title  = $row->[1];
+  }
+  
+  # Fetch only a first row and put it into array reference
+  my $row = $result->fetch_one;
+  
+  # Fetch all rows and put them into array of array reference
+  my $rows = $result->fetch_all;
+
+  # Fetch a row and put it into hash reference
+  while (my $row = $result->fetch_hash) {
+    my $title  = $row->{title};
+    my $author = $row->{author};
+  }
+  
+  # Fetch only a first row and put it into hash reference
+  my $row = $result->fetch_hash_one;
+  my $row = $result->one; # Alias for "fetch_hash_one"
+  
+  # Fetch all rows and put them into array of hash reference
+  my $rows = $result->fetch_hash_all;
+  my $rows = $result->all; # Alias for "fetch_hash_all"
 
 =head1 ATTRIBUTES
 
 =head2 C<dbi>
 
-    my $dbi = $result->dbi;
-    $result = $result->dbi($dbi);
+  my $dbi = $result->dbi;
+  $result = $result->dbi($dbi);
 
 L<DBIx::Custom> object.
 
 =head2 C<sth>
 
-    my $sth = $reuslt->sth
-    $result = $result->sth($sth);
+  my $sth = $reuslt->sth
+  $result = $result->sth($sth);
 
 Statement handle of L<DBI>.
 
@@ -492,72 +492,72 @@ and implements the following new ones.
 
 =head2 C<all>
 
-    my $rows = $result->all;
+  my $rows = $result->all;
 
 Same as C<fetch_hash_all>.
 
 =head2 C<column> EXPERIMENTAL
 
-    my $column = $result->column;
+  my $column = $result->column;
 
 Get first column's all values.
 
-    my $names = $dbi->select('name', table => 'book')->column;
+  my $names = $dbi->select('name', table => 'book')->column;
 
 =head2 C<fetch>
 
-    my $row = $result->fetch;
+  my $row = $result->fetch;
 
 Fetch a row and put it into array reference.
 
 =head2 C<fetch_all>
 
-    my $rows = $result->fetch_all;
+  my $rows = $result->fetch_all;
 
 Fetch all rows and put them into array of array reference.
 
 =head2 C<fetch_one>
 
-    my $row = $result->fetch_one;
+  my $row = $result->fetch_one;
 
 Fetch only a first row and put it into array reference,
 and finish statment handle.
 
 =head2 C<fetch_hash>
 
-    my $row = $result->fetch_hash;
+  my $row = $result->fetch_hash;
 
 Fetch a row and put it into hash reference.
 
 =head2 C<fetch_hash_all>
 
-    my $rows = $result->fetch_hash_all;
+  my $rows = $result->fetch_hash_all;
 
 Fetch all rows and put them into array of hash reference.
 
 =head2 C<fetch_hash_one>
-    
-    my $row = $result->fetch_hash_one;
+  
+  my $row = $result->fetch_hash_one;
 
 Fetch only a first row and put it into hash reference,
 and finish statment handle.
 
 =head2 C<fetch_hash_multi>
 
-    my $rows = $result->fetch_hash_multi(5);
-    
+  my $rows = $result->fetch_hash_multi(5);
+  
 Fetch multiple rows and put them into array of hash reference.
 
 =head2 C<fetch_multi>
 
-    my $rows = $result->fetch_multi(5);
-    
+  my $rows = $result->fetch_multi(5);
+  
 Fetch multiple rows and put them into array of array reference.
 
 =head2 C<filter>
 
-    $result->filter(title  => sub { uc $_[0] }, author => 'to_upper');
-    $result->filter([qw/title author/] => 'to_upper');
+  $result->filter(title  => sub { uc $_[0] }, author => 'to_upper');
+  $result->filter([qw/title author/] => 'to_upper');
 
 Set filter for column.
 You can use subroutine or filter name as filter.
@@ -565,92 +565,92 @@ This filter is executed after C<type_rule> filter.
 
 =head2 C<header>
 
-    my $header = $result->header;
+  my $header = $result->header;
 
 Get header column names.
 
 =head2 C<one>
 
-    my $row = $result->one;
+  my $row = $result->one;
 
 Alias for C<fetch_hash_one>.
 
 =head2 C<stash>
 
-    my $stash = $result->stash;
-    my $foo = $result->stash->{foo};
-    $result->stash->{foo} = $foo;
+  my $stash = $result->stash;
+  my $foo = $result->stash->{foo};
+  $result->stash->{foo} = $foo;
 
 Stash is hash reference to save some data.
 
 =head2 C<type_rule>
-    
-    # Merge type rule
-    $result->type_rule(
-        # DATE
-        9 => sub { ... },
-        # DATETIME or TIMESTAMP
-        11 => sub { ... }
-    );
-
-    # Replace type rule(by reference)
-    $result->type_rule([
-        # DATE
-        9 => sub { ... },
-        # DATETIME or TIMESTAMP
-        11 => sub { ... }
-    ]);
+  
+  # Merge type rule
+  $result->type_rule(
+    # DATE
+    9 => sub { ... },
+    # DATETIME or TIMESTAMP
+    11 => sub { ... }
+  );
+
+  # Replace type rule(by reference)
+  $result->type_rule([
+    # DATE
+    9 => sub { ... },
+    # DATETIME or TIMESTAMP
+    11 => sub { ... }
+  ]);
 
 This is same as L<DBIx::Custom>'s C<type_rule>'s <from>.
 
 =head2 C<type_rule_off>
 
-    $result = $result->type_rule_off;
+  $result = $result->type_rule_off;
 
 Turn C<from1> and C<from2> type rule off.
 By default, type rule is on.
 
 =head2 C<type_rule_on>
 
-    $result = $result->type_rule_on;
+  $result = $result->type_rule_on;
 
 Turn C<from1> and C<from2> type rule on.
 By default, type rule is on.
 
 =head2 C<type_rule1_off>
 
-    $result = $result->type_rule1_off;
+  $result = $result->type_rule1_off;
 
 Turn C<from1> type rule off.
 By default, type rule is on.
 
 =head2 C<type_rule1_on>
 
-    $result = $result->type_rule1_on;
+  $result = $result->type_rule1_on;
 
 Turn C<from1> type rule on.
 By default, type rule is on.
 
 =head2 C<type_rule2_off>
 
-    $result = $result->type_rule2_off;
+  $result = $result->type_rule2_off;
 
 Turn C<from2> type rule off.
 By default, type rule is on.
 
 =head2 C<type_rule2_on>
 
-    $result = $result->type_rule2_on;
+  $result = $result->type_rule2_on;
 
 Turn C<from2> type rule on.
 By default, type rule is on.
 
 =head2 C<value> EXPERIMENTAL
 
-    my $value = $result->value;
+  my $value = $result->value;
 
 Get first column's first value.
 
-    my $count = $dbi->select('count(*)')->value;
+  my $count = $dbi->select('count(*)')->value;
 
 =cut

+53 -55

lib/DBIx/Custom/Tag.pm

View

@@ -14,42 +14,40 @@ sub greater_than_equal { _basic('>=', @_) }
 sub greater_than       { _basic('>',  @_) }
 
 sub in {
-    my ($column, $count) = @_;
-    
-    # Check arguments
-    croak qq{Column name and count of values must be specified in tag "{in }" }
-        . _subname
-      unless $column && $count && $count =~ /^\d+$/;
-
-    # Part of statement
-    my $s = "$column in (";
-    for (my $i = 0; $i < $count; $i++) {
-        $s .= '?, ';
-    }
-    $s =~ s/, $//;
-    $s .= ')';
-    
-    # Columns
-    my $columns = [];
-    push @$columns, $column for (0 .. $count - 1);
-    
-    return [$s, $columns];
+  my ($column, $count) = @_;
+  
+  # Check arguments
+  croak qq{Column name and count of values must be specified in tag "{in }" }
+      . _subname
+    unless $column && $count && $count =~ /^\d+$/;
+
+  # Part of statement
+  my $s = "$column in (";
+  for (my $i = 0; $i < $count; $i++) { $s .= '?, ' }
+  $s =~ s/, $//;
+  $s .= ')';
+  
+  # Columns
+  my $columns = [];
+  push @$columns, $column for (0 .. $count - 1);
+  
+  return [$s, $columns];
 }
 
 sub insert_param {
-    my @columns = @_;
-    
-    # Insert parameters
-    my $s = '(';
-    $s .= "$_, " for @columns;
-    $s =~ s/, $//;
-    $s .= ') ';
-    $s .= 'values (';
-    $s .= "?, " for @columns;
-    $s =~ s/, $//;
-    $s .= ')';
-    
-    return [$s, \@columns];
+  my @columns = @_;
+  
+  # Insert parameters
+  my $s = '(';
+  $s .= "$_, " for @columns;
+  $s =~ s/, $//;
+  $s .= ') ';
+  $s .= 'values (';
+  $s .= "?, " for @columns;
+  $s =~ s/, $//;
+  $s .= ')';
+  
+  return [$s, \@columns];
 }
 
 sub like               { _basic('like', @_) }
@@ -58,34 +56,34 @@ sub lower_than         { _basic('<',    @_) }
 sub not_equal          { _basic('<>',   @_) }
 
 sub placeholder {
-    my $column = shift;
-    
-    # Check arguments
-    croak qq{Column name must be specified in tag "{? }" } . _subname
-      unless $column;
-    
-    return ['?', [$column]];
+  my $column = shift;
+  
+  # Check arguments
+  croak qq{Column name must be specified in tag "{? }" } . _subname
+    unless $column;
+  
+  return ['?', [$column]];
 }
 
 sub update_param {
-    my @columns = @_;
-    
-    # Update parameters
-    my $s = 'set ';
-    $s .= "$_ = ?, " for @columns;
-    $s =~ s/, $//;
-    
-    return [$s, \@columns];
+  my @columns = @_;
+  
+  # Update parameters
+  my $s = 'set ';
+  $s .= "$_ = ?, " for @columns;
+  $s =~ s/, $//;
+  
+  return [$s, \@columns];
 }
 
 sub _basic {
-    my ($name, $column) = @_;
-    
-    # Check arguments
-    croak qq{Column name must be specified in tag "{$name }" } . _subname
-      unless $column;
-    
-    return ["$column $name ?", [$column]];
+  my ($name, $column) = @_;
+  
+  # Check arguments
+  croak qq{Column name must be specified in tag "{$name }" } . _subname
+    unless $column;
+  
+  return ["$column $name ?", [$column]];
 }
 
 1;

+15 -19

lib/DBIx/Custom/Util.pm

View

@@ -8,27 +8,23 @@ use base 'Exporter';
 our @EXPORT_OK = qw/_array_to_hash _subname/;
 
 sub _array_to_hash {
-    my $array = shift;
+  my $array = shift;
+  
+  return $array if ref $array eq 'HASH';
+  return unless $array;
+  
+  my $hash = {};
+  
+  for (my $i = 0; $i < @$array; $i += 2) {
+    my $key = $array->[$i];
+    my $f = $array->[$i + 1];
     
-    return $array if ref $array eq 'HASH';
-    return unless $array;
-    
-    my $hash = {};
-    
-    for (my $i = 0; $i < @$array; $i += 2) {
-        my $key = $array->[$i];
-        my $f = $array->[$i + 1];
-        
-        if (ref $key eq 'ARRAY') {
-            for my $k (@$key) {
-                $hash->{$k} = $f;
-            }
-        }
-        else {
-            $hash->{$key} = $f;
-        }
+    if (ref $key eq 'ARRAY') {
+      for my $k (@$key) { $hash->{$k} = $f }
     }
-    return $hash;
+    else { $hash->{$key} = $f }
+  }
+  return $hash;
 }
 
 sub _subname { '(' . (caller 1)[3] . ')' }

+196 -197

lib/DBIx/Custom/Where.pm

View

@@ -10,135 +10,134 @@ use overload '""' => sub { shift->to_string }, fallback => 1;
 push @DBIx::Custom::CARP_NOT, __PACKAGE__;
 
 has [qw/dbi param/],
-    clause => sub { [] };
+  clause => sub { [] };
 
 sub new {
-    my $self = shift->SUPER::new(@_);
-    
-    # Check attribute names
-    my @attrs = keys %$self;
-    for my $attr (@attrs) {
-        croak qq{"$attr" is invalid attribute name (} . _subname . ")"
-          unless $self->can($attr);
-    }
-    
-    return $self;
+  my $self = shift->SUPER::new(@_);
+  
+  # Check attribute names
+  my @attrs = keys %$self;
+  for my $attr (@attrs) {
+    croak qq{"$attr" is invalid attribute name (} . _subname . ")"
+      unless $self->can($attr);
+  }
+  
+  return $self;
 }
 
 sub to_string {
-    my $self = shift;
-    
-    # Clause
-    my $clause = $self->clause;
-    $clause = ['and', $clause] unless ref $clause eq 'ARRAY';
-    $clause->[0] = 'and' unless @$clause;
-    
-    # Parse
-    my $where = [];
-    my $count = {};
-    $self->{_query_builder} = $self->dbi->query_builder;
-    my $c = $self->dbi->safety_character;
-    $self->{_re} = $c eq 'a-zA-Z0-9_' ?
-      qr/[^\\]:([$c\.]+)/so : qr/[^\\]:([$c\.]+)/s;
-    
-    $self->{_quote} = $self->dbi->_quote;
-    $self->{_tag_parse} = exists $ENV{DBIX_CUSTOM_TAG_PARSE}
-      ? $ENV{DBIX_CUSTOM_TAG_PARSE} : $self->dbi->{tag_parse};
-    $self->_parse($clause, $where, $count, 'and');
+  my $self = shift;
+  
+  # Clause
+  my $clause = $self->clause;
+  $clause = ['and', $clause] unless ref $clause eq 'ARRAY';
+  $clause->[0] = 'and' unless @$clause;
+  
+  # Parse
+  my $where = [];
+  my $count = {};
+  $self->{_query_builder} = $self->dbi->query_builder;
+  my $c = $self->dbi->safety_character;
+  $self->{_re} = $c eq 'a-zA-Z0-9_' ?
+    qr/[^\\]:([$c\.]+)/so : qr/[^\\]:([$c\.]+)/s;
+  
+  $self->{_quote} = $self->dbi->_quote;
+  $self->{_tag_parse} = exists $ENV{DBIX_CUSTOM_TAG_PARSE}
+    ? $ENV{DBIX_CUSTOM_TAG_PARSE} : $self->dbi->{tag_parse};
+  $self->_parse($clause, $where, $count, 'and');
 
-    # Stringify
-    unshift @$where, 'where' if @$where;
-    return join(' ', @$where);
+  # Stringify
+  unshift @$where, 'where' if @$where;
+  return join(' ', @$where);
 }
-    
+  
 our %VALID_OPERATIONS = map { $_ => 1 } qw/and or/;
 sub _parse {
-    my ($self, $clause, $where, $count, $op, $info) = @_;
+  my ($self, $clause, $where, $count, $op, $info) = @_;
+  
+  # Array
+  if (ref $clause eq 'ARRAY') {
+    # Start
+    push @$where, '(';
     
-    # Array
-    if (ref $clause eq 'ARRAY') {
-        
-        # Start
-        push @$where, '(';
-        
-        # Operation
-        my $op = $clause->[0] || '';
-        croak qq{First argument must be "and" or "or" in where clause } .
-              qq{"$op" is passed} . _subname . ")"
-          unless $VALID_OPERATIONS{$op};
-        
-        my $pushed_array;
-        # Parse internal clause
-        for (my $i = 1; $i < @$clause; $i++) {
-            my $pushed = $self->_parse($clause->[$i], $where, $count, $op);
-            push @$where, $op if $pushed;
-            $pushed_array = 1 if $pushed;
-        }
-        pop @$where if $where->[-1] eq $op;
-        
-        # Undo
-        if ($where->[-1] eq '(') {
-            pop @$where;
-            pop @$where if ($where->[-1] || '') eq $op;
-        }
-        # End
-        else { push @$where, ')' }
-        
-        return $pushed_array;
+    # Operation
+    my $op = $clause->[0] || '';
+    croak qq{First argument must be "and" or "or" in where clause } .
+        qq{"$op" is passed} . _subname . ")"
+      unless $VALID_OPERATIONS{$op};
+    
+    my $pushed_array;
+    # Parse internal clause
+    for (my $i = 1; $i < @$clause; $i++) {
+      my $pushed = $self->_parse($clause->[$i], $where, $count, $op);
+      push @$where, $op if $pushed;
+      $pushed_array = 1 if $pushed;
+    }
+    pop @$where if $where->[-1] eq $op;
+    
+    # Undo
+    if ($where->[-1] eq '(') {
+      pop @$where;
+      pop @$where if ($where->[-1] || '') eq $op;
     }
+    # End
+    else { push @$where, ')' }
     
-    # String
+    return $pushed_array;
+  }
+  
+  # String
+  else {
+    # Pushed
+    my $pushed;
+    
+    # Column
+    my $re = $self->{_re};
+    
+    my $column;
+    my $sql = " " . $clause || '';
+    if ($self->{_tag_parse} && ($sql =~ /\s\{/)) {
+      my $columns = $self->dbi->query_builder->build_query($sql)->{columns};
+      $column = $columns->[0];
+    }
     else {
-        # Pushed
-        my $pushed;
-        
-        # Column
-        my $re = $self->{_re};
-        
-        my $column;
-        my $sql = " " . $clause || '';
-        if ($self->{_tag_parse} && ($sql =~ /\s\{/)) {
-            my $columns = $self->dbi->query_builder->build_query($sql)->{columns};
-            $column = $columns->[0];
-        }
-        else {
-            $sql =~ s/([0-9]):/$1\\:/g;
-            ($column) = $sql =~ /$re/;
-        }
-        unless (defined $column) {
-            push @$where, $clause;
-            $pushed = 1;
-            return $pushed;
-        }
-        
-        # Column count up
-        my $count = ++$count->{$column};
+      $sql =~ s/([0-9]):/$1\\:/g;
+      ($column) = $sql =~ /$re/;
+    }
+    unless (defined $column) {
+      push @$where, $clause;
+      $pushed = 1;
+      return $pushed;
+    }
+    
+    # Column count up
+    my $count = ++$count->{$column};
+    
+    # Push
+    my $param = $self->{param};
+    if (ref $param eq 'HASH') {
+      if (exists $param->{$column}) {
+        my $if = $self->{_if};
         
-        # Push
-        my $param = $self->{param};
-        if (ref $param eq 'HASH') {
-            if (exists $param->{$column}) {
-                my $if = $self->{_if};
-                
-                if (ref $param->{$column} eq 'ARRAY') {
-                    $pushed = 1 if exists $param->{$column}->[$count - 1]
-                      && ref $param->{$column}->[$count - 1] ne 'DBIx::Custom::NotExists'
-                }
-                elsif ($count == 1) { $pushed = 1 }
-            }
-            push @$where, $clause if $pushed;
+        if (ref $param->{$column} eq 'ARRAY') {
+          $pushed = 1 if exists $param->{$column}->[$count - 1]
+            && ref $param->{$column}->[$count - 1] ne 'DBIx::Custom::NotExists'
         }
-        elsif (!defined $param) {
-            push @$where, $clause;
-            $pushed = 1;
-        }
-        else {
-            croak "Parameter must be hash reference or undfined value ("
-                . _subname . ")"
-        }
-        return $pushed;
+        elsif ($count == 1) { $pushed = 1 }
+      }
+      push @$where, $clause if $pushed;
+    }
+    elsif (!defined $param) {
+      push @$where, $clause;
+      $pushed = 1;
     }
-    return;
+    else {
+      croak "Parameter must be hash reference or undfined value ("
+          . _subname . ")"
+    }
+    return $pushed;
+  }
+  return;
 }
 1;
 
@@ -147,103 +146,103 @@ sub _parse {
 DBIx::Custom::Where - Where clause
 
 =head1 SYNOPSYS
-    
-    # Create DBIx::Custom::Where object
-    my $where = $dbi->where;
-    
-    # Set clause and parameter
-    $where->clause(['and', ':title{like}', ':price{=}']);
-    
-    # Create where clause by to_string method
-    my $where_clause = $where->to_string;
-    
-    # Create where clause by stringify
-    my $where_clause = "$where";
-    
-    # Created where clause in the above way
-    where :title{=} and :price{like}
-    
-    # Only price condition
-    $where->clause(['and', ':title{like}', ':price{=}']);
-    $where->param({price => 1900});
-    my $where_clause = "$where";
-    
-    # Created where clause in the above way
-    where :price{=}
-    
-    # Only title condition
-    $where->clause(['and', ':title{like}', ':price{=}']);
-    $where->param({title => 'Perl'});
-    my $where_clause = "$where";
-    
-    # Created where clause in the above way
-    where :title{like}
-    
-    # Nothing
-    $where->clause(['and', ':title{like}', ':price{=}']);
-    $where->param({});
-    my $where_clause = "$where";
-    
-    # or condition
-    $where->clause(['or', ':title{like}', ':price{=}']);
-    
-    # More than one parameter
-    $where->clause(['and', ':price{>}', ':price{<}']);
-    $where->param({price => [1000, 2000]});
-    
-    # Only first condition
-    $where->clause(['and', ':price{>}', ':price{<}']);
-    $where->param({price => [1000, $dbi->not_exists]});
-    
-    # Only second condition
-    $where->clause(['and', ':price{>}', ':price{<}']);
-    $where->param({price => [$dbi->not_exists, 2000]});
-    
-    # More complex condition
-    $where->clause(
-        [
-            'and',
-            ':price{=}',
-            ['or', ':title{=}', ':title{=}', ':title{=}']
-        ]
-    );
-    my $where_clause = "$where";
-    
-    # Created where clause in the above way
-    where :price{=} and (:title{=} or :title{=} or :title{=})
-    
-    # Using Full-qualified column name
-    $where->clause(['and', ':book.title{like}', ':book.price{=}']);
+  
+  # Create DBIx::Custom::Where object
+  my $where = $dbi->where;
+  
+  # Set clause and parameter
+  $where->clause(['and', ':title{like}', ':price{=}']);
+  
+  # Create where clause by to_string method
+  my $where_clause = $where->to_string;
+  
+  # Create where clause by stringify
+  my $where_clause = "$where";
+  
+  # Created where clause in the above way
+  where :title{=} and :price{like}
+  
+  # Only price condition
+  $where->clause(['and', ':title{like}', ':price{=}']);
+  $where->param({price => 1900});
+  my $where_clause = "$where";
+  
+  # Created where clause in the above way
+  where :price{=}
+  
+  # Only title condition
+  $where->clause(['and', ':title{like}', ':price{=}']);
+  $where->param({title => 'Perl'});
+  my $where_clause = "$where";
+  
+  # Created where clause in the above way
+  where :title{like}
+  
+  # Nothing
+  $where->clause(['and', ':title{like}', ':price{=}']);
+  $where->param({});
+  my $where_clause = "$where";
+  
+  # or condition
+  $where->clause(['or', ':title{like}', ':price{=}']);
+  
+  # More than one parameter
+  $where->clause(['and', ':price{>}', ':price{<}']);
+  $where->param({price => [1000, 2000]});
+  
+  # Only first condition
+  $where->clause(['and', ':price{>}', ':price{<}']);
+  $where->param({price => [1000, $dbi->not_exists]});
+  
+  # Only second condition
+  $where->clause(['and', ':price{>}', ':price{<}']);
+  $where->param({price => [$dbi->not_exists, 2000]});
+  
+  # More complex condition
+  $where->clause(
+    [
+      'and',
+      ':price{=}',
+      ['or', ':title{=}', ':title{=}', ':title{=}']
+    ]
+  );
+  my $where_clause = "$where";
+  
+  # Created where clause in the above way
+  where :price{=} and (:title{=} or :title{=} or :title{=})
+  
+  # Using Full-qualified column name
+  $where->clause(['and', ':book.title{like}', ':book.price{=}']);
 
 =head1 ATTRIBUTES
 
 =head2 C<clause>
 
-    my $clause = $where->clause;
-    $where = $where->clause(
-        ['and',
-            ':title{=}', 
-            ['or', ':date{<}', ':date{>}']
-        ]
-    );
+  my $clause = $where->clause;
+  $where = $where->clause(
+    ['and',
+      ':title{=}', 
+      ['or', ':date{<}', ':date{>}']
+    ]
+  );
 
 Where clause. Above one is expanded to the following SQL by to_string
 If all parameter names is exists.
 
-    where title = :title and ( date < :date or date > :date )
+  where title = :title and ( date < :date or date > :date )
 
 =head2 C<param>
 
-    my $param = $where->param;
-    $where = $where->param({
-        title => 'Perl',
-        date => ['2010-11-11', '2011-03-05'],
-    });
+  my $param = $where->param;
+  $where = $where->param({
+    title => 'Perl',
+    date => ['2010-11-11', '2011-03-05'],
+  });
 
 =head2 C<dbi>
 
-    my $dbi = $where->dbi;
-    $where = $where->dbi($dbi);
+  my $dbi = $where->dbi;
+  $where = $where->dbi($dbi);
 
 L<DBIx::Custom> object.
 
@@ -254,12 +253,12 @@ and implements the following new ones.
 
 =head2 C<to_string>
 
-    $where->to_string;
+  $where->to_string;
 
 Convert where clause to string.
 
 double quote is override to execute C<to_string> method.
 
-    my $string_where = "$where";
+  my $string_where = "$where";
 
 =cut

...	...	@@ -10,119 +10,117 @@ use DBIx::Custom::Util '_subname';
10	10	push @DBIx::Custom::CARP_NOT, __PACKAGE__;
11	11
12	12	has [qw/param/],
13		- condition => sub {
14		- sub { defined $_[0] && length $_[0] }
15		- },
16		- pass => sub { [] };
	13	+ condition => sub {
	14	+ sub { defined $_[0] && length $_[0] }
	15	+ },
	16	+ pass => sub { [] };
17	17
18	18	sub map {
19		- my ($self, %rule) = @_;
20		- my $param = $self->param;
21		- $rule{$_} = {key => $_} for @{$self->pass};
	19	+ my ($self, %rule) = @_;
	20	+ my $param = $self->param;
	21	+ $rule{$_} = {key => $_} for @{$self->pass};
	22	+
	23	+ # Mapping
	24	+ my $new_param = {};
	25	+ for my $key (keys %rule) {
22	26
23		- # Mapping
24		- my $new_param = {};
25		- for my $key (keys %rule) {
26		-
27		- my $mapping = $rule{$key};
28		-
29		- # Get mapping information
30		- my $new_key;
31		- my $value;
32		- my $condition;
33		-
34		- if (ref $mapping eq 'ARRAY') {
35		- $new_key = $mapping->[0];
36		- $value = $mapping->[1];
37		- $condition = ref $mapping->[2] eq 'HASH' ? $mapping->[2]->{condition} : $mapping->[2];
38		- }
39		- elsif (ref $mapping eq 'HASH') {
40		- $new_key = $mapping->{key};
41		- $value = $mapping->{value};
42		- $condition = $mapping->{condition};
43		- }
44		- elsif (!ref $mapping) {
45		- $new_key = $mapping;
46		- warn qq/map method's string value "$mapping" is DEPRECATED. / .
47		- qq/use {key => ...} syntax instead/
	27	+ my $mapping = $rule{$key};
	28	+
	29	+ # Get mapping information
	30	+ my $new_key;
	31	+ my $value;
	32	+ my $condition;
	33	+
	34	+ if (ref $mapping eq 'ARRAY') {
	35	+ $new_key = $mapping->[0];
	36	+ $value = $mapping->[1];
	37	+ $condition = ref $mapping->[2] eq 'HASH' ? $mapping->[2]->{condition} : $mapping->[2];
	38	+ }
	39	+ elsif (ref $mapping eq 'HASH') {
	40	+ $new_key = $mapping->{key};
	41	+ $value = $mapping->{value};
	42	+ $condition = $mapping->{condition};
	43	+ }
	44	+ elsif (!ref $mapping) {
	45	+ $new_key = $mapping;
	46	+ warn qq/map method's string value "$mapping" is DEPRECATED. / .
	47	+ qq/use {key => ...} syntax instead/
	48	+ }
	49	+ elsif (ref $mapping eq 'CODE') {
	50	+ $value = $mapping;
	51	+ warn qq/map method's code reference value "$mapping" is DEPRECATED. / .
	52	+ qq/use {value => ...} syntax instead/
	53	+ }
	54	+
	55	+ $new_key = $key unless defined $new_key;
	56	+ $condition \|\|= $self->condition;
	57	+ $condition = $self->_condition_to_sub($condition);
	58	+
	59	+ # Map parameter
	60	+ if (ref $condition eq 'CODE') {
	61	+ if (ref $param->{$key} eq 'ARRAY') {
	62	+ $new_param->{$new_key} = [];
	63	+ for (my $i = 0; $i < @{$param->{$key}}; $i++) {
	64	+ $new_param->{$new_key}->[$i]
	65	+ = $condition->($param->{$key}->[$i]) ? $param->{$key}->[$i]
	66	+ : DBIx::Custom::NotExists->singleton;
48	67	}
49		- elsif (ref $mapping eq 'CODE') {
50		- $value = $mapping;
51		- warn qq/map method's code reference value "$mapping" is DEPRECATED. / .
52		- qq/use {value => ...} syntax instead/
	68	+ }
	69	+ else {
	70	+ if ($condition->($param->{$key})) {
	71	+ $new_param->{$new_key} = defined $value
	72	+ ? $value->($param->{$key}) : $param->{$key};
53	73	}
54		-
55		- $new_key = $key unless defined $new_key;
56		- $condition \|\|= $self->condition;
57		- $condition = $self->_condition_to_sub($condition);
58		-
59		- # Map parameter
60		- if (ref $condition eq 'CODE') {
61		- if (ref $param->{$key} eq 'ARRAY') {
62		- $new_param->{$new_key} = [];
63		- for (my $i = 0; $i < @{$param->{$key}}; $i++) {
64		- $new_param->{$new_key}->[$i]
65		- = $condition->($param->{$key}->[$i]) ? $param->{$key}->[$i]
66		- : DBIx::Custom::NotExists->singleton;
67		- }
68		- }
69		- else {
70		- if ($condition->($param->{$key})) {
71		- $new_param->{$new_key} = defined $value
72		- ? $value->($param->{$key})
73		- : $param->{$key};
74		- }
75		- }
	74	+ }
	75	+ }
	76	+ elsif ($condition eq 'exists') {
	77	+ if (ref $param->{$key} eq 'ARRAY') {
	78	+ $new_param->{$new_key} = [];
	79	+ for (my $i = 0; $i < @{$param->{$key}}; $i++) {
	80	+ $new_param->{$new_key}->[$i]
	81	+ = exists $param->{$key}->[$i] ? $param->{$key}->[$i]
	82	+ : DBIx::Custom::NotExists->singleton;
76	83	}
77		- elsif ($condition eq 'exists') {
78		- if (ref $param->{$key} eq 'ARRAY') {
79		- $new_param->{$new_key} = [];
80		- for (my $i = 0; $i < @{$param->{$key}}; $i++) {
81		- $new_param->{$new_key}->[$i]
82		- = exists $param->{$key}->[$i] ? $param->{$key}->[$i]
83		- : DBIx::Custom::NotExists->singleton;
84		- }
85		- }
86		- else {
87		- if (exists $param->{$key}) {
88		- $new_param->{$new_key} = defined $value
89		- ? $value->($param->{$key})
90		- : $param->{$key};
91		- }
92		- }
	84	+ }
	85	+ else {
	86	+ if (exists $param->{$key}) {
	87	+ $new_param->{$new_key} = defined $value
	88	+ ? $value->($param->{$key}) : $param->{$key};
93	89	}
94		- else { croak qq/Condition must be code reference or "exists" / . _subname }
	90	+ }
95	91	}
96		-
97		- return $new_param;
	92	+ else { croak qq/Condition must be code reference or "exists" / . _subname }
	93	+ }
	94	+
	95	+ return $new_param;
98	96	}
99	97
100	98	sub new {
101		- my $self = shift->SUPER::new(@_);
102		-
103		- # Check attribute names
104		- my @attrs = keys %$self;
105		- for my $attr (@attrs) {
106		- croak qq{"$attr" is invalid attribute name (} . _subname . ")"
107		- unless $self->can($attr);
108		- }
109		-
110		- return $self;
	99	+ my $self = shift->SUPER::new(@_);
	100	+
	101	+ # Check attribute names
	102	+ my @attrs = keys %$self;
	103	+ for my $attr (@attrs) {
	104	+ croak qq{"$attr" is invalid attribute name (} . _subname . ")"
	105	+ unless $self->can($attr);
	106	+ }
	107	+
	108	+ return $self;
111	109	}
112	110
113	111
114	112	sub _condition_to_sub {
115		- my ($self, $if) = @_;
116		- $if = $if eq 'exists' ? $if
117		- : $if eq 'defined' ? sub { defined $_[0] }
118		- : $if eq 'length' ? sub { defined $_[0] && length $_[0] }
119		- : ref $if eq 'CODE' ? $if
120		- : undef;
121		-
122		- croak "You can must specify right value to C<condition> " . _subname
123		- unless $if;
124		-
125		- return $if;
	113	+ my ($self, $if) = @_;
	114	+ $if = $if eq 'exists' ? $if
	115	+ : $if eq 'defined' ? sub { defined $_[0] }
	116	+ : $if eq 'length' ? sub { defined $_[0] && length $_[0] }
	117	+ : ref $if eq 'CODE' ? $if
	118	+ : undef;
	119	+
	120	+ croak "You can must specify right value to C<condition> " . _subname
	121	+ unless $if;
	122	+
	123	+ return $if;
126	124	}
127	125
128	126	1;
...	...	@@ -133,33 +131,33 @@ DBIx::Custom::Mapper - Mapper of parameter
133	131
134	132	=head1 SYNOPSYS
135	133
136		- my $mapper = $dbi->mapper(param => $param);
137		- my $new_param = $mapper->map(
138		- title => 'book.title', # Key
139		- author => sub { '%' . $_[0] . '%'} # Value
140		- price => ['book.price' => sub { '%' . $_[0] . '%' }], # Key and value
141		- );
	134	+ my $mapper = $dbi->mapper(param => $param);
	135	+ my $new_param = $mapper->map(
	136	+ title => 'book.title', # Key
	137	+ author => sub { '%' . $_[0] . '%'} # Value
	138	+ price => ['book.price' => sub { '%' . $_[0] . '%' }], # Key and value
	139	+ );
142	140
143	141	=head1 ATTRIBUTES
144	142
145	143	=head2 C<param>
146	144
147		- my $param = $mapper->param;
148		- $mapper = $mapper->param({title => 'Perl', author => 'Ken'});
	145	+ my $param = $mapper->param;
	146	+ $mapper = $mapper->param({title => 'Perl', author => 'Ken'});
149	147
150	148	Parameter.
151	149
152	150	=head2 C<pass>
153	151
154		- my $pass = $mapper->pass;
155		- $mapper = $mapper->pass([qw/title author/]);
	152	+ my $pass = $mapper->pass;
	153	+ $mapper = $mapper->pass([qw/title author/]);
156	154
157	155	the key and value is copied without change when C<map> method is executed.
158	156
159	157	=head2 C<condition>
160	158
161		- my $condition = $mapper->condition;
162		- $mapper = $mapper->condition('exists');
	159	+ my $condition = $mapper->condition;
	160	+ $mapper = $mapper->condition('exists');
163	161
164	162	Mapping condtion, default to C<length>.
165	163
...	...	@@ -168,26 +166,26 @@ You can set the following values to C<condition>.
168	166	=over 4
169	167
170	168	=item * C<exists>
171		-
172		- condition => 'exists'
	169	+
	170	+ condition => 'exists'
173	171
174	172	If key exists, key and value is mapped.
175	173
176	174	=item * C<defined>
177	175
178		- condition => 'defined';
	176	+ condition => 'defined';
179	177
180	178	If value is defined, key and value is mapped.
181	179
182	180	=item * C<length>
183	181
184		- condition => 'length';
	182	+ condition => 'length';
185	183
186	184	If value is defined and has length, key and value is mapped.
187	185
188	186	=item * C<code reference>
189	187
190		- condition => sub { defined $_[0] }
	188	+ condition => sub { defined $_[0] }
191	189
192	190	You can set code reference to C<condtion>.
193	191	The subroutine return true, key and value is mapped.
...	...	@@ -199,61 +197,61 @@ and implements the following new ones.
199	197
200	198	=head2 C<map>
201	199
202		- my $new_param = $mapper->map(
203		- price => {key => 'book.price'}
204		- title => {value => sub { '%' . $_[0] . '%'}}
205		- author => ['book.author' => sub { '%' . $_[0] . '%'}] # Key and value
206		- );
	200	+ my $new_param = $mapper->map(
	201	+ price => {key => 'book.price'}
	202	+ title => {value => sub { '%' . $_[0] . '%'}}
	203	+ author => ['book.author' => sub { '%' . $_[0] . '%'}] # Key and value
	204	+ );
207	205
208	206	Map C<param> into new parameter.
209	207
210	208	For example, if C<param> is set to
211	209
212		- {
213		- price => 1900,
214		- title => 'Perl',
215		- author => 'Ken',
216		- issue_date => '2010-11-11'
217		- }
	210	+ {
	211	+ price => 1900,
	212	+ title => 'Perl',
	213	+ author => 'Ken',
	214	+ issue_date => '2010-11-11'
	215	+ }
218	216
219	217	The following hash reference is returned.
220	218
221		- {
222		- 'book.price' => 1900,
223		- title => '%Perl%',
224		- 'book.author' => '%Ken%',
225		- }
	219	+ {
	220	+ 'book.price' => 1900,
	221	+ title => '%Perl%',
	222	+ 'book.author' => '%Ken%',
	223	+ }
226	224
227	225	By default, If the value has length, key and value is mapped.
228	226
229		- title => 'Perl' # Mapped
230		- {title => '' } # Not mapped
231		- {title => undef} # Not mapped
232		- {} # Not mapped
	227	+ title => 'Perl' # Mapped
	228	+ {title => '' } # Not mapped
	229	+ {title => undef} # Not mapped
	230	+ {} # Not mapped
233	231
234	232	You can set change mapping condition by C<condition> attribute.
235	233
236		- $mapper->condition('defined');
	234	+ $mapper->condition('defined');
237	235
238	236	Or you can set C<condtion> option for each key.
239	237
240		- my $new_param = $mapper->map(
241		- price => {key => 'book.price', condition => 'defined'}]
242		- title => {value => sub { '%' . $_[0] . '%'}, condition => 'defined'}
243		- author => ['book.author', sub { '%' . $_[0] . '%'}, 'exists']
244		- );
	238	+ my $new_param = $mapper->map(
	239	+ price => {key => 'book.price', condition => 'defined'}]
	240	+ title => {value => sub { '%' . $_[0] . '%'}, condition => 'defined'}
	241	+ author => ['book.author', sub { '%' . $_[0] . '%'}, 'exists']
	242	+ );
245	243
246	244	If C<pass> attrivute is set, the keys and value is copied without change.
247	245
248		- $mapper->pass([qw/title author/]);
249		- my $new_param = $mapper->map(price => {key => 'book.price'});
	246	+ $mapper->pass([qw/title author/]);
	247	+ my $new_param = $mapper->map(price => {key => 'book.price'});
250	248
251	249	The following hash reference
252		-
253		- {title => 'Perl', author => 'Ken', price => 1900}
	250	+
	251	+ {title => 'Perl', author => 'Ken', price => 1900}
254	252
255	253	is mapped to
256	254
257		- {title => 'Perl', author => 'Ken', 'book.price' => 1900}
	255	+ {title => 'Perl', author => 'Ken', 'book.price' => 1900}
258	256
259	257	=cut

...	...	@@ -8,151 +8,149 @@ use DBIx::Custom::Util '_subname';
8	8	push @DBIx::Custom::CARP_NOT, __PACKAGE__;
9	9
10	10	has [qw/dbi table created_at updated_at bind_type join primary_key/],
11		- columns => sub { [] };
	11	+ columns => sub { [] };
12	12
13	13	our $AUTOLOAD;
14	14
15	15	sub AUTOLOAD {
16		- my $self = shift;
17		-
18		- # Method name
19		- my ($package, $mname) = $AUTOLOAD =~ /^([\w\:]+)\:\:(\w+)$/;
20		-
21		- # Method
22		- $self->{_methods} \|\|= {};
23		- if (my $method = $self->{_methods}->{$mname}) {
24		- return $self->$method(@_)
25		- }
26		- elsif (my $dbi_method = $self->dbi->can($mname)) {
27		- $self->dbi->$dbi_method(@_);
28		- }
29		- elsif ($self->{dbh} && (my $dbh_method = $self->dbh->can($mname))) {
30		- $self->dbi->dbh->$dbh_method(@_);
31		- }
32		- else {
33		- croak qq{Can't locate object method "$mname" via "$package" }
34		- . _subname;
35		- }
	16	+ my $self = shift;
	17	+
	18	+ # Method name
	19	+ my ($package, $mname) = $AUTOLOAD =~ /^([\w\:]+)\:\:(\w+)$/;
	20	+
	21	+ # Method
	22	+ $self->{_methods} \|\|= {};
	23	+ if (my $method = $self->{_methods}->{$mname}) {
	24	+ return $self->$method(@_)
	25	+ }
	26	+ elsif (my $dbi_method = $self->dbi->can($mname)) {
	27	+ $self->dbi->$dbi_method(@_);
	28	+ }
	29	+ elsif ($self->{dbh} && (my $dbh_method = $self->dbh->can($mname))) {
	30	+ $self->dbi->dbh->$dbh_method(@_);
	31	+ }
	32	+ else {
	33	+ croak qq{Can't locate object method "$mname" via "$package" }
	34	+ . _subname;
	35	+ }
36	36	}
37	37
38	38	my @methods = qw/insert insert_at update update_at update_all
39		- delete delete_at delete_all select select_at count/;
	39	+delete delete_at delete_all select select_at count/;
40	40	for my $method (@methods) {
41		-
42		- my $code =
43		- qq/sub {/ .
44		- qq/my \$self = shift;/ .
45		- qq/\$self->dbi->$method(/ .
46		- qq/\@_ % 2 ? shift : (),/;
47		-
48		-
49		- my @attrs = qw/table type primary_key bind_type/;
50		- my @insert_attrs = qw/created_at updated_at/;
51		- my @update_attrs = qw/updated_at/;
52		- my @select_attrs = qw/join/;
53		- if ($method eq 'insert') { push @attrs, @insert_attrs }
54		- elsif ($method eq 'update') { push @attrs, @update_attrs }
55		- elsif (index($method, 'select') != -1 \|\| $method eq 'count') {
56		- push @attrs, @select_attrs
57		- }
58		-
59		- for my $attr (@attrs) {
60		- $code .= "exists \$self->{$attr} ? ($attr => \$self->{$attr}) : (),";
61		- }
62		-
63		- $code .= qq/\@_);/ .
64		- qq/}/;
65		-
66		- no strict 'refs';
67		- *{__PACKAGE__ . "::$method"} = eval $code;
68		- croak $code if $@;
	41	+
	42	+ my $code =
	43	+ qq/sub {/ .
	44	+ qq/my \$self = shift;/ .
	45	+ qq/\$self->dbi->$method(/ .
	46	+ qq/\@_ % 2 ? shift : (),/;
	47	+
	48	+
	49	+ my @attrs = qw/table type primary_key bind_type/;
	50	+ my @insert_attrs = qw/created_at updated_at/;
	51	+ my @update_attrs = qw/updated_at/;
	52	+ my @select_attrs = qw/join/;
	53	+ if ($method eq 'insert') { push @attrs, @insert_attrs }
	54	+ elsif ($method eq 'update') { push @attrs, @update_attrs }
	55	+ elsif (index($method, 'select') != -1 \|\| $method eq 'count') {
	56	+ push @attrs, @select_attrs
	57	+ }
	58	+
	59	+ for my $attr (@attrs) {
	60	+ $code .= "exists \$self->{$attr} ? ($attr => \$self->{$attr}) : (),";
	61	+ }
	62	+
	63	+ $code .= qq/\@_);/ .
	64	+ qq/}/;
	65	+
	66	+ no strict 'refs';
	67	+ *{__PACKAGE__ . "::$method"} = eval $code;
	68	+ croak $code if $@;
69	69	}
70	70
71	71	sub update_or_insert {
72		- my ($self, $param, %opt) = @_;
73		-
74		- croak "update_or_insert method need primary_key and id option "
75		- unless (defined $opt{id} \|\| defined $self->{id})
76		- && (defined $opt{primary_key} \|\| defined $self->{primary_key});
77		-
78		- my $statement_opt = $opt{option} \|\| {};
79		- my $rows = $self->select(%opt, %{$statement_opt->{select} \|\| {}})->all;
80		- if (@$rows == 0) {
81		- return $self->insert($param, %opt, %{$statement_opt->{insert} \|\| {}});
82		- }
83		- elsif (@$rows == 1) {
84		- return $self->update($param, %opt, %{$statement_opt->{update} \|\| {}});
85		- }
86		- else {
87		- croak "selected row must be one " . _subname;
88		- }
	72	+ my ($self, $param, %opt) = @_;
	73	+
	74	+ croak "update_or_insert method need primary_key and id option "
	75	+ unless (defined $opt{id} \|\| defined $self->{id})
	76	+ && (defined $opt{primary_key} \|\| defined $self->{primary_key});
	77	+
	78	+ my $statement_opt = $opt{option} \|\| {};
	79	+ my $rows = $self->select(%opt, %{$statement_opt->{select} \|\| {}})->all;
	80	+ if (@$rows == 0) {
	81	+ return $self->insert($param, %opt, %{$statement_opt->{insert} \|\| {}});
	82	+ }
	83	+ elsif (@$rows == 1) {
	84	+ return $self->update($param, %opt, %{$statement_opt->{update} \|\| {}});
	85	+ }
	86	+ else { croak "selected row must be one " . _subname }
89	87	}
90	88
91	89	sub execute {
92		- my $self = shift;
93		-
94		- if ($ENV{DBIX_CUSTOM_DISABLE_MODEL_EXECUTE}) {
95		- $self->dbi->execute(@_);
96		- }
97		- else {
98		- warn "DBIx::Custom::Model execute method is DEPRECATED! " .
99		- "use DBIx::Custom execute method. " .
100		- "If you want to call DBIx::Custom execute method directory from model, " .
101		- "set \$ENV{DBIX_CUSTOM_DISABLE_MODEL_EXECUTE} to 1 " .
102		- "until DBIx::Custom::Model execute method is removed in the future." ;
103		- return $self->dbi->execute(
104		- shift,
105		- shift,
106		- table => $self->table,
107		- bind_type => $self->bind_type,
108		- primary_key => $self->primary_key,
109		- type => $self->type,
110		- @_
111		- );
112		- }
	90	+ my $self = shift;
	91	+
	92	+ if ($ENV{DBIX_CUSTOM_DISABLE_MODEL_EXECUTE}) {
	93	+ $self->dbi->execute(@_);
	94	+ }
	95	+ else {
	96	+ warn "DBIx::Custom::Model execute method is DEPRECATED! " .
	97	+ "use DBIx::Custom execute method. " .
	98	+ "If you want to call DBIx::Custom execute method directory from model, " .
	99	+ "set \$ENV{DBIX_CUSTOM_DISABLE_MODEL_EXECUTE} to 1 " .
	100	+ "until DBIx::Custom::Model execute method is removed in the future." ;
	101	+ return $self->dbi->execute(
	102	+ shift,
	103	+ shift,
	104	+ table => $self->table,
	105	+ bind_type => $self->bind_type,
	106	+ primary_key => $self->primary_key,
	107	+ type => $self->type,
	108	+ @_
	109	+ );
	110	+ }
113	111	}
114	112
115	113	sub DESTROY { }
116	114
117	115	sub helper {
118		- my $self = shift;
119		-
120		- # Merge
121		- my $methods = ref $_[0] eq 'HASH' ? $_[0] : {@_};
122		- $self->{_methods} = {%{$self->{_methods} \|\| {}}, %$methods};
123		-
124		- return $self;
	116	+ my $self = shift;
	117	+
	118	+ # Merge
	119	+ my $methods = ref $_[0] eq 'HASH' ? $_[0] : {@_};
	120	+ $self->{_methods} = {%{$self->{_methods} \|\| {}}, %$methods};
	121	+
	122	+ return $self;
125	123	}
126	124
127	125	sub mycolumn {
128		- my $self = shift;
129		- my $table = shift unless ref $_[0];
130		- my $columns = shift;
131		-
132		- $table \|\|= $self->table \|\| '';
133		- $columns \|\|= $self->columns;
134		-
135		- return $self->dbi->mycolumn($table, $columns);
	126	+ my $self = shift;
	127	+ my $table = shift unless ref $_[0];
	128	+ my $columns = shift;
	129	+
	130	+ $table \|\|= $self->table \|\| '';
	131	+ $columns \|\|= $self->columns;
	132	+
	133	+ return $self->dbi->mycolumn($table, $columns);
136	134	}
137	135
138	136	sub new {
139		- my $self = shift->SUPER::new(@_);
140		-
141		- # Check attribute names
142		- my @attrs = keys %$self;
143		- for my $attr (@attrs) {
144		- croak qq{"$attr" is invalid attribute name } . _subname
145		- unless $self->can($attr);
146		- }
147		-
148		- # Cache
149		- for my $attr (qw/dbi table created_at updated_at bind_type join primary_key/) {
150		- $self->$attr;
151		- $self->{$attr} = undef unless exists $self->{$attr};
152		- }
153		- $self->columns;
154		-
155		- return $self;
	137	+ my $self = shift->SUPER::new(@_);
	138	+
	139	+ # Check attribute names
	140	+ my @attrs = keys %$self;
	141	+ for my $attr (@attrs) {
	142	+ croak qq{"$attr" is invalid attribute name } . _subname
	143	+ unless $self->can($attr);
	144	+ }
	145	+
	146	+ # Cache
	147	+ for my $attr (qw/dbi table created_at updated_at bind_type join primary_key/) {
	148	+ $self->$attr;
	149	+ $self->{$attr} = undef unless exists $self->{$attr};
	150	+ }
	151	+ $self->columns;
	152	+
	153	+ return $self;
156	154	}
157	155
158	156	# DEPRECATED!
...	...	@@ -160,11 +158,10 @@ has 'filter';
160	158	has 'name';
161	159	has 'type';
162	160
163		-
164	161	# DEPRECATED!
165	162	sub method {
166		- warn "method method is DEPRECATED! use helper instead";
167		- return shift->helper(@_);
	163	+ warn "method method is DEPRECATED! use helper instead";
	164	+ return shift->helper(@_);
168	165	}
169	166
170	167	1;
...	...	@@ -183,55 +180,55 @@ my $model = DBIx::Custom::Model->new(table => 'books');
183	180
184	181	=head2 C<dbi>
185	182
186		- my $dbi = $model->dbi;
187		- $model = $model->dbi($dbi);
	183	+ my $dbi = $model->dbi;
	184	+ $model = $model->dbi($dbi);
188	185
189	186	L<DBIx::Custom> object.
190	187
191	188	=head2 C<created_at EXPERIMENTAL>
192	189
193		- my $created_at = $model->created_at;
194		- $model = $model->created_at('created_datatime');
	190	+ my $created_at = $model->created_at;
	191	+ $model = $model->created_at('created_datatime');
195	192
196	193	Create timestamp column, this is passed to C<insert> or C<update> method.
197	194
198	195	=head2 C<join>
199	196
200		- my $join = $model->join;
201		- $model = $model->join(
202		- ['left outer join company on book.company_id = company.id']
203		- );
204		-
	197	+ my $join = $model->join;
	198	+ $model = $model->join(
	199	+ ['left outer join company on book.company_id = company.id']
	200	+ );
	201	+
205	202	Join clause, this value is passed to C<select> method.
206	203
207	204	=head2 C<primary_key>
208	205
209		- my $primary_key = $model->primary_key;
210		- $model = $model->primary_key(['id', 'number']);
	206	+ my $primary_key = $model->primary_key;
	207	+ $model = $model->primary_key(['id', 'number']);
211	208
212	209	Primary key,this is passed to C<insert>, C<update>,
213	210	C<delete>, and C<select> method.
214	211
215	212	=head2 C<table>
216	213
217		- my $model = $model->table;
218		- $model = $model->table('book');
	214	+ my $model = $model->table;
	215	+ $model = $model->table('book');
219	216
220	217	Table name, this is passed to C<select> method.
221	218
222	219	=head2 C<bind_type>
223	220
224		- my $type = $model->bind_type;
225		- $model = $model->bind_type(['image' => DBI::SQL_BLOB]);
226		-
	221	+ my $type = $model->bind_type;
	222	+ $model = $model->bind_type(['image' => DBI::SQL_BLOB]);
	223	+
227	224	Database data type, this is used as type optioon of C<insert>,
228	225	C<update>, C<update_all>, C<delete>, C<delete_all>,
229	226	and C<select> method
230	227
231	228	=head2 C<updated_at EXPERIMENTAL>
232	229
233		- my $updated_at = $model->updated_at;
234		- $model = $model->updated_at('updated_datatime');
	230	+ my $updated_at = $model->updated_at;
	231	+ $model = $model->updated_at('updated_datatime');
235	232
236	233	Updated timestamp column, this is passed to C<update> method.
237	234
...	...	@@ -243,7 +240,7 @@ and implements the following new ones.
243	240
244	241	=head2 C<count>
245	242
246		- my $count = $model->count;
	243	+ my $count = $model->count;
247	244
248	245	Get rows count.
249	246
...	...	@@ -251,89 +248,90 @@ Options is same as C<select> method's ones.
251	248
252	249	=head2 C<delete>
253	250
254		- $model->delete(...);
255		-
	251	+ $model->delete(...);
	252	+
256	253	Same as C<delete> of L<DBIx::Custom> except that
257	254	you don't have to specify options if you set attribute in model.
258	255
259	256	=head2 C<delete_all>
260	257
261		- $model->delete_all(...);
262		-
	258	+ $model->delete_all(...);
	259	+
263	260	Same as C<delete_all> of L<DBIx::Custom> except that
264	261	you don't have to specify options if you set attribute in model.
265	262
266	263	=head2 C<insert>
267	264
268		- $model->insert(...);
269		-
	265	+ $model->insert(...);
	266	+
270	267	Same as C<insert> of L<DBIx::Custom> except that
271	268	you don't have to specify options if you set attribute in model.
272	269
273	270	=head2 C<helper>
274	271
275		- $model->helper(
276		- update_or_insert => sub {
277		- my $self = shift;
278		-
279		- # ...
280		- },
281		- find_or_create => sub {
282		- my $self = shift;
283		-
284		- # ...
285		- );
	272	+ $model->helper(
	273	+ update_or_insert => sub {
	274	+ my $self = shift;
	275	+
	276	+ # ...
	277	+ },
	278	+ find_or_create => sub {
	279	+ my $self = shift;
	280	+
	281	+ # ...
	282	+ }
	283	+ );
286	284
287	285	Register helper. These helper is called directly from L<DBIx::Custom::Model> object.
288	286
289		- $model->update_or_insert;
290		- $model->find_or_create;
	287	+ $model->update_or_insert;
	288	+ $model->find_or_create;
291	289
292	290	=head2 C<mycolumn>
293	291
294		- my $column = $self->mycolumn;
295		- my $column = $self->mycolumn(book => ['author', 'title']);
296		- my $column = $self->mycolumn(['author', 'title']);
	292	+ my $column = $self->mycolumn;
	293	+ my $column = $self->mycolumn(book => ['author', 'title']);
	294	+ my $column = $self->mycolumn(['author', 'title']);
297	295
298	296	Create column clause for myself. The follwoing column clause is created.
299	297
300		- book.author as author,
301		- book.title as title
	298	+ book.author as author,
	299	+ book.title as title
302	300
303	301	If table name is ommited, C<table> attribute of the model is used.
304	302	If column names is omitted, C<columns> attribute of the model is used.
305	303
306	304	=head2 C<new>
307	305
308		- my $model = DBIx::Custom::Model->new;
	306	+ my $model = DBIx::Custom::Model->new;
309	307
310	308	Create a L<DBIx::Custom::Model> object.
311	309
312	310	=head2 C<select>
313	311
314		- $model->select(...);
315		-
	312	+ $model->select(...);
	313	+
316	314	Same as C<select> of L<DBIx::Custom> except that
317	315	you don't have to specify options if you set attribute in model.
318	316
319	317	=head2 C<update>
320	318
321		- $model->update(...);
322		-
	319	+ $model->update(...);
	320	+
323	321	Same as C<update> of L<DBIx::Custom> except that
324	322	you don't have to specify options if you set attribute in model.
325	323
326	324	=head2 C<update_all>
327	325
328		- $model->update_all(param => \%param);
329		-
	326	+ $model->update_all(param => \%param);
	327	+
330	328	Same as C<update_all> of L<DBIx::Custom> except that
331	329	you don't have to specify options if you set attribute in model.
332	330
333	331	=head2 C<update_or_insert>
334	332
335		- $model->update_or_insert(...);
336		-
	333	+ $model->update_or_insert(...);
	334	+
337	335	Same as C<update> of L<DBIx::Custom> except that
338	336	you don't have to specify options if you set attribute in model.
339	337

...	...	@@ -13,13 +13,13 @@ DBIx::Custom::NotExists
13	13
14	14	=head1 SYNOPSYS
15	15
16		- $not_exists = DBIx::Custom::NotExists->singleton;
	16	+ $not_exists = DBIx::Custom::NotExists->singleton;
17	17
18	18	=head1 METHODS
19	19
20	20	=head2 C<singleton>
21	21
22		- $not_exists = DBIx::Custom::NotExists->singleton;
	22	+ $not_exists = DBIx::Custom::NotExists->singleton;
23	23
24	24	L<DBIx::Custom::NotExists> singleton object.
25	25

...	...	@@ -6,43 +6,43 @@ use overload
6	6	fallback => 1;
7	7
8	8	has 'dbi',
9		- orders => sub { [] };
	9	+ orders => sub { [] };
10	10
11	11	sub prepend {
12		- my $self = shift;
13		-
14		- for my $order (reverse @_) {
15		- if (ref $order eq 'ARRAY') {
16		- warn "prepend method receiving array reference is DEPRECATED! " .
17		- "use q method to quote column name.";
18		- my $column = shift @$order;
19		- $column = $self->dbi->q($column) if defined $column;
20		- my $derection = shift @$order;
21		- $order = $column;
22		- $order .= " $derection" if $derection;
23		- }
24		- unshift @{$self->orders}, $order;
	12	+ my $self = shift;
	13	+
	14	+ for my $order (reverse @_) {
	15	+ if (ref $order eq 'ARRAY') {
	16	+ warn "prepend method receiving array reference is DEPRECATED! " .
	17	+ "use q method to quote column name.";
	18	+ my $column = shift @$order;
	19	+ $column = $self->dbi->q($column) if defined $column;
	20	+ my $derection = shift @$order;
	21	+ $order = $column;
	22	+ $order .= " $derection" if $derection;
25	23	}
26		-
27		- return $self;
	24	+ unshift @{$self->orders}, $order;
	25	+ }
	26	+
	27	+ return $self;
28	28	}
29	29
30	30	sub to_string {
31		- my $self = shift;
32		-
33		- my $exists = {};
34		- my @orders;
35		- for my $order (@{$self->orders}) {
36		- next unless defined $order;
37		- $order =~ s/^\s+//;
38		- $order =~ s/\s+$//;
39		- my ($column, $direction) = split /\s+/, $order;
40		- push @orders, $order unless $exists->{$column};
41		- $exists->{$column} = 1;
42		- }
43		-
44		- return '' unless @orders;
45		- return 'order by ' . join(', ', @orders);
	31	+ my $self = shift;
	32	+
	33	+ my $exists = {};
	34	+ my @orders;
	35	+ for my $order (@{$self->orders}) {
	36	+ next unless defined $order;
	37	+ $order =~ s/^\s+//;
	38	+ $order =~ s/\s+$//;
	39	+ my ($column, $direction) = split /\s+/, $order;
	40	+ push @orders, $order unless $exists->{$column};
	41	+ $exists->{$column} = 1;
	42	+ }
	43	+
	44	+ return '' unless @orders;
	45	+ return 'order by ' . join(', ', @orders);
46	46	}
47	47
48	48	1;
...	...	@@ -53,24 +53,24 @@ DBIx::Custom::Order - Order by
53	53
54	54	=head1 SYNOPSIS
55	55
56		- # Result
57		- my $order = DBIx::Custom::Order->new;
58		- $order->prepend('title', 'author desc');
59		- my $order_by = "$order";
60		-
	56	+ # Result
	57	+ my $order = DBIx::Custom::Order->new;
	58	+ $order->prepend('title', 'author desc');
	59	+ my $order_by = "$order";
	60	+
61	61	=head1 ATTRIBUTES
62	62
63	63	=head2 C<dbi>
64	64
65		- my $dbi = $order->dbi;
66		- $order = $order->dbi($dbi);
	65	+ my $dbi = $order->dbi;
	66	+ $order = $order->dbi($dbi);
67	67
68	68	L<DBIx::Custom> object.
69	69
70	70	=head2 C<orders>
71	71
72		- my $orders = $result->orders;
73		- $result = $result->orders(\%orders);
	72	+ my $orders = $result->orders;
	73	+ $result = $result->orders(\%orders);
74	74
75	75	Parts of order by clause
76	76
...	...	@@ -81,18 +81,18 @@ and implements the following new ones.
81	81
82	82	=head2 C<prepend>
83	83
84		- $order->prepend('title', 'author desc');
	84	+ $order->prepend('title', 'author desc');
85	85
86	86	Prepend order parts to C<orders>.
87	87
88	88	=head2 C<to_string>
89	89
90		- my $order_by = $order->to_string;
	90	+ my $order_by = $order->to_string;
91	91
92	92	Create order by clause. If column name is duplicated, First one is used.
93	93	C<to_string> override stringification. so you can write the follwoing way.
94	94
95		- my $order_by = "$order";
	95	+ my $order_by = "$order";
96	96
97	97	=cut
98	98

...	...	@@ -5,72 +5,68 @@ use Carp 'croak';
5	5	use DBIx::Custom::Util '_subname';
6	6
7	7	has [qw/sth statement/],
8		- sql => '',
9		- columns => sub { [] };
	8	+ sql => '',
	9	+ columns => sub { [] };
10	10
11	11	# DEPRECATED!
12	12	has 'default_filter';
13	13	sub filters {
14		- warn "DBIx::Custom::Query filters attribute method is DEPRECATED!";
15		- my $self = shift;
16		- if (@_) {
17		- $self->{filters} = $_[0];
18		- return $self;
19		- }
20		- return $self->{filters};
	14	+ warn "DBIx::Custom::Query filters attribute method is DEPRECATED!";
	15	+ my $self = shift;
	16	+ if (@_) {
	17	+ $self->{filters} = $_[0];
	18	+ return $self;
	19	+ }
	20	+ return $self->{filters};
21	21	}
22	22
23	23	# DEPRECATED!
24	24	sub tables {
25		- warn "DBIx::Custom::Query tables attribute method is DEPRECATED!";
26		- my $self = shift;
27		- if (@_) {
28		- $self->{tables} = $_[0];
29		- return $self;
30		- }
31		- return $self->{tables} \|\|= [];
	25	+ warn "DBIx::Custom::Query tables attribute method is DEPRECATED!";
	26	+ my $self = shift;
	27	+ if (@_) {
	28	+ $self->{tables} = $_[0];
	29	+ return $self;
	30	+ }
	31	+ return $self->{tables} \|\|= [];
32	32	}
33	33
34	34	#DEPRECATED!
35	35	sub filter {
36		- Carp::carp "DBIx::Custom::Query filter method is DEPRECATED!";
37		- my $self = shift;
38		- if (@_) {
39		- my $filter = {};
40		- if (ref $_[0] eq 'HASH') {
41		- $filter = $_[0];
42		- }
43		- else {
44		- my $ef = @_ > 1 ? [@_] : $_[0];
45		- for (my $i = 0; $i < @$ef; $i += 2) {
46		- my $column = $ef->[$i];
47		- my $f = $ef->[$i + 1];
48		- if (ref $column eq 'ARRAY') {
49		- for my $c (@$column) {
50		- $filter->{$c} = $f;
51		- }
52		- }
53		- else {
54		- $filter->{$column} = $f;
55		- }
56		- }
57		- }
58		- for my $column (keys %$filter) {
59		- my $fname = $filter->{$column};
60		- if (exists $filter->{$column}
61		- && defined $fname
62		- && ref $fname ne 'CODE')
63		- {
64		- my $filters = $self->{filters} \|\| {};
65		- croak qq{Filter "$fname" is not registered" } . _subname
66		- unless exists $filters->{$fname};
67		- $filter->{$column} = $filters->{$fname};
68		- }
	36	+ Carp::carp "DBIx::Custom::Query filter method is DEPRECATED!";
	37	+ my $self = shift;
	38	+ if (@_) {
	39	+ my $filter = {};
	40	+ if (ref $_[0] eq 'HASH') {
	41	+ $filter = $_[0];
	42	+ }
	43	+ else {
	44	+ my $ef = @_ > 1 ? [@_] : $_[0];
	45	+ for (my $i = 0; $i < @$ef; $i += 2) {
	46	+ my $column = $ef->[$i];
	47	+ my $f = $ef->[$i + 1];
	48	+ if (ref $column eq 'ARRAY') {
	49	+ for my $c (@$column) { $filter->{$c} = $f }
69	50	}
70		- $self->{filter} = {%{$self->{filter} \|\| {}}, %$filter};
71		- return $self;
	51	+ else { $filter->{$column} = $f }
	52	+ }
	53	+ }
	54	+ for my $column (keys %$filter) {
	55	+ my $fname = $filter->{$column};
	56	+ if (exists $filter->{$column}
	57	+ && defined $fname
	58	+ && ref $fname ne 'CODE')
	59	+ {
	60	+ my $filters = $self->{filters} \|\| {};
	61	+ croak qq{Filter "$fname" is not registered" } . _subname
	62	+ unless exists $filters->{$fname};
	63	+ $filter->{$column} = $filters->{$fname};
	64	+ }
72	65	}
73		- return $self->{filter} \|\|= {};
	66	+ $self->{filter} = {%{$self->{filter} \|\| {}}, %$filter};
	67	+ return $self;
	68	+ }
	69	+ return $self->{filter} \|\|= {};
74	70	}
75	71
76	72	1;

...	...	@@ -13,51 +13,51 @@ push @DBIx::Custom::Where::CARP_NOT, __PACKAGE__;
13	13
14	14	# DEPRECATED!
15	15	sub build_query {
16		- my ($self, $sql) = @_;
	16	+ my ($self, $sql) = @_;
17	17
18		- my $query = $self->_parse_tag($sql);
19		- my $tag_count = delete $query->{tag_count};
20		- warn qq/Tag system such as {? name} is DEPRECATED! / .
21		- qq/use parameter system such as :name instead/
22		- if $tag_count;
23		- my $query2 = $self->_parse_parameter($query->sql);
24		- $query->sql($query2->sql);
25		- for (my $i =0; $i < @{$query->columns}; $i++) {
26		- my $column = $query->columns->[$i];
27		- if ($column eq 'RESERVED_PARAMETER') {
28		- my $column2 = shift @{$query2->columns};
29		- croak ":name syntax is wrong"
30		- unless defined $column2;
31		- $query->columns->[$i] = $column2;
32		- }
	18	+ my $query = $self->_parse_tag($sql);
	19	+ my $tag_count = delete $query->{tag_count};
	20	+ warn qq/Tag system such as {? name} is DEPRECATED! / .
	21	+ qq/use parameter system such as :name instead/
	22	+ if $tag_count;
	23	+ my $query2 = $self->_parse_parameter($query->sql);
	24	+ $query->sql($query2->sql);
	25	+ for (my $i =0; $i < @{$query->columns}; $i++) {
	26	+ my $column = $query->columns->[$i];
	27	+ if ($column eq 'RESERVED_PARAMETER') {
	28	+ my $column2 = shift @{$query2->columns};
	29	+ croak ":name syntax is wrong"
	30	+ unless defined $column2;
	31	+ $query->columns->[$i] = $column2;
33	32	}
34		- return $query;
	33	+ }
	34	+ return $query;
35	35	}
36	36
37	37	# DEPRECATED!
38	38	sub _parse_parameter {
39		- my ($self, $source) = @_;
40		-
41		- # Get and replace parameters
42		- my $sql = $source \|\| '';
43		- my $columns = [];
44		- my $c = $self->dbi->safety_character;
45		- # Parameter regex
46		- $sql =~ s/([^:]):(\d+):([^:])/$1\\:$2\\:$3/g;
47		- my $re = qr/(^\|.?[^\\]):([$c\.]+)(?:\{(.?)\})?(.*)/s;
48		- while ($sql =~ /$re/g) {
49		- push @$columns, $2;
50		- $sql = defined $3 ? "$1$2 $3 ?$4" : "$1?$4";
51		- }
52		- $sql =~ s/\\:/:/g;
	39	+ my ($self, $source) = @_;
	40	+
	41	+ # Get and replace parameters
	42	+ my $sql = $source \|\| '';
	43	+ my $columns = [];
	44	+ my $c = $self->dbi->safety_character;
	45	+ # Parameter regex
	46	+ $sql =~ s/([^:]):(\d+):([^:])/$1\\:$2\\:$3/g;
	47	+ my $re = qr/(^\|.?[^\\]):([$c\.]+)(?:\{(.?)\})?(.*)/s;
	48	+ while ($sql =~ /$re/g) {
	49	+ push @$columns, $2;
	50	+ $sql = defined $3 ? "$1$2 $3 ?$4" : "$1?$4";
	51	+ }
	52	+ $sql =~ s/\\:/:/g;
53	53
54		- # Create query
55		- my $query = DBIx::Custom::Query->new(
56		- sql => $sql,
57		- columns => $columns
58		- );
59		-
60		- return $query;
	54	+ # Create query
	55	+ my $query = DBIx::Custom::Query->new(
	56	+ sql => $sql,
	57	+ columns => $columns
	58	+ );
	59	+
	60	+ return $query;
61	61	}
62	62
63	63	# DEPRECATED
...	...	@@ -68,190 +68,190 @@ has tags => sub { {} };
68	68
69	69	# DEPRECATED!
70	70	sub register_tag {
71		- my $self = shift;
72		-
73		- warn "register_tag is DEPRECATED!";
74		-
75		- # Merge tag
76		- my $tags = ref $_[0] eq 'HASH' ? $_[0] : {@_};
77		- $self->tags({%{$self->tags}, %$tags});
78		-
79		- return $self;
	71	+ my $self = shift;
	72	+
	73	+ warn "register_tag is DEPRECATED!";
	74	+
	75	+ # Merge tag
	76	+ my $tags = ref $_[0] eq 'HASH' ? $_[0] : {@_};
	77	+ $self->tags({%{$self->tags}, %$tags});
	78	+
	79	+ return $self;
80	80	}
81	81
82	82	# DEPRECATED!
83	83	sub _parse_tag {
84		- my ($self, $source) = @_;
85		- # Source
86		- $source \|\|= '';
87		- # Tree
88		- my @tree;
89		- # Value
90		- my $value = '';
91		- # State
92		- my $state = 'text';
93		- # Before charactor
94		- my $before = '';
95		- # Position
96		- my $pos = 0;
97		- # Parse
98		- my $original = $source;
99		- my $tag_count = 0;
100		- while (defined(my $c = substr($source, $pos, 1))) {
101		- # Last
102		- last unless length $c;
103		- # Parameter
104		- if ($c eq ':' && (substr($source, $pos + 1, 1) \|\| '') =~ /\w/) {
105		- push @tree, {type => 'param'};;
	84	+ my ($self, $source) = @_;
	85	+ # Source
	86	+ $source \|\|= '';
	87	+ # Tree
	88	+ my @tree;
	89	+ # Value
	90	+ my $value = '';
	91	+ # State
	92	+ my $state = 'text';
	93	+ # Before charactor
	94	+ my $before = '';
	95	+ # Position
	96	+ my $pos = 0;
	97	+ # Parse
	98	+ my $original = $source;
	99	+ my $tag_count = 0;
	100	+ while (defined(my $c = substr($source, $pos, 1))) {
	101	+ # Last
	102	+ last unless length $c;
	103	+ # Parameter
	104	+ if ($c eq ':' && (substr($source, $pos + 1, 1) \|\| '') =~ /\w/) {
	105	+ push @tree, {type => 'param'};;
	106	+ }
	107	+ # State is text
	108	+ if ($state eq 'text') {
	109	+ # Tag start charactor
	110	+ if ($c eq '{') {
	111	+ # Escaped charactor
	112	+ if ($before eq "\\") {
	113	+ substr($value, -1, 1, '');
	114	+ $value .= $c;
	115	+ }
	116	+ # Tag start
	117	+ else {
	118	+ # Change state
	119	+ $state = 'tag';
	120	+ # Add text
	121	+ push @tree, {type => 'text', value => $value}
	122	+ if $value;
	123	+ # Clear
	124	+ $value = '';
106	125	}
107		- # State is text
108		- if ($state eq 'text') {
109		- # Tag start charactor
110		- if ($c eq '{') {
111		- # Escaped charactor
112		- if ($before eq "\\") {
113		- substr($value, -1, 1, '');
114		- $value .= $c;
115		- }
116		- # Tag start
117		- else {
118		- # Change state
119		- $state = 'tag';
120		- # Add text
121		- push @tree, {type => 'text', value => $value}
122		- if $value;
123		- # Clear
124		- $value = '';
125		- }
126		- }
127		- # Tag end charactor
128		- elsif ($c eq '}') {
129		- # Escaped charactor
130		- if ($before eq "\\") {
131		- substr($value, -1, 1, '');
132		- $value .= $c;
133		- }
134		- # Unexpected
135		- else {
136		- croak qq{Parsing error. unexpected "\}". }
137		- . qq{pos $pos of "$original" } . _subname
138		- }
139		- }
140		- # Normal charactor
141		- else { $value .= $c }
	126	+ }
	127	+ # Tag end charactor
	128	+ elsif ($c eq '}') {
	129	+ # Escaped charactor
	130	+ if ($before eq "\\") {
	131	+ substr($value, -1, 1, '');
	132	+ $value .= $c;
142	133	}
143		- # State is tags
	134	+ # Unexpected
144	135	else {
145		- # Tag start charactor
146		- if ($c eq '{') {
147		- # Escaped charactor
148		- if ($before eq "\\") {
149		- substr($value, -1, 1, '');
150		- $value .= $c;
151		- }
152		- # Unexpected
153		- else {
154		- croak qq{Parsing error. unexpected "\{". }
155		- . qq{pos $pos of "$original" } . _subname
156		- }
157		- }
158		- # Tag end charactor
159		- elsif ($c eq '}') {
160		- # Escaped charactor
161		- if ($before eq "\\") {
162		- substr($value, -1, 1, '');
163		- $value .= $c;
164		- }
165		- # Tag end
166		- else {
167		- # Change state
168		- $state = 'text';
169		- # Add tag
170		- my ($tag_name, @tag_args) = split /\s+/, $value;
171		- push @tree, {type => 'tag', tag_name => $tag_name,
172		- tag_args => \@tag_args};
173		- # Clear
174		- $value = '';
175		- # Countup
176		- $tag_count++;
177		- }
178		- }
179		- # Normal charactor
180		- else { $value .= $c }
	136	+ croak qq{Parsing error. unexpected "\}". }
	137	+ . qq{pos $pos of "$original" } . _subname
181	138	}
182		- # Save before charactor
183		- $before = $c;
184		- # increment position
185		- $pos++;
	139	+ }
	140	+ # Normal charactor
	141	+ else { $value .= $c }
186	142	}
187		- # Tag not finished
188		- croak qq{Tag not finished. "$original" } . _subname
189		- if $state eq 'tag';
190		- # Not contains tag
191		- return DBIx::Custom::Query->new(sql => $source, tag_count => $tag_count)
192		- if $tag_count == 0;
193		- # Add rest text
194		- push @tree, {type => 'text', value => $value}
195		- if $value;
196		- # SQL
197		- my $sql = '';
198		- # All Columns
199		- my $all_columns = [];
200		- # Tables
201		- my $tables = [];
202		- # Build SQL
203		- for my $node (@tree) {
204		- # Text
205		- if ($node->{type} eq 'text') { $sql .= $node->{value} }
206		- # Parameter
207		- elsif ($node->{type} eq 'param') {
208		- push @$all_columns, 'RESERVED_PARAMETER';
	143	+ # State is tags
	144	+ else {
	145	+ # Tag start charactor
	146	+ if ($c eq '{') {
	147	+ # Escaped charactor
	148	+ if ($before eq "\\") {
	149	+ substr($value, -1, 1, '');
	150	+ $value .= $c;
209	151	}
210		- # Tag
	152	+ # Unexpected
211	153	else {
212		- # Tag name
213		- my $tag_name = $node->{tag_name};
214		- # Tag arguments
215		- my $tag_args = $node->{tag_args};
216		- # Table
217		- if ($tag_name eq 'table') {
218		- my $table = $tag_args->[0];
219		- push @$tables, $table;
220		- $sql .= $table;
221		- next;
222		- }
223		- # Get tag
224		- $self->dbi->{_tags} \|\|= {};
225		- my $tag = $self->tag_processors->{$tag_name}
226		- \|\| $self->dbi->{_tags}->{$tag_name};
227		- # Tag is not registered
228		- croak qq{Tag "$tag_name" is not registered } . _subname
229		- unless $tag;
230		- # Tag not sub reference
231		- croak qq{Tag "$tag_name" must be sub reference } . _subname
232		- unless ref $tag eq 'CODE';
233		- # Execute tag
234		- my $r = $tag->(@$tag_args);
235		- # Check tag return value
236		- croak qq{Tag "$tag_name" must return [STRING, ARRAY_REFERENCE] }
237		- . _subname
238		- unless ref $r eq 'ARRAY' && defined $r->[0] && ref $r->[1] eq 'ARRAY';
239		- # Part of SQL statement and colum names
240		- my ($part, $columns) = @$r;
241		- # Add columns
242		- push @$all_columns, @$columns;
243		- # Join part tag to SQL
244		- $sql .= $part;
	154	+ croak qq{Parsing error. unexpected "\{". }
	155	+ . qq{pos $pos of "$original" } . _subname
245	156	}
	157	+ }
	158	+ # Tag end charactor
	159	+ elsif ($c eq '}') {
	160	+ # Escaped charactor
	161	+ if ($before eq "\\") {
	162	+ substr($value, -1, 1, '');
	163	+ $value .= $c;
	164	+ }
	165	+ # Tag end
	166	+ else {
	167	+ # Change state
	168	+ $state = 'text';
	169	+ # Add tag
	170	+ my ($tag_name, @tag_args) = split /\s+/, $value;
	171	+ push @tree, {type => 'tag', tag_name => $tag_name,
	172	+ tag_args => \@tag_args};
	173	+ # Clear
	174	+ $value = '';
	175	+ # Countup
	176	+ $tag_count++;
	177	+ }
	178	+ }
	179	+ # Normal charactor
	180	+ else { $value .= $c }
	181	+ }
	182	+ # Save before charactor
	183	+ $before = $c;
	184	+ # increment position
	185	+ $pos++;
	186	+ }
	187	+ # Tag not finished
	188	+ croak qq{Tag not finished. "$original" } . _subname
	189	+ if $state eq 'tag';
	190	+ # Not contains tag
	191	+ return DBIx::Custom::Query->new(sql => $source, tag_count => $tag_count)
	192	+ if $tag_count == 0;
	193	+ # Add rest text
	194	+ push @tree, {type => 'text', value => $value}
	195	+ if $value;
	196	+ # SQL
	197	+ my $sql = '';
	198	+ # All Columns
	199	+ my $all_columns = [];
	200	+ # Tables
	201	+ my $tables = [];
	202	+ # Build SQL
	203	+ for my $node (@tree) {
	204	+ # Text
	205	+ if ($node->{type} eq 'text') { $sql .= $node->{value} }
	206	+ # Parameter
	207	+ elsif ($node->{type} eq 'param') {
	208	+ push @$all_columns, 'RESERVED_PARAMETER';
	209	+ }
	210	+ # Tag
	211	+ else {
	212	+ # Tag name
	213	+ my $tag_name = $node->{tag_name};
	214	+ # Tag arguments
	215	+ my $tag_args = $node->{tag_args};
	216	+ # Table
	217	+ if ($tag_name eq 'table') {
	218	+ my $table = $tag_args->[0];
	219	+ push @$tables, $table;
	220	+ $sql .= $table;
	221	+ next;
	222	+ }
	223	+ # Get tag
	224	+ $self->dbi->{_tags} \|\|= {};
	225	+ my $tag = $self->tag_processors->{$tag_name}
	226	+ \|\| $self->dbi->{_tags}->{$tag_name};
	227	+ # Tag is not registered
	228	+ croak qq{Tag "$tag_name" is not registered } . _subname
	229	+ unless $tag;
	230	+ # Tag not sub reference
	231	+ croak qq{Tag "$tag_name" must be sub reference } . _subname
	232	+ unless ref $tag eq 'CODE';
	233	+ # Execute tag
	234	+ my $r = $tag->(@$tag_args);
	235	+ # Check tag return value
	236	+ croak qq{Tag "$tag_name" must return [STRING, ARRAY_REFERENCE] }
	237	+ . _subname
	238	+ unless ref $r eq 'ARRAY' && defined $r->[0] && ref $r->[1] eq 'ARRAY';
	239	+ # Part of SQL statement and colum names
	240	+ my ($part, $columns) = @$r;
	241	+ # Add columns
	242	+ push @$all_columns, @$columns;
	243	+ # Join part tag to SQL
	244	+ $sql .= $part;
246	245	}
247		- # Query
248		- my $query = DBIx::Custom::Query->new(
249		- sql => $sql,
250		- columns => $all_columns,
251		- tables => $tables,
252		- tag_count => $tag_count
253		- );
254		- return $query;
	246	+ }
	247	+ # Query
	248	+ my $query = DBIx::Custom::Query->new(
	249	+ sql => $sql,
	250	+ columns => $all_columns,
	251	+ tables => $tables,
	252	+ tag_count => $tag_count
	253	+ );
	254	+ return $query;
255	255	}
256	256
257	257	# DEPRECATED!
...	...	@@ -259,12 +259,12 @@ has tag_processors => sub { {} };
259	259
260	260	# DEPRECATED!
261	261	sub register_tag_processor {
262		- my $self = shift;
263		- warn "register_tag_processor is DEPRECATED!";
264		- # Merge tag
265		- my $tag_processors = ref $_[0] eq 'HASH' ? $_[0] : {@_};
266		- $self->tag_processors({%{$self->tag_processors}, %{$tag_processors}});
267		- return $self;
	262	+ my $self = shift;
	263	+ warn "register_tag_processor is DEPRECATED!";
	264	+ # Merge tag
	265	+ my $tag_processors = ref $_[0] eq 'HASH' ? $_[0] : {@_};
	266	+ $self->tag_processors({%{$self->tag_processors}, %{$tag_processors}});
	267	+ return $self;
268	268	}
269	269
270	270	1;

...	...	@@ -14,42 +14,40 @@ sub greater_than_equal { _basic('>=', @_) }
14	14	sub greater_than { _basic('>', @_) }
15	15
16	16	sub in {
17		- my ($column, $count) = @_;
18		-
19		- # Check arguments
20		- croak qq{Column name and count of values must be specified in tag "{in }" }
21		- . _subname
22		- unless $column && $count && $count =~ /^\d+$/;
23		-
24		- # Part of statement
25		- my $s = "$column in (";
26		- for (my $i = 0; $i < $count; $i++) {
27		- $s .= '?, ';
28		- }
29		- $s =~ s/, $//;
30		- $s .= ')';
31		-
32		- # Columns
33		- my $columns = [];
34		- push @$columns, $column for (0 .. $count - 1);
35		-
36		- return [$s, $columns];
	17	+ my ($column, $count) = @_;
	18	+
	19	+ # Check arguments
	20	+ croak qq{Column name and count of values must be specified in tag "{in }" }
	21	+ . _subname
	22	+ unless $column && $count && $count =~ /^\d+$/;
	23	+
	24	+ # Part of statement
	25	+ my $s = "$column in (";
	26	+ for (my $i = 0; $i < $count; $i++) { $s .= '?, ' }
	27	+ $s =~ s/, $//;
	28	+ $s .= ')';
	29	+
	30	+ # Columns
	31	+ my $columns = [];
	32	+ push @$columns, $column for (0 .. $count - 1);
	33	+
	34	+ return [$s, $columns];
37	35	}
38	36
39	37	sub insert_param {
40		- my @columns = @_;
41		-
42		- # Insert parameters
43		- my $s = '(';
44		- $s .= "$_, " for @columns;
45		- $s =~ s/, $//;
46		- $s .= ') ';
47		- $s .= 'values (';
48		- $s .= "?, " for @columns;
49		- $s =~ s/, $//;
50		- $s .= ')';
51		-
52		- return [$s, \@columns];
	38	+ my @columns = @_;
	39	+
	40	+ # Insert parameters
	41	+ my $s = '(';
	42	+ $s .= "$_, " for @columns;
	43	+ $s =~ s/, $//;
	44	+ $s .= ') ';
	45	+ $s .= 'values (';
	46	+ $s .= "?, " for @columns;
	47	+ $s =~ s/, $//;
	48	+ $s .= ')';
	49	+
	50	+ return [$s, \@columns];
53	51	}
54	52
55	53	sub like { _basic('like', @_) }
...	...	@@ -58,34 +56,34 @@ sub lower_than { _basic('<', @_) }
58	56	sub not_equal { _basic('<>', @_) }
59	57
60	58	sub placeholder {
61		- my $column = shift;
62		-
63		- # Check arguments
64		- croak qq{Column name must be specified in tag "{? }" } . _subname
65		- unless $column;
66		-
67		- return ['?', [$column]];
	59	+ my $column = shift;
	60	+
	61	+ # Check arguments
	62	+ croak qq{Column name must be specified in tag "{? }" } . _subname
	63	+ unless $column;
	64	+
	65	+ return ['?', [$column]];
68	66	}
69	67
70	68	sub update_param {
71		- my @columns = @_;
72		-
73		- # Update parameters
74		- my $s = 'set ';
75		- $s .= "$_ = ?, " for @columns;
76		- $s =~ s/, $//;
77		-
78		- return [$s, \@columns];
	69	+ my @columns = @_;
	70	+
	71	+ # Update parameters
	72	+ my $s = 'set ';
	73	+ $s .= "$_ = ?, " for @columns;
	74	+ $s =~ s/, $//;
	75	+
	76	+ return [$s, \@columns];
79	77	}
80	78
81	79	sub _basic {
82		- my ($name, $column) = @_;
83		-
84		- # Check arguments
85		- croak qq{Column name must be specified in tag "{$name }" } . _subname
86		- unless $column;
87		-
88		- return ["$column $name ?", [$column]];
	80	+ my ($name, $column) = @_;
	81	+
	82	+ # Check arguments
	83	+ croak qq{Column name must be specified in tag "{$name }" } . _subname
	84	+ unless $column;
	85	+
	86	+ return ["$column $name ?", [$column]];
89	87	}
90	88
91	89	1;

...	...	@@ -8,27 +8,23 @@ use base 'Exporter';
8	8	our @EXPORT_OK = qw/_array_to_hash _subname/;
9	9
10	10	sub _array_to_hash {
11		- my $array = shift;
	11	+ my $array = shift;
	12	+
	13	+ return $array if ref $array eq 'HASH';
	14	+ return unless $array;
	15	+
	16	+ my $hash = {};
	17	+
	18	+ for (my $i = 0; $i < @$array; $i += 2) {
	19	+ my $key = $array->[$i];
	20	+ my $f = $array->[$i + 1];
12	21
13		- return $array if ref $array eq 'HASH';
14		- return unless $array;
15		-
16		- my $hash = {};
17		-
18		- for (my $i = 0; $i < @$array; $i += 2) {
19		- my $key = $array->[$i];
20		- my $f = $array->[$i + 1];
21		-
22		- if (ref $key eq 'ARRAY') {
23		- for my $k (@$key) {
24		- $hash->{$k} = $f;
25		- }
26		- }
27		- else {
28		- $hash->{$key} = $f;
29		- }
	22	+ if (ref $key eq 'ARRAY') {
	23	+ for my $k (@$key) { $hash->{$k} = $f }
30	24	}
31		- return $hash;
	25	+ else { $hash->{$key} = $f }
	26	+ }
	27	+ return $hash;
32	28	}
33	29
34	30	sub _subname { '(' . (caller 1)[3] . ')' }

...	...	@@ -10,135 +10,134 @@ use overload '""' => sub { shift->to_string }, fallback => 1;
10	10	push @DBIx::Custom::CARP_NOT, __PACKAGE__;
11	11
12	12	has [qw/dbi param/],
13		- clause => sub { [] };
	13	+ clause => sub { [] };
14	14
15	15	sub new {
16		- my $self = shift->SUPER::new(@_);
17		-
18		- # Check attribute names
19		- my @attrs = keys %$self;
20		- for my $attr (@attrs) {
21		- croak qq{"$attr" is invalid attribute name (} . _subname . ")"
22		- unless $self->can($attr);
23		- }
24		-
25		- return $self;
	16	+ my $self = shift->SUPER::new(@_);
	17	+
	18	+ # Check attribute names
	19	+ my @attrs = keys %$self;
	20	+ for my $attr (@attrs) {
	21	+ croak qq{"$attr" is invalid attribute name (} . _subname . ")"
	22	+ unless $self->can($attr);
	23	+ }
	24	+
	25	+ return $self;
26	26	}
27	27
28	28	sub to_string {
29		- my $self = shift;
30		-
31		- # Clause
32		- my $clause = $self->clause;
33		- $clause = ['and', $clause] unless ref $clause eq 'ARRAY';
34		- $clause->[0] = 'and' unless @$clause;
35		-
36		- # Parse
37		- my $where = [];
38		- my $count = {};
39		- $self->{_query_builder} = $self->dbi->query_builder;
40		- my $c = $self->dbi->safety_character;
41		- $self->{_re} = $c eq 'a-zA-Z0-9_' ?
42		- qr/[^\\]:([$c\.]+)/so : qr/[^\\]:([$c\.]+)/s;
43		-
44		- $self->{_quote} = $self->dbi->_quote;
45		- $self->{_tag_parse} = exists $ENV{DBIX_CUSTOM_TAG_PARSE}
46		- ? $ENV{DBIX_CUSTOM_TAG_PARSE} : $self->dbi->{tag_parse};
47		- $self->_parse($clause, $where, $count, 'and');
	29	+ my $self = shift;
	30	+
	31	+ # Clause
	32	+ my $clause = $self->clause;
	33	+ $clause = ['and', $clause] unless ref $clause eq 'ARRAY';
	34	+ $clause->[0] = 'and' unless @$clause;
	35	+
	36	+ # Parse
	37	+ my $where = [];
	38	+ my $count = {};
	39	+ $self->{_query_builder} = $self->dbi->query_builder;
	40	+ my $c = $self->dbi->safety_character;
	41	+ $self->{_re} = $c eq 'a-zA-Z0-9_' ?
	42	+ qr/[^\\]:([$c\.]+)/so : qr/[^\\]:([$c\.]+)/s;
	43	+
	44	+ $self->{_quote} = $self->dbi->_quote;
	45	+ $self->{_tag_parse} = exists $ENV{DBIX_CUSTOM_TAG_PARSE}
	46	+ ? $ENV{DBIX_CUSTOM_TAG_PARSE} : $self->dbi->{tag_parse};
	47	+ $self->_parse($clause, $where, $count, 'and');
48	48
49		- # Stringify
50		- unshift @$where, 'where' if @$where;
51		- return join(' ', @$where);
	49	+ # Stringify
	50	+ unshift @$where, 'where' if @$where;
	51	+ return join(' ', @$where);
52	52	}
53		-
	53	+
54	54	our %VALID_OPERATIONS = map { $_ => 1 } qw/and or/;
55	55	sub _parse {
56		- my ($self, $clause, $where, $count, $op, $info) = @_;
	56	+ my ($self, $clause, $where, $count, $op, $info) = @_;
	57	+
	58	+ # Array
	59	+ if (ref $clause eq 'ARRAY') {
	60	+ # Start
	61	+ push @$where, '(';
57	62
58		- # Array
59		- if (ref $clause eq 'ARRAY') {
60		-
61		- # Start
62		- push @$where, '(';
63		-
64		- # Operation
65		- my $op = $clause->[0] \|\| '';
66		- croak qq{First argument must be "and" or "or" in where clause } .
67		- qq{"$op" is passed} . _subname . ")"
68		- unless $VALID_OPERATIONS{$op};
69		-
70		- my $pushed_array;
71		- # Parse internal clause
72		- for (my $i = 1; $i < @$clause; $i++) {
73		- my $pushed = $self->_parse($clause->[$i], $where, $count, $op);
74		- push @$where, $op if $pushed;
75		- $pushed_array = 1 if $pushed;
76		- }
77		- pop @$where if $where->[-1] eq $op;
78		-
79		- # Undo
80		- if ($where->[-1] eq '(') {
81		- pop @$where;
82		- pop @$where if ($where->[-1] \|\| '') eq $op;
83		- }
84		- # End
85		- else { push @$where, ')' }
86		-
87		- return $pushed_array;
	63	+ # Operation
	64	+ my $op = $clause->[0] \|\| '';
	65	+ croak qq{First argument must be "and" or "or" in where clause } .
	66	+ qq{"$op" is passed} . _subname . ")"
	67	+ unless $VALID_OPERATIONS{$op};
	68	+
	69	+ my $pushed_array;
	70	+ # Parse internal clause
	71	+ for (my $i = 1; $i < @$clause; $i++) {
	72	+ my $pushed = $self->_parse($clause->[$i], $where, $count, $op);
	73	+ push @$where, $op if $pushed;
	74	+ $pushed_array = 1 if $pushed;
	75	+ }
	76	+ pop @$where if $where->[-1] eq $op;
	77	+
	78	+ # Undo
	79	+ if ($where->[-1] eq '(') {
	80	+ pop @$where;
	81	+ pop @$where if ($where->[-1] \|\| '') eq $op;
88	82	}
	83	+ # End
	84	+ else { push @$where, ')' }
89	85
90		- # String
	86	+ return $pushed_array;
	87	+ }
	88	+
	89	+ # String
	90	+ else {
	91	+ # Pushed
	92	+ my $pushed;
	93	+
	94	+ # Column
	95	+ my $re = $self->{_re};
	96	+
	97	+ my $column;
	98	+ my $sql = " " . $clause \|\| '';
	99	+ if ($self->{_tag_parse} && ($sql =~ /\s\{/)) {
	100	+ my $columns = $self->dbi->query_builder->build_query($sql)->{columns};
	101	+ $column = $columns->[0];
	102	+ }
91	103	else {
92		- # Pushed
93		- my $pushed;
94		-
95		- # Column
96		- my $re = $self->{_re};
97		-
98		- my $column;
99		- my $sql = " " . $clause \|\| '';
100		- if ($self->{_tag_parse} && ($sql =~ /\s\{/)) {
101		- my $columns = $self->dbi->query_builder->build_query($sql)->{columns};
102		- $column = $columns->[0];
103		- }
104		- else {
105		- $sql =~ s/([0-9]):/$1\\:/g;
106		- ($column) = $sql =~ /$re/;
107		- }
108		- unless (defined $column) {
109		- push @$where, $clause;
110		- $pushed = 1;
111		- return $pushed;
112		- }
113		-
114		- # Column count up
115		- my $count = ++$count->{$column};
	104	+ $sql =~ s/([0-9]):/$1\\:/g;
	105	+ ($column) = $sql =~ /$re/;
	106	+ }
	107	+ unless (defined $column) {
	108	+ push @$where, $clause;
	109	+ $pushed = 1;
	110	+ return $pushed;
	111	+ }
	112	+
	113	+ # Column count up
	114	+ my $count = ++$count->{$column};
	115	+
	116	+ # Push
	117	+ my $param = $self->{param};
	118	+ if (ref $param eq 'HASH') {
	119	+ if (exists $param->{$column}) {
	120	+ my $if = $self->{_if};
116	121
117		- # Push
118		- my $param = $self->{param};
119		- if (ref $param eq 'HASH') {
120		- if (exists $param->{$column}) {
121		- my $if = $self->{_if};
122		-
123		- if (ref $param->{$column} eq 'ARRAY') {
124		- $pushed = 1 if exists $param->{$column}->[$count - 1]
125		- && ref $param->{$column}->[$count - 1] ne 'DBIx::Custom::NotExists'
126		- }
127		- elsif ($count == 1) { $pushed = 1 }
128		- }
129		- push @$where, $clause if $pushed;
	122	+ if (ref $param->{$column} eq 'ARRAY') {
	123	+ $pushed = 1 if exists $param->{$column}->[$count - 1]
	124	+ && ref $param->{$column}->[$count - 1] ne 'DBIx::Custom::NotExists'
130	125	}
131		- elsif (!defined $param) {
132		- push @$where, $clause;
133		- $pushed = 1;
134		- }
135		- else {
136		- croak "Parameter must be hash reference or undfined value ("
137		- . _subname . ")"
138		- }
139		- return $pushed;
	126	+ elsif ($count == 1) { $pushed = 1 }
	127	+ }
	128	+ push @$where, $clause if $pushed;
	129	+ }
	130	+ elsif (!defined $param) {
	131	+ push @$where, $clause;
	132	+ $pushed = 1;
140	133	}
141		- return;
	134	+ else {
	135	+ croak "Parameter must be hash reference or undfined value ("
	136	+ . _subname . ")"
	137	+ }
	138	+ return $pushed;
	139	+ }
	140	+ return;
142	141	}
143	142	1;
144	143
...	...	@@ -147,103 +146,103 @@ sub _parse {
147	146	DBIx::Custom::Where - Where clause
148	147
149	148	=head1 SYNOPSYS
150		-
151		- # Create DBIx::Custom::Where object
152		- my $where = $dbi->where;
153		-
154		- # Set clause and parameter
155		- $where->clause(['and', ':title{like}', ':price{=}']);
156		-
157		- # Create where clause by to_string method
158		- my $where_clause = $where->to_string;
159		-
160		- # Create where clause by stringify
161		- my $where_clause = "$where";
162		-
163		- # Created where clause in the above way
164		- where :title{=} and :price{like}
165		-
166		- # Only price condition
167		- $where->clause(['and', ':title{like}', ':price{=}']);
168		- $where->param({price => 1900});
169		- my $where_clause = "$where";
170		-
171		- # Created where clause in the above way
172		- where :price{=}
173		-
174		- # Only title condition
175		- $where->clause(['and', ':title{like}', ':price{=}']);
176		- $where->param({title => 'Perl'});
177		- my $where_clause = "$where";
178		-
179		- # Created where clause in the above way
180		- where :title{like}
181		-
182		- # Nothing
183		- $where->clause(['and', ':title{like}', ':price{=}']);
184		- $where->param({});
185		- my $where_clause = "$where";
186		-
187		- # or condition
188		- $where->clause(['or', ':title{like}', ':price{=}']);
189		-
190		- # More than one parameter
191		- $where->clause(['and', ':price{>}', ':price{<}']);
192		- $where->param({price => [1000, 2000]});
193		-
194		- # Only first condition
195		- $where->clause(['and', ':price{>}', ':price{<}']);
196		- $where->param({price => [1000, $dbi->not_exists]});
197		-
198		- # Only second condition
199		- $where->clause(['and', ':price{>}', ':price{<}']);
200		- $where->param({price => [$dbi->not_exists, 2000]});
201		-
202		- # More complex condition
203		- $where->clause(
204		- [
205		- 'and',
206		- ':price{=}',
207		- ['or', ':title{=}', ':title{=}', ':title{=}']
208		- ]
209		- );
210		- my $where_clause = "$where";
211		-
212		- # Created where clause in the above way
213		- where :price{=} and (:title{=} or :title{=} or :title{=})
214		-
215		- # Using Full-qualified column name
216		- $where->clause(['and', ':book.title{like}', ':book.price{=}']);
	149	+
	150	+ # Create DBIx::Custom::Where object
	151	+ my $where = $dbi->where;
	152	+
	153	+ # Set clause and parameter
	154	+ $where->clause(['and', ':title{like}', ':price{=}']);
	155	+
	156	+ # Create where clause by to_string method
	157	+ my $where_clause = $where->to_string;
	158	+
	159	+ # Create where clause by stringify
	160	+ my $where_clause = "$where";
	161	+
	162	+ # Created where clause in the above way
	163	+ where :title{=} and :price{like}
	164	+
	165	+ # Only price condition
	166	+ $where->clause(['and', ':title{like}', ':price{=}']);
	167	+ $where->param({price => 1900});
	168	+ my $where_clause = "$where";
	169	+
	170	+ # Created where clause in the above way
	171	+ where :price{=}
	172	+
	173	+ # Only title condition
	174	+ $where->clause(['and', ':title{like}', ':price{=}']);
	175	+ $where->param({title => 'Perl'});
	176	+ my $where_clause = "$where";
	177	+
	178	+ # Created where clause in the above way
	179	+ where :title{like}
	180	+
	181	+ # Nothing
	182	+ $where->clause(['and', ':title{like}', ':price{=}']);
	183	+ $where->param({});
	184	+ my $where_clause = "$where";
	185	+
	186	+ # or condition
	187	+ $where->clause(['or', ':title{like}', ':price{=}']);
	188	+
	189	+ # More than one parameter
	190	+ $where->clause(['and', ':price{>}', ':price{<}']);
	191	+ $where->param({price => [1000, 2000]});
	192	+
	193	+ # Only first condition
	194	+ $where->clause(['and', ':price{>}', ':price{<}']);
	195	+ $where->param({price => [1000, $dbi->not_exists]});
	196	+
	197	+ # Only second condition
	198	+ $where->clause(['and', ':price{>}', ':price{<}']);
	199	+ $where->param({price => [$dbi->not_exists, 2000]});
	200	+
	201	+ # More complex condition
	202	+ $where->clause(
	203	+ [
	204	+ 'and',
	205	+ ':price{=}',
	206	+ ['or', ':title{=}', ':title{=}', ':title{=}']
	207	+ ]
	208	+ );
	209	+ my $where_clause = "$where";
	210	+
	211	+ # Created where clause in the above way
	212	+ where :price{=} and (:title{=} or :title{=} or :title{=})
	213	+
	214	+ # Using Full-qualified column name
	215	+ $where->clause(['and', ':book.title{like}', ':book.price{=}']);
217	216
218	217	=head1 ATTRIBUTES
219	218
220	219	=head2 C<clause>
221	220
222		- my $clause = $where->clause;
223		- $where = $where->clause(
224		- ['and',
225		- ':title{=}',
226		- ['or', ':date{<}', ':date{>}']
227		- ]
228		- );
	221	+ my $clause = $where->clause;
	222	+ $where = $where->clause(
	223	+ ['and',
	224	+ ':title{=}',
	225	+ ['or', ':date{<}', ':date{>}']
	226	+ ]
	227	+ );
229	228
230	229	Where clause. Above one is expanded to the following SQL by to_string
231	230	If all parameter names is exists.
232	231
233		- where title = :title and ( date < :date or date > :date )
	232	+ where title = :title and ( date < :date or date > :date )
234	233
235	234	=head2 C<param>
236	235
237		- my $param = $where->param;
238		- $where = $where->param({
239		- title => 'Perl',
240		- date => ['2010-11-11', '2011-03-05'],
241		- });
	236	+ my $param = $where->param;
	237	+ $where = $where->param({
	238	+ title => 'Perl',
	239	+ date => ['2010-11-11', '2011-03-05'],
	240	+ });
242	241
243	242	=head2 C<dbi>
244	243
245		- my $dbi = $where->dbi;
246		- $where = $where->dbi($dbi);
	244	+ my $dbi = $where->dbi;
	245	+ $where = $where->dbi($dbi);
247	246
248	247	L<DBIx::Custom> object.
249	248
...	...	@@ -254,12 +253,12 @@ and implements the following new ones.
254	253
255	254	=head2 C<to_string>
256	255
257		- $where->to_string;
	256	+ $where->to_string;
258	257
259	258	Convert where clause to string.
260	259
261	260	double quote is override to execute C<to_string> method.
262	261
263		- my $string_where = "$where";
	262	+ my $string_where = "$where";
264	263
265	264	=cut