简介

use DBIx::Custom;

# Connect
my $dbi = DBIx::Custom->connect(
  "dbi:mysql:database=dbname",
  'ken',
  '!LFKD%$&',
  {mysql_enable_utf8 => 1}
);

# Create model
$dbi->create_model('book');

# Insert 
$dbi->model('book')->insert({title => 'Perl', author => 'Ken'});

# Update 
$dbi->model('book')->update({title => 'Perl', author => 'Ken'}, where  => {id => 5});

# Delete
$dbi->model('book')->delete(where => {author => 'Ken'});

# Select
my $result = $dbi->model('book')->select(['title', 'author'], where  => {author => 'Ken'});

# Select, more complex
#   select book.title as book.title,
#     book.author as book.author,
#     comnapy.name as company.name
#   form book
#     left outer join company on book.company_id = company.id
#   where book.author = ?
#   order by id limit 0, 5
my $result = $dbi->model('book')->select(
  [
    {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 0, 5'
);

# Get all rows or only one row
my $rows = $result->all;
my $row = $result->one;

# Execute SQL with named place holder
my $result = $dbi->execute(
  "select id from book where author = :author and title like :title",
  {author => 'ken', title => '%Perl%'}
);    

DBIx::Custom是一个DBI的包装器，此模块具有以下功能：

1. 可以更容易的执行insert、update、deleted和select语句。
2. 可以非常灵活的创建where子句
3. 支持命名占位符
4. 支持连接管理，透明的数据库连接池管理。
5. 支持很多关系型数据库：MySQL、SQLite、PostgreSQL、Oracle、Microsoft SQL Server、Microsoft Access、DB2和其他。
6. 可以根据数据类型和列名进行过滤。
7. 非常灵活的支持order by 子句的创建。

属性

connector

my $connector = $dbi->connector;
$dbi = $dbi->connector($connector);

连接管理器对象，如果设置了一个连接管理器对象，你可以通过它的dbh方法获取一个数据库连接。所以连接管理器对象必须有一个dbh方法。

下面是一个使用DBIx::Connector作为DBIx::Custom的连接管理器对象的例子：

my $connector = DBIx::Connector->new(
  "dbi:mysql:database=$database",
  $user,
  $password,
  DBIx::Custom->new->default_option
);

my $dbi = DBIx::Custom->connect(connector => $connector);

如果在调用DBIx::Custom的connect方法时，其属性connector的值为1，则DBIx::Custom将默认使用DBIx::Connector创建一个连接管理器并为属性connector赋值。

my $dbi = DBIx::Custom->connect(
  dsn => $dsn, user => $user, password => $password, connector => 1);

my $connector = $dbi->connector; # DBIx::Connector

注：必须安装DBIx::Connector模块。

dsn

my $dsn = $dbi->dsn;
$dbi = $dbi->dsn("DBI:mysql:database=dbname");

数据源名称，在调用connect方法时使用。dsn支持很多种格式，具体内容可以查阅DBI模块的文档获取。

default_option

my $default_option = $dbi->default_option;
$dbi = $dbi->default_option($default_option);

使用DBI创建数据库连接时的默认参数，执行connect方法时使用，默认情况下为以下值：

{
  RaiseError => 1,
  PrintError => 0,
  AutoCommit => 1,
}

exclude_table

my $exclude_table = $dbi->exclude_table;
$dbi = $dbi->exclude_table(qr/pg_/);

使用正则表达式在以下方法（each_column、each_table、type_rule）执行时排除一些表。

filters

my $filters = $dbi->filters;
$dbi = $dbi->filters(\%filters);

过滤器，可以通过方法register_filter注册。

last_sql

my $last_sql = $dbi->last_sql;
$dbi = $dbi->last_sql($last_sql);

获取通过execute方法成功执行的最后一个SQL。

now

my $now = $dbi->now;
$dbi = $dbi->now($now);

返回当前时间的代码引用，默认为以下代码的引用：

sub {
  my ($sec, $min, $hour, $mday, $mon, $year) = localtime;
  $mon++;
  $year += 1900;
  return sprintf("%04d-%02d-%02d %02d:%02d:%02d");
}

通过会返回一个表示时间的字符串：2011-10-14 05:05:27。给insert方法的ctime、mtime选项以及update方法的mtime选项使用。

models

my $models = $dbi->models;
$dbi = $dbi->models(\%models);

数据模型，由include_model 和 create_model方法可以注册数据模型。

mytable_sysmbol

在“select”方法的column 选项中指定要查询自己列的符号，默认为“MY”。

$dbi->table('book')->select({__MY__ => '*'});

option

my $option = $dbi->option;
$dbi = $dbi->option($option);

使用DBI创建数据库连接时的可选参数，执行connect方法时使用，并且在这里设置的值会覆盖default_option中的值。

password

my $password = $dbi->password;
$dbi = $dbi->password('lkj&le`@s');

数据库连接的密码，在执行connect方法时使用。

quote

my quote = $dbi->quote;
$dbi = $dbi->quote('"');

在数据库查询中有一些具有特殊含义的词（如：表名，列名等），这个属性就是给这类词设置引用符号的。在mysql默认使用反引号"`"。如果是非mysql则此属性的值默认为双引号。

你可以为此属性设计一对符号。

$dbi->quote('[]');

result_class

my $result_class = $dbi->result_class;
$dbi = $dbi->result_class('DBIx::Custom::Result');

结果类，对查询结果进行包装的类。默认为：DBIx::Custom::Result。

safety_character

my $safety_character = $dbi->safety_character;
$dbi = $dbi->safety_character($character);

表名和列名中安全字符的正则表达式，默认为“a-zA-Z_”。无需像“[a-zA-Z_]”指定。

separator

my $separator = $dbi->separator;
$dbi = $dbi->separator('-');

连接表名和列名的分隔符。这会用在mycolumn和column方法中，在select方法的column选项中也会用到。默认值为.。

user

my $user = $dbi->user;
$dbi = $dbi->user('Ken');

数据库连接的用户名，在执行connect方法时使用。

user_column_info

my $user_column_info = $dbi->user_column_info;
$dbi = $dbi->user_column_info($user_column_info);

你可以把这个属性的值设置为如下格式的数据：

[
  {table => 'book', column => 'title', info => {...}},
  {table => 'author', column => 'name', info => {...}}
]

通常你可以使用get_column_info方法的返回值进行设置。

my $user_column_info = $dbi->get_column_info(exclude_table => qr/^system/);
$dbi->user_column_info($user_column_info);

如果 user_column_info被设置了，在执行each_column方法会使用user_column_info属性去查找column信息，这样做相对来说速度上有一点的优势。

user_table_info

my $user_table_info = $dbi->user_table_info;
$dbi = $dbi->user_table_info($user_table_info);

你可以把这个属性的值设置为如下格式的数据：

[
  {table => 'book', info => {...}},
  {table => 'author', info => {...}}
]

通常你可以使用get_table_info方法的返回值进行设置。

my $user_table_info = $dbi->get_table_info(exclude => qr/^system/);
$dbi->user_table_info($user_table_info);

如果 user_table_info被设置了，在执行each_teble方法会使用user_table_info属性去查找table信息，这样做相对来说速度上有一点的优势。

方法

DBIx::Custom模块了Object::Simple中的所有方法，并实现了以下方法。

available_datatype

print $dbi->available_datatype;

获取可用的数据类型。（暂时不知道用它能做啥）

available_typename

print $dbi->available_typename;

获取可用的类型名称。（暂时不知道用它能做啥）

assign_clause

my $assign_clause = $dbi->assign_clause({title => 'a', age => 2});

对sql语句中的变量进行数值绑定。用于在执行更新或插入操作时创建set子句。

"update book set " . $dbi->assign_clause({title => 'a', age => 2});

update book set  title = :title, age = :age 

column

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

用于创建 column 子句，上面的代码将生成如下所示的sql语句。

book.author as "book.author",
book.title as "book.title"

您可以通过separator属性更改分隔符。

# Separator is hyphen
$dbi->separator('-');

book.author as "book-author",
book.title as "book-title"

connect

# DBI compatible arguments
my $dbi = DBIx::Custom->connect(
  "dbi:mysql:database=dbname",
  'ken',
  '!LFKD%$&',
  {mysql_enable_utf8 => 1}
);

# pass DBIx::Custom attributes
my $dbi = DBIx::Custom->connect(
  dsn => "dbi:mysql:database=dbname",
  user => 'ken',
  password => '!LFKD%$&',
  option => {mysql_enable_utf8 => 1}
);

连接到数据库，并创建一个新的DBIx::Custom对象。DBIx::Custom是对DBI模块的封装，并且默认情况下在创建连接时参数option中的AutoCommit和RaiseError两个属性的值是true，而PrintError属性的值为假。（这在上面属性小节的default_option中已经介绍过了）

create_model

$dbi->create_model('book');
$dbi->create_model(
  'book',
  join => [
    'inner join company on book.comparny_id = company.id'
  ]
);
$dbi->create_model(
  table => 'book',
  join => [
    'inner join company on book.comparny_id = company.id'
  ],
);

创建一个DBIx::Custom::Model对象并初始化，对象中的列属性是自动设置的。您可以使用后面将要介绍的model方法使用已经创建的DBIx::Custom::Model对象。

$dbi->model('book')->select(...);

你可以使用与表名不同的标识符作为DBIx::Custom::Model对象的名称。

$dbi->create_model(name => 'book1', table => 'book');
$dbi->model('book1')->select(...);

dbh

my $dbh = $dbi->dbh;

获取DBI数据库连接的句柄，如果connector属性已经被设置，则会使用connector对象进行获取。

delete

$dbi->delete(table => 'book', where => {title => 'Perl'});

执行数据库的DELETE操作。

所有对execute方法可用的参数选项，对于delete函数都可用，并且含意完全相同。除此之外delete方法还以下参数选项。

prefix

prefix => 'some'

前缀，指明从哪些表中删除数据。当from子句中有多个表名时需要用到它。

delete some from book

table

table => 'book'

表名。对哪张表执行DELETE操作。

where

与select方法的where选项相同，指明本次DELETE操作的条件。对需要删除的记录进行过滤。

delete_all

$dbi->delete_all(table => $table);

删除一张表中的所有数据。它的实现代码如下：

sub delete_all { shift->delete(@_, allow_delete_all => 1) }

其实当我们调用delete函数时，如果没有传where和id参数并且没有指定allow_delete_all 为true的话，是会报错的。delete_all方法和delete方法的执行逻辑和所接收的参数完全一样，只是delete_all允许删除一张表中的所有数据。

each_column

$dbi->each_column(
  sub {
    my ($dbi, $table, $column, $column_info) = @_;
 
    my $type = $column_info->{TYPE_NAME};
 
    if ($type eq 'DATE') {
        # ...
    }
  }
);

迭代数据库中的所有列信息，参数是一个回调函数。回调函数需要接收四个参数：DBIx::Custom对象、table_name（表名）、column_name（列名）和column_info（列信息）。针对数据库中的每一个数据列会调用一次回调函数。

如果user_column_info属性已经设置，each_column方法会使用user_column_info属性中的信息，这种方式可以提高each_column方法的性能。

my $column_infos = $dbi->get_column_info(exclude_table => qr/^system_/);
$dbi->user_column_info($column_info);
$dbi->each_column(sub { ... });

each_table

$dbi->each_table(
  sub {
    my ($dbi, $table, $table_info) = @_;
 
    my $table_name = $table_info->{TABLE_NAME};
  }
);

迭代数据中所有表的信息，参数是一个回调函数。回调函数接收三个参数：DBIx::Custom对象、table_name（表名）和table_info（表信息）。针对数据库中的每个一个表调用一次回调函数。

如果user_table_info属性已经设置，each_table方法使用user_table_info属性中的信息，这种方式可以提高each_table方法的性能。

my $table_infos = $dbi->get_table_info(exclude => qr/^system_/);
$dbi->user_table_info($table_info);
$dbi->each_table(sub { ... });

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 = :book.title and author like :book.author",
  {'book.title' => 'Perl', 'book.author' => '%Ken%'}
);

执行SQL语句。SQL语句中可以包含“命名占位符”（:author和:title）。你也可以将表名加入到“命名占位符”中（:book.author和:book.title）。第二个参数是一个hashref，其中包含需要绑定到“命名占位符”中的数据。当执行select语句时返回值是DBIx::Custom::Result对象，当执行的是insert、update、delete语句时返回值是受影响的行数。

在不支持“命名占位符”的数据库系统（如Mysql）中，执行SQL语句前“命名占位符”会被通用占位符？替换。

# Original
select * from book where title = :title and author like :author

# Replaced
select * from where title = ? and author like ?;

您还可以通过 name{operator}语法指定具有指定“运算符”的“命名点位符”。

# Original
select * from book where :title{=} and :author{like}

# Replaced
select * from where title = ? and author like ?;

需要注意的是：时间格式（如12:13:15）中的冒号是一个例外，它不会被解析为指定的占位符。一般情况下你如果想使用冒号，则必须使用\\逃避。

select * from where title = "aa\\:bb";

execute方法可接收的参数：第一个参数必须为SQL语句；第二个参数（为占位符绑定的数据）是可选的；再往后是一个元素数为偶数的列表作为第三个参数（一系列键值对），叫OPTION。OPTION支持的属性会在接下来分小节介绍。

after_build_sql

这个属性的值需要是一个coderef类型的回调，它用于对生成的sql进行过滤。

after_build_sql => $code_ref

下面是一个例子

$dbi->select(
  table => 'book',
  column => 'distinct(name)',
  after_build_sql => sub {
    "select count(*) from ($_[0]) as t1"
  }
);

select count(*) from (select distinct(name) from book) as t1;

append

append => 'order by name'

在SQL语句之后追加一些语句。

bind_type

指定数据库绑定数据类型。

bind_type => {image => DBI::SQL_BLOB}
bind_type => [image => DBI::SQL_BLOB]
bind_type => [[qw/image audio/] => DBI::SQL_BLOB]

这用于通过数据库连接句柄dbh的bind_param方法对SQL语句进行绑定参数。

$sth->bind_param($pos, $value, DBI::SQL_BLOB);

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] }
]

过滤。你可以通过这个参数为column的值绑定一个过滤器。过滤器可以是一个subroutine也可以是一个通过register_filter方法注册的过滤器的名称。过滤器会在数据保存到数据库之前、且在执行类型过滤（type_rule）之前执行。

reuse

reuse => $hash_ref

如果设置了哈希引用变量，则重用查询对象。

my $queries = {};
$dbi->execute($sql, $param, reuse => $queries);

当您想要重复执行相同的查询操作时，这样做可以提高性能，因为通常创建查询对象速度会很慢。

table

table => 'author'

如果在列名中省略了表名，并且启用了into1和into2过滤器，则必须设置table选项。

$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');

table_alias

table_alias => {worker => 'user'} # {ALIAS => TABLE}

表别名。key是表别名，value是真实表名。在你设定表别名后，你可以在type_rule的into1和into2上使用表别名。

type_rule_of

type_rule_off => 1

关闭 into1和into2过滤规则。

type_rule1_of

type_rule1_off => 1

关闭 into1过滤规则。

type_rule2_of

type_rule2_off => 1

关闭 into2过滤规则。

prepare_attr EXPERIMENTAL

prepare_attr => {mysql_use_result => 1}

这个是由Statemend处理的属性，这是DBI的prepare方法第二个参数。

query EXPERIMENTAL

query => 1

如果你仅仅是为了获取SQL信息，而不是为了执行SQL语句。可以设置这个选项，这时execute方法会返回一个DBIx::Custom::Query对象。

my $query = $dbi->execute(
  "insert into book (id, name) values (:id, :name)",
  {id => 1, name => 'Perl'},
  query => 1
);

DBIx::Custom::Query对象具有以下信息

my $sql = $query->sql;
my $param = $query->param;
my $columns $query->columns;

您可以通过以下方式获取绑定值和类型。

# Build bind values and types
$query->build;

# Get bind values
my $bind_values = $query->bind_values;

# Get bind types
my $bind_value_types = $query->bind_value_types;

您可以通过DBI准备sql并执行SQL 。

my $sth = $dbi->dbh->prepare($sql);
$sth->execute($sql, @$bind_values);

如果你知道参数没有重复的列名，没有过滤器，你可以通过以下方式更快速的获得绑定值。

my $ bind_values = [map {$ param-> {$ _}} @columns]

get_column_info

my $column_infos = $dbi->get_column_info(exclude_table => qr/^system_/);

用于获取数据库中数据列的信息，参数exclude_table的值是一个正则表达式，用于排除与之相匹配的表。返回值结构如下：

[
  {table => 'book', column => 'title', info => {...}},
  {table => 'author', column => 'name' info => {...}}
]

get_table_info

my $table_infos = $dbi->get_table_info(exclude => qr/^system_/);

用于获取数据库中数据表的信息，参数exclude_table的值是一个正则表达式，用于排除与之相匹配的表。返回值结构如下：

[
  {table => 'book', info => {...}},
  {table => 'author', info => {...}}
]

insert

$dbi->insert({title => 'Perl', author => 'Ken'}, table  => 'book');

向一个数据表中插入数据，第一个参数是需要插入的数据，可以是一个hashref（只插入一条记录时），也可以是一个元素为hashref的arrayref（插入多条数据时）。返回值是受影响的行数。如果数据项的值为常量值，则需要使用标题引用作为参数。

{date => \"NOW()"}

注：在插入多条记录时，你不能使用id选项。

insert方法支持execute方法中的所有参数选项，同时你还可以使用以下参数选项。

bulk_insert

bulk_insert => 1

在“插入多条记录”时，如果数据库支持批量插入，则执行批量插入操作。会生成如下面这样的SQL：

insert into book (id, title) values (?, ?), (?, ?);

ctime

ctime => 'created_time'

表中记录“创建时间”的列。默认时间格式为“YYYY-mm-dd HH：MM：SS”，可以通过now属性进行修改。

prefix

prefix => 'or replace'

表名前面的前缀。

insert or replace into book

table

table => 'book'

表名。

mtime

该选项与update方法mtime选项相同。用于指定表中记录“更新时间”的列。默认时间格式为“YYYY-mm-dd HH：MM：SS”，可以通过now属性进行修改。

wrap

wrap => {price => sub { "max($_[0])" }}

占位符包装器。

 $dbi->insert({price => 100}, table => 'book',{price => sub { "$_[0] + 5" }});
 
 insert into book price values ( ? + 5 );

include_model

$dbi->include_model('MyModel');

导入指定名称空间的DBIx::Custom::Model对象，需要如下的包结构。

lib / MyModel.pm
    / MyModel / book.pm
              / company.pm

名称空间的模块必须是DBIx::Custom::Model的子类。请参阅DBIx::Custom::Model来了解更多信息。

like_value

my $like_value = $dbi->like_value

返回一个可以包值包装成like value格式的代码引用。

sub { "%$_[0]%" }

mapper

my $mapper = $dbi->mapper(param => $param);

创建一个DBIx::Custom::Mapper对象。

merge_param

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

合并参数，如上代码可以得到如下结果：

{key1 => [1, 1], key2 => 2}

如果被合并的两个参数包含相同的键名，则该被合并后对应键名的值会转换为数组引用。

model

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

获取一个由create_model 或 include_model方法创建的DBIx::Custom::Model对象。

mycolumn

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

创建列子句，如上代码会创建如下SQL片段：

book.author as author,
book.title as title

new

my $dbi = DBIx::Custom->new(
  dsn => "dbi:mysql:database=dbname",
  user => 'ken',
  password => '!LFKD%$&',
  option => {mysql_enable_utf8 => 1}
);

创建一个新的DBIx::Custom对象。

not_exists

my $not_exists = $dbi->not_exists;

返回一个DBIx::Custom::NotExists对象，表示当前列不存在。这个方法仅用于DBIx::Custom::Where对象中的param方法中。

order

my $order = $dbi->order;

创建一个DBIx::Custom::Order对象。

q

my $quooted = $dbi->q("title");

使用quote方法引用字符串。

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');
  }
);

注册过滤器，给某些方法参数中的filter选项使用。

select

my $result = $dbi->select(
  column => ['author', 'title'],
  table  => 'book',
  where  => {author => 'Ken'},
);

执行select语句。你可以传递奇数个参数。第一个参数是column，后面的所有参数共同组成了OPTION。

 my $result = $dbi->select(['author', 'title'], table => 'book');

select方法可以使用execute方法中所有的参数选项，除此之外还可以使用如下参数选项。

column

column => 'author'
column => ['author', 'title']

指定列子句，如果没有指定column，则默认为*。

column => '*'

你还可以用一个元素为hashref类型的arrayref作为column的值。

column => [
  {book => [qw/author title/]},
  {person => [qw/name age/]}
]

book.author as "book.author",
book.title as "book.title",
person.name as "person.name",
person.age as "person.age"

你可以通过 __MY__指定那些属于当前表的列。

column => [
  {__MY__ => [qw/author title/]},
]

__MY__可以通过mytable_symbol属性来改变。

param

param => {'table2.key3' => 5}

where子句之前“命名占位符”的绑定参数。

如果你要在join子句中指定“命名占位符”，则可以通过参param选项传递绑定参数。

join  => ['inner join (select * from table2 where table2.key3 = :table2.key3)as table2 on table1.key1 = table2.key1']

prefix

prefix => 'SQL_CALC_FOUND_ROWS'

列子句的前缀

select SQL_CALC_FOUND_ROWS title, author from book;

join

join => [
  'left outer join company on book.company_id = company_id',
  'left outer join location on company.location_id = location.id'
]

join子句，如果column子句或where子句包含像company.name这样的表名，则自动使用创建SQL时所需的join子句。

$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'
  ]
);

select company.location_id as location_id
from book
  left outer join company on book.company_id = company.id
where company.name = ?;

table

table => 'book'

表名。

where

# (1) Hash reference
where => {author => 'Ken', 'title' => ['Perl', 'Ruby']}
# -> where author = 'Ken' and title in ('Perl', 'Ruby')

# (2) DBIx::Custom::Where object
where => $dbi->where(
  clause => ['and', ':author{=}', ':title{like}'],
  param  => {author => 'Ken', title => '%Perl%'}
)
# -> where author = 'Ken' and title like '%Perl%'

# (3) Array reference[Array refenrece, Hash reference]
where => [
  ['and', ':author{=}', ':title{like}'],
  {author => 'Ken', title => '%Perl%'}
]
# -> where author = 'Ken' and title like '%Perl%'

# (4) Array reference[String, Hash reference]
where => [
  ':author{=} and :title{like}',
  {author => 'Ken', title => '%Perl%'}
]
#  -> where author = 'Ken' and title like '%Perl%'

# (5) String
where => 'title is null'
#  -> where title is null

where子句。更详细的内容可以参数DBIx::Custom::Where模块的文档。

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 { ... },
  }
);

此方法可以设置一些回调函数，用于在数据保存到数据（into）或从数据库中获取（from）时，根据数据类型对数据进行过滤。

在into1和into2中你可以指定与create table时一样的类型名，如：DATA 或 DATATIME。需要注意的是，在这里类型名必须要全是小写字母。into2中回调的执行在into1之后。

你可以使用available_typename方法获取在你当前数据库中可用的数据类型名称。

print $dbi->available_typename;

在from1和from2中指定数据类型不能使用类型名，而是使用以数字表示的类型。from2中的回调会在from1之后执行。

你可以使用available_datatype获取你当前数据库所有可用的数据类型。

你还可以一次为多个类型指定过滤器回调。

$dbi->type_rule(
  into1 => [
    [qw/DATE DATETIME/] => sub { ... },
  ],
);

update

$dbi->update({title => 'Perl'}, table  => 'book', where  => {id => 4});

执行更新语句。第一个参数的类型是hashref，表示要更新的数据。

如果数据项的值为常量值，则需要使用标题引用作为参数。

{date => \"NOW()"}

update方法支持execute方法中的所有参数选项，同时你还可以使用以下参数选项。

prefix

 prefix => 'or replace'

表名前面的前缀

update or replace book

table

table => 'book'

表名。

where

与select方法中的where选项相同。

warp

wrap => {price => sub { "max($_[0])" }}

占位符包装器。

$dbi->update({price => 100}, table => 'book', {price => sub { "$_[0] + 5" }});

update book set price =  ? + 5;

mtime

mtime => 'modified_time'

用于指定表中记录“更新时间”的列。默认时间格式为“YYYY-mm-dd HH：MM：SS”，可以通过now属性进行修改。

update_all

$dbi->update_all({title => 'Perl'}, table => 'book', );

为表中的所有记录执行update操作，参数选项与update方法相同。

sub update_all { shift->update(@_, allow_update_all => 1) };

show_datatype

$dbi->show_datatype($table);

显示指定表所有列的数据类型。

book
title: 5
issue_date: 91

此数据类型可以用于type_rule中的from1和from2中。

show_tables

$dbi->show_tables;

显示当前数据库中的所有表。

show_typename

$dbi->show_typename($table);

显示指定表所有列的类型名称。

book
title: varchar
issue_date: date

此数据类型的名称可以用于type_rule中的into1和into2中。

values_clause

my $values_clause = $dbi->values_clause({title => 'a', age => 2});

创建值子句。

(title, author) values (title = :title, age = :age);

你可以在插入语句中使用它。

my $insert_sql = "insert into book $values_clause";

where

my $where = $dbi->where;
$where->clause(['and', 'title = :title', 'author = :author']);
$where->param({title => 'Perl', author => 'Ken'});
$where->join(['left join author on book.author = author.id]);

创建一个新的DBIx::Custom::Where对象。

create_result EXPERIMENTAL

my $result = $dbi->create_result($sth);

创建一个DBIx::Custom::Result对象。

a