DBIx-Custom / lib / DBIx / Custom.pm /
Newer Older
3215 lines | 83.571kb
cleanup
yuki-kimoto authored on 2009-12-22
1
package DBIx::Custom;
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
2
use Object::Simple -base;
cleanup
yuki-kimoto authored on 2009-12-22
3

            
fixed named placeholder bug ...
Yuki Kimoto authored on 2011-08-01
4
our $VERSION = '0.1709';
fixed DBIx::Custom::QueryBui...
yuki-kimoto authored on 2010-08-15
5
use 5.008001;
cleanup
yuki-kimoto authored on 2009-12-22
6

            
packaging one directory
yuki-kimoto authored on 2009-11-16
7
use Carp 'croak';
8
use DBI;
9
use DBIx::Custom::Result;
cleanup
yuki-kimoto authored on 2010-02-11
10
use DBIx::Custom::Query;
cleanup
yuki-kimoto authored on 2010-08-05
11
use DBIx::Custom::QueryBuilder;
added experimental DBIx::Cus...
Yuki Kimoto authored on 2011-01-18
12
use DBIx::Custom::Where;
add feture. all model class ...
Yuki Kimoto authored on 2011-02-18
13
use DBIx::Custom::Model;
cleanup
Yuki Kimoto authored on 2011-01-25
14
use DBIx::Custom::Tag;
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
15
use DBIx::Custom::Order;
cleanup
Yuki Kimoto authored on 2011-04-25
16
use DBIx::Custom::Util qw/_array_to_hash _subname/;
improved debug message
Yuki Kimoto authored on 2011-05-23
17
use Encode qw/encode encode_utf8 decode_utf8/;
packaging one directory
yuki-kimoto authored on 2009-11-16
18

            
added environment variable D...
Yuki Kimoto authored on 2011-04-02
19
use constant DEBUG => $ENV{DBIX_CUSTOM_DEBUG} || 0;
improved debug message
Yuki Kimoto authored on 2011-05-23
20
use constant DEBUG_ENCODING => $ENV{DBIX_CUSTOM_DEBUG_ENCODING} || 'UTF-8';
added environment variable D...
Yuki Kimoto authored on 2011-04-02
21

            
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
22
has [qw/connector dsn password quote user/],
removed from cache() and cac...
Yuki Kimoto authored on 2011-03-29
23
    cache => 0,
many changed
Yuki Kimoto authored on 2011-01-23
24
    cache_method => sub {
25
        sub {
26
            my $self = shift;
27
            
28
            $self->{_cached} ||= {};
29
            
30
            if (@_ > 1) {
update pod
Yuki Kimoto authored on 2011-03-13
31
                $self->{_cached}{$_[0]} = $_[1];
many changed
Yuki Kimoto authored on 2011-01-23
32
            }
33
            else {
update pod
Yuki Kimoto authored on 2011-03-13
34
                return $self->{_cached}{$_[0]};
many changed
Yuki Kimoto authored on 2011-01-23
35
            }
36
        }
update pod
Yuki Kimoto authored on 2011-03-13
37
    },
38
    dbi_option => sub { {} },
39
    default_dbi_option => sub {
40
        {
41
            RaiseError => 1,
42
            PrintError => 0,
43
            AutoCommit => 1
44
        }
45
    },
fix tests
Yuki Kimoto authored on 2011-01-13
46
    filters => sub {
47
        {
48
            encode_utf8 => sub { encode_utf8($_[0]) },
49
            decode_utf8 => sub { decode_utf8($_[0]) }
50
        }
update pod
Yuki Kimoto authored on 2011-03-13
51
    },
added EXPERIMENTAL last_sql ...
Yuki Kimoto authored on 2011-07-11
52
    last_sql => '',
update pod
Yuki Kimoto authored on 2011-03-13
53
    models => sub { {} },
54
    query_builder => sub { DBIx::Custom::QueryBuilder->new },
55
    result_class  => 'DBIx::Custom::Result',
56
    safety_character => '\w',
added tag_parse attribute
Yuki Kimoto authored on 2011-06-28
57
    stash => sub { {} },
58
    tag_parse => 1;
cleanup
yuki-kimoto authored on 2010-10-17
59

            
added helper method
yuki-kimoto authored on 2010-10-17
60
our $AUTOLOAD;
61
sub AUTOLOAD {
62
    my $self = shift;
63

            
renamed helper to method.
Yuki Kimoto authored on 2011-01-25
64
    # Method name
65
    my ($package, $mname) = $AUTOLOAD =~ /^([\w\:]+)\:\:(\w+)$/;
added helper method
yuki-kimoto authored on 2010-10-17
66

            
cleanup
Yuki Kimoto authored on 2011-04-02
67
    # Call method
renamed helper to method.
Yuki Kimoto authored on 2011-01-25
68
    $self->{_methods} ||= {};
add feture. all model class ...
Yuki Kimoto authored on 2011-02-18
69
    if (my $method = $self->{_methods}->{$mname}) {
70
        return $self->$method(@_)
71
    }
- removed EXPERIMENTAL Prefo...
Yuki Kimoto authored on 2011-04-04
72
    elsif ($self->{dbh} && (my $dbh_method = $self->dbh->can($mname))) {
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
73
        $self->dbh->$dbh_method(@_);
add feture. all model class ...
Yuki Kimoto authored on 2011-02-18
74
    }
75
    else {
cleanup
Yuki Kimoto authored on 2011-04-25
76
        croak qq{Can't locate object method "$mname" via "$package" }
77
            . _subname;
add feture. all model class ...
Yuki Kimoto authored on 2011-02-18
78
    }
added helper method
yuki-kimoto authored on 2010-10-17
79
}
80

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
81
sub assign_param {
added EXPERIMENTAL assign_ta...
Yuki Kimoto authored on 2011-04-26
82
    my ($self, $param) = @_;
83
    
84
    # Create set tag
85
    my @params;
86
    my $safety = $self->safety_character;
insert and update method's p...
Yuki Kimoto authored on 2011-07-29
87
    foreach my $column (sort keys %$param) {
added EXPERIMENTAL assign_ta...
Yuki Kimoto authored on 2011-04-26
88
        croak qq{"$column" is not safety column name } . _subname
89
          unless $column =~ /^[$safety\.]+$/;
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
90
        my $column_quote = $self->_q($column);
91
        $column_quote =~ s/\./$self->_q(".")/e;
insert and update method's p...
Yuki Kimoto authored on 2011-07-29
92
        push @params, ref $param->{$column} eq 'SCALAR'
93
          ? "$column_quote = " . ${$param->{$column}}
94
          : "$column_quote = :$column";
95

            
added EXPERIMENTAL assign_ta...
Yuki Kimoto authored on 2011-04-26
96
    }
97
    my $tag = join(', ', @params);
98
    
99
    return $tag;
100
}
101

            
cleanup
Yuki Kimoto authored on 2011-03-21
102
sub column {
- DBIx::Custom Model filter ...
Yuki Kimoto authored on 2011-06-15
103
    my $self = shift;
104
    my $option = pop if ref $_[-1] eq 'HASH';
105
    my $real_table = shift;
106
    my $columns = shift;
107
    my $table = $option->{alias} || $real_table;
108
    
109
    # Columns
110
    unless ($columns) {
111
        $columns ||= $self->model($real_table)->columns;
112
    }
added helper method
yuki-kimoto authored on 2010-10-17
113
    
EXPERIMTANL column method th...
Yuki Kimoto authored on 2011-06-13
114
    # Separator
115
    my $separator = $self->separator;
116
    
cleanup
Yuki Kimoto authored on 2011-04-02
117
    # Column clause
cleanup
Yuki Kimoto authored on 2011-03-21
118
    my @column;
cleanup
Yuki Kimoto authored on 2011-04-02
119
    $columns ||= [];
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
120
    push @column, $self->_q($table) . "." . $self->_q($_) .
121
      " as " . $self->_q("${table}${separator}$_")
EXPERIMTANL column method th...
Yuki Kimoto authored on 2011-06-13
122
      for @$columns;
cleanup
Yuki Kimoto authored on 2011-03-21
123
    
124
    return join (', ', @column);
added helper method
yuki-kimoto authored on 2010-10-17
125
}
126

            
packaging one directory
yuki-kimoto authored on 2009-11-16
127
sub connect {
cleanup
Yuki Kimoto authored on 2011-01-25
128
    my $self = ref $_[0] ? shift : shift->new(@_);;
removed register_format()
yuki-kimoto authored on 2010-05-26
129
    
- removed EXPERIMENTAL Prefo...
Yuki Kimoto authored on 2011-04-04
130
    # Connect
131
    $self->dbh;
update document
yuki-kimoto authored on 2010-01-30
132
    
packaging one directory
yuki-kimoto authored on 2009-11-16
133
    return $self;
134
}
135

            
update pod
Yuki Kimoto authored on 2011-03-13
136
sub dbh {
137
    my $self = shift;
cleanup
Yuki Kimoto authored on 2011-04-02
138
    
fixed dbh() method bug:wq
Yuki Kimoto authored on 2011-04-05
139
    # Set
140
    if (@_) {
141
        $self->{dbh} = $_[0];
142
        
143
        return $self;
144
    }
145
    
146
    # Get
147
    else {
148
        # From Connction manager
149
        if (my $connector = $self->connector) {
cleanup
Yuki Kimoto authored on 2011-04-25
150
            croak "connector must have dbh() method " . _subname
fixed dbh() method bug:wq
Yuki Kimoto authored on 2011-04-05
151
              unless ref $connector && $connector->can('dbh');
152
              
set reserved_word_quote auto...
Yuki Kimoto authored on 2011-06-08
153
            $self->{dbh} = $connector->dbh;
fixed dbh() method bug:wq
Yuki Kimoto authored on 2011-04-05
154
        }
155
        
set reserved_word_quote auto...
Yuki Kimoto authored on 2011-06-08
156
        # Connect
157
        $self->{dbh} ||= $self->_connect;
158
        
159
        # Quote
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
160
        if (!defined $self->reserved_word_quote && !defined $self->quote) {
set reserved_word_quote auto...
Yuki Kimoto authored on 2011-06-08
161
            my $driver = $self->{dbh}->{Driver}->{Name};
162
            my $quote = $driver eq 'mysql' ? '`' : '"';
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
163
            $self->quote($quote);
set reserved_word_quote auto...
Yuki Kimoto authored on 2011-06-08
164
        }
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
165
        
set reserved_word_quote auto...
Yuki Kimoto authored on 2011-06-08
166
        return $self->{dbh};
update pod
Yuki Kimoto authored on 2011-03-13
167
    }
168
}
169

            
cleanup
yuki-kimoto authored on 2010-10-17
170
sub delete {
select, insert, update, upda...
yuki-kimoto authored on 2010-06-14
171
    my ($self, %args) = @_;
added EXPERIMENTAL reserved_...
Yuki Kimoto authored on 2011-03-30
172

            
cleanup update and update_al...
yuki-kimoto authored on 2010-04-28
173
    # Arguments
cleanup
Yuki Kimoto authored on 2011-03-21
174
    my $table = $args{table} || '';
cleanup
Yuki Kimoto authored on 2011-04-25
175
    croak qq{"table" option must be specified. } . _subname
improved error messages
Yuki Kimoto authored on 2011-04-18
176
      unless $table;
cleanup
Yuki Kimoto authored on 2011-03-21
177
    my $where            = delete $args{where} || {};
178
    my $append           = delete $args{append};
179
    my $allow_delete_all = delete $args{allow_delete_all};
DEPRECATED select() param op...
Yuki Kimoto authored on 2011-04-25
180
    my $where_param      = delete $args{where_param} || {};
delete_at is DEPRECATED! use...
Yuki Kimoto authored on 2011-06-08
181
    my $id = delete $args{id};
182
    my $primary_key = delete $args{primary_key};
183
    croak "update method primary_key option " .
184
          "must be specified when id is specified " . _subname
185
      if defined $id && !defined $primary_key;
186
    $primary_key = [$primary_key] unless ref $primary_key eq 'ARRAY';
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
187
    my $prefix = delete $args{prefix};
delete_at is DEPRECATED! use...
Yuki Kimoto authored on 2011-06-08
188
    
make delete() using where ob...
Yuki Kimoto authored on 2011-01-26
189
    # Where
fixed small insert, update, ...
Yuki Kimoto authored on 2011-06-21
190
    $where = $self->_create_param_from_id($id, $primary_key) if defined $id;
select, update, and delete w...
Yuki Kimoto authored on 2011-04-25
191
    my $where_clause = '';
updated pod
Yuki Kimoto authored on 2011-06-21
192
    if (ref $where eq 'ARRAY' && !ref $where->[0]) {
193
        $where_clause = "where " . $where->[0];
194
        $where_param = $where->[1];
195
    }
196
    elsif (ref $where) {
select, update, and delete w...
Yuki Kimoto authored on 2011-04-25
197
        $where = $self->_where_to_obj($where);
DEPRECATED select() param op...
Yuki Kimoto authored on 2011-04-25
198
        $where_param = keys %$where_param
199
                     ? $self->merge_param($where_param, $where->param)
200
                     : $where->param;
select, update, and delete w...
Yuki Kimoto authored on 2011-04-25
201
        
202
        # String where
203
        $where_clause = $where->to_string;
204
    }
205
    elsif ($where) { $where_clause = "where $where" }
cleanup
Yuki Kimoto authored on 2011-04-25
206
    croak qq{"where" must be specified } . _subname
cleanup
Yuki Kimoto authored on 2011-04-02
207
      if $where_clause eq '' && !$allow_delete_all;
make delete() using where ob...
Yuki Kimoto authored on 2011-01-26
208

            
cleanup
Yuki Kimoto authored on 2011-04-02
209
    # Delete statement
cleanup
Yuki Kimoto authored on 2011-01-27
210
    my @sql;
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
211
    push @sql, "delete";
212
    push @sql, $prefix if defined $prefix;
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
213
    push @sql, "from " . $self->_q($table) . " $where_clause";
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
214
    push @sql, $append if defined $append;
cleanup
Yuki Kimoto authored on 2011-01-27
215
    my $sql = join(' ', @sql);
packaging one directory
yuki-kimoto authored on 2009-11-16
216
    
217
    # Execute query
updated pod
Yuki Kimoto authored on 2011-06-21
218
    return $self->execute($sql, $where_param, table => $table, %args);
packaging one directory
yuki-kimoto authored on 2009-11-16
219
}
220

            
cleanup
yuki-kimoto authored on 2010-10-17
221
sub delete_all { shift->delete(allow_delete_all => 1, @_) }
packaging one directory
yuki-kimoto authored on 2009-11-16
222

            
added helper method
yuki-kimoto authored on 2010-10-17
223
sub DESTROY { }
224

            
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
225
sub create_model {
226
    my $self = shift;
227
    
cleanup
Yuki Kimoto authored on 2011-04-02
228
    # Arguments
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
229
    my $args = ref $_[0] eq 'HASH' ? $_[0] : {@_};
230
    $args->{dbi} = $self;
231
    my $model_class = delete $args->{model_class} || 'DBIx::Custom::Model';
232
    my $model_name  = delete $args->{name};
233
    my $model_table = delete $args->{table};
234
    $model_name ||= $model_table;
235
    
cleanup
Yuki Kimoto authored on 2011-04-02
236
    # Create model
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
237
    my $model = $model_class->new($args);
238
    $model->name($model_name) unless $model->name;
239
    $model->table($model_table) unless $model->table;
240
    
micro optimization
Yuki Kimoto authored on 2011-07-30
241
    # Apply filter(DEPRECATED logic)
242
    if ($model->{filter}) {
243
        my $filter = ref $model->filter eq 'HASH'
244
                   ? [%{$model->filter}]
245
                   : $model->filter;
246
        $filter ||= [];
247
        warn "DBIx::Custom::Model filter method is DEPRECATED!"
248
          if @$filter;
249
        $self->_apply_filter($model->table, @$filter);
250
    }
251
    
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
252
    # Set model
253
    $self->model($model->name, $model);
254
    
create_model() return model
Yuki Kimoto authored on 2011-03-29
255
    return $self->model($model->name);
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
256
}
257

            
258
sub each_column {
259
    my ($self, $cb) = @_;
260
    
261
    # Iterate all tables
262
    my $sth_tables = $self->dbh->table_info;
263
    while (my $table_info = $sth_tables->fetchrow_hashref) {
264
        
265
        # Table
266
        my $table = $table_info->{TABLE_NAME};
267
        
268
        # Iterate all columns
269
        my $sth_columns = $self->dbh->column_info(undef, undef, $table, '%');
270
        while (my $column_info = $sth_columns->fetchrow_hashref) {
271
            my $column = $column_info->{COLUMN_NAME};
272
            $self->$cb($table, $column, $column_info);
273
        }
274
    }
275
}
276

            
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
277
sub each_table {
278
    my ($self, $cb) = @_;
279
    
280
    # Iterate all tables
281
    my $sth_tables = $self->dbh->table_info;
282
    while (my $table_info = $sth_tables->fetchrow_hashref) {
283
        
284
        # Table
285
        my $table = $table_info->{TABLE_NAME};
286
        $self->$cb($table, $table_info);
287
    }
288
}
289

            
simplified arguments check
Yuki Kimoto authored on 2011-07-11
290
our %VALID_ARGS = map { $_ => 1 } qw/append allow_delete_all
291
  allow_update_all bind_type column filter id join param prefix primary_key
292
  query relation table table_alias type type_rule_off type_rule1_off
293
  type_rule2_off wrap/;
cleanup
Yuki Kimoto authored on 2011-04-02
294

            
295
sub execute {
execute method can second ar...
Yuki Kimoto authored on 2011-06-09
296
    my $self = shift;
297
    my $query = shift;
298
    my $param;
299
    $param = shift if @_ % 2;
300
    my %args = @_;
refactoring delete and delet...
yuki-kimoto authored on 2010-04-28
301
    
cleanup
Yuki Kimoto authored on 2011-04-02
302
    # Arguments
execute method can second ar...
Yuki Kimoto authored on 2011-06-09
303
    my $p = delete $args{param} || {};
304
    $param ||= $p;
cleanup
Yuki Kimoto authored on 2011-04-02
305
    my $tables = delete $args{table} || [];
306
    $tables = [$tables] unless ref $tables eq 'ARRAY';
cleanup
Yuki Kimoto authored on 2011-04-02
307
    my $filter = delete $args{filter};
cleanup
Yuki Kimoto authored on 2011-04-25
308
    $filter = _array_to_hash($filter);
DBIx::Custom::Model type att...
Yuki Kimoto authored on 2011-06-17
309
    my $bind_type = delete $args{bind_type} || delete $args{type};
310
    $bind_type = _array_to_hash($bind_type);
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
311
    my $type_rule_off = delete $args{type_rule_off};
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
312
    my $type_rule_off_parts = {
313
        1 => delete $args{type_rule1_off},
314
        2 => delete $args{type_rule2_off}
315
    };
cleanup
Yuki Kimoto authored on 2011-06-09
316
    my $query_return = delete $args{query};
added EXPERIMENTAL execute m...
Yuki Kimoto authored on 2011-06-27
317
    my $table_alias = delete $args{table_alias} || {};
added EXPERIMENTAL reserved_...
Yuki Kimoto authored on 2011-03-30
318
    
cleanup
Yuki Kimoto authored on 2011-03-09
319
    # Check argument names
select, insert, update, upda...
yuki-kimoto authored on 2010-06-14
320
    foreach my $name (keys %args) {
cleanup
Yuki Kimoto authored on 2011-04-25
321
        croak qq{"$name" is wrong option } . _subname
simplified arguments check
Yuki Kimoto authored on 2011-07-11
322
          unless $VALID_ARGS{$name};
refactoring delete and delet...
yuki-kimoto authored on 2010-04-28
323
    }
324
    
cleanup
Yuki Kimoto authored on 2011-04-02
325
    # Create query
updated pod
Yuki Kimoto authored on 2011-06-21
326
    $query = $self->_create_query($query) unless ref $query;
added EXPERIMENTAL last_sql ...
Yuki Kimoto authored on 2011-07-11
327
    
328
    # Save query
329
    $self->last_sql($query->sql);
330

            
cleanup
Yuki Kimoto authored on 2011-06-09
331
    return $query if $query_return;
micro optimization
Yuki Kimoto authored on 2011-07-30
332
    
333
    # DEPRECATED! Merge query filter
DBIx::Custom::Query filter m...
Yuki Kimoto authored on 2011-07-30
334
    $filter ||= $query->{filter} || {};
all filter can receive array...
Yuki Kimoto authored on 2011-02-25
335
    
cleanup
Yuki Kimoto authored on 2011-04-02
336
    # Tables
DBIx::Custom::Query tables a...
Yuki Kimoto authored on 2011-07-30
337
    unshift @$tables, @{$query->{tables} || []};
micro optimization
Yuki Kimoto authored on 2011-07-30
338
    my $main_table = @{$tables}[-1];
micro optimization
Yuki Kimoto authored on 2011-07-30
339
    
micro optimization
Yuki Kimoto authored on 2011-07-30
340
    # DEPRECATED! Cleanup tables
micro optimization
Yuki Kimoto authored on 2011-07-30
341
    $tables = $self->_remove_duplicate_table($tables, $main_table)
342
      if @$tables > 1;
cleanup
Yuki Kimoto authored on 2011-04-02
343
    
added type_rule into logic
Yuki Kimoto authored on 2011-06-09
344
    # Type rule
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
345
    my $type_filters = {};
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
346
    unless ($type_rule_off) {
micro optimization
Yuki Kimoto authored on 2011-07-30
347
        foreach my $i (1, 2) {
348
            unless ($type_rule_off_parts->{$i}) {
349
                $type_filters->{$i} = {};
350
                foreach my $alias (keys %$table_alias) {
351
                    my $table = $table_alias->{$alias};
added EXPERIMENTAL execute m...
Yuki Kimoto authored on 2011-06-27
352
                    
micro optimization
Yuki Kimoto authored on 2011-07-30
353
                    foreach my $column (keys %{$self->{"_into$i"}{key}{$table} || {}}) {
354
                        $type_filters->{$i}->{"$alias.$column"} = $self->{"_into$i"}{key}{$table}{$column};
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
355
                    }
356
                }
micro optimization
Yuki Kimoto authored on 2011-07-30
357
                $type_filters->{$i} = {%{$type_filters->{$i}}, %{$self->{"_into$i"}{key}{$main_table} || {}}}
358
                  if $main_table;
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
359
            }
added type_rule into logic
Yuki Kimoto authored on 2011-06-09
360
        }
361
    }
cleanup
Yuki Kimoto authored on 2011-04-02
362
    
micro optimization
Yuki Kimoto authored on 2011-07-30
363
    # DEPRECATED! Applied filter
micro optimization
Yuki Kimoto authored on 2011-07-30
364
    if ($self->{filter}{on}) {
365
        my $applied_filter = {};
366
        foreach my $table (@$tables) {
367
            $applied_filter = {
368
                %$applied_filter,
369
                %{$self->{filter}{out}->{$table} || {}}
370
            }
added auto_filter method
kimoto.yuki@gmail.com authored on 2010-12-21
371
        }
micro optimization
Yuki Kimoto authored on 2011-07-30
372
        $filter = {%$applied_filter, %$filter};
added auto_filter method
kimoto.yuki@gmail.com authored on 2010-12-21
373
    }
374
    
cleanup
Yuki Kimoto authored on 2011-04-02
375
    # Replace filter name to code
376
    foreach my $column (keys %$filter) {
377
        my $name = $filter->{$column};
378
        if (!defined $name) {
379
            $filter->{$column} = undef;
renamed auto_filter to apply...
Yuki Kimoto authored on 2011-01-12
380
        }
cleanup
Yuki Kimoto authored on 2011-04-02
381
        elsif (ref $name ne 'CODE') {
cleanup
Yuki Kimoto authored on 2011-04-25
382
          croak qq{Filter "$name" is not registered" } . _subname
cleanup
Yuki Kimoto authored on 2011-04-02
383
            unless exists $self->filters->{$name};
384
          $filter->{$column} = $self->filters->{$name};
cleanup
Yuki Kimoto authored on 2010-12-21
385
        }
386
    }
packaging one directory
yuki-kimoto authored on 2009-11-16
387
    
cleanup
Yuki Kimoto authored on 2011-04-02
388
    # Create bind values
389
    my $bind = $self->_create_bind_values(
390
        $param,
391
        $query->columns,
392
        $filter,
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
393
        $type_filters,
DBIx::Custom::Model type att...
Yuki Kimoto authored on 2011-06-17
394
        $bind_type
cleanup
Yuki Kimoto authored on 2011-04-02
395
    );
cleanup
yuki-kimoto authored on 2010-10-17
396
    
397
    # Execute
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
398
    my $sth = $query->sth;
cleanup
yuki-kimoto authored on 2010-10-17
399
    my $affected;
cleanup
Yuki Kimoto authored on 2011-03-21
400
    eval {
401
        for (my $i = 0; $i < @$bind; $i++) {
DBIx::Custom::Model type att...
Yuki Kimoto authored on 2011-06-17
402
            my $bind_type = $bind->[$i]->{bind_type};
403
            $sth->bind_param(
404
                $i + 1,
405
                $bind->[$i]->{value},
406
                $bind_type ? $bind_type : ()
407
            );
cleanup
Yuki Kimoto authored on 2011-03-21
408
        }
409
        $affected = $sth->execute;
410
    };
improved error messages
Yuki Kimoto authored on 2011-04-18
411
    
micro optimization
Yuki Kimoto authored on 2011-07-30
412
    $self->_croak($@, qq{. Following SQL is executed.\n}
413
      . qq{$query->{sql}\n} . _subname) if $@;
cleanup
yuki-kimoto authored on 2010-10-17
414
    
improved debug message
Yuki Kimoto authored on 2011-05-23
415
    # DEBUG message
416
    if (DEBUG) {
417
        print STDERR "SQL:\n" . $query->sql . "\n";
418
        my @output;
419
        foreach my $b (@$bind) {
420
            my $value = $b->{value};
421
            $value = 'undef' unless defined $value;
422
            $value = encode(DEBUG_ENCODING(), $value)
423
              if utf8::is_utf8($value);
424
            push @output, $value;
425
        }
426
        print STDERR "Bind values: " . join(', ', @output) . "\n\n";
427
    }
added environment variable D...
Yuki Kimoto authored on 2011-04-02
428
    
cleanup
Yuki Kimoto authored on 2011-04-02
429
    # Select statement
cleanup
yuki-kimoto authored on 2010-10-17
430
    if ($sth->{NUM_OF_FIELDS}) {
431
        
micro optimization
Yuki Kimoto authored on 2011-07-30
432
        # DEPRECATED! Filter
cleanup
Yuki Kimoto authored on 2011-04-02
433
        my $filter = {};
micro optimization
Yuki Kimoto authored on 2011-07-30
434
        if ($self->{filter}{on}) {
435
            $filter->{in}  = {};
436
            $filter->{end} = {};
437
            push @$tables, $main_table if $main_table;
438
            foreach my $table (@$tables) {
439
                foreach my $way (qw/in end/) {
440
                    $filter->{$way} = {
441
                        %{$filter->{$way}},
442
                        %{$self->{filter}{$way}{$table} || {}}
443
                    };
444
                }
cleanup
Yuki Kimoto authored on 2011-04-02
445
            }
cleanup
Yuki Kimoto authored on 2011-01-12
446
        }
447
        
448
        # Result
449
        my $result = $self->result_class->new(
added type_rule method and f...
Yuki Kimoto authored on 2011-06-09
450
            sth => $sth,
451
            filters => $self->filters,
cleanup
Yuki Kimoto authored on 2011-01-12
452
            default_filter => $self->{default_in_filter},
added type_rule method and f...
Yuki Kimoto authored on 2011-06-09
453
            filter => $filter->{in} || {},
454
            end_filter => $filter->{end} || {},
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
455
            type_rule => {
456
                from1 => $self->type_rule->{from1},
457
                from2 => $self->type_rule->{from2}
458
            },
cleanup
yuki-kimoto authored on 2010-10-17
459
        );
460

            
461
        return $result;
462
    }
cleanup
Yuki Kimoto authored on 2011-04-02
463
    
464
    # Not select statement
465
    else { return $affected }
cleanup
yuki-kimoto authored on 2010-10-17
466
}
467

            
468
sub insert {
- insert, insert_at, update,...
Yuki Kimoto authored on 2011-06-08
469
    my $self = shift;
added EXPERIMENTAL reserved_...
Yuki Kimoto authored on 2011-03-30
470
    
cleanup
yuki-kimoto authored on 2010-10-17
471
    # Arguments
- insert, insert_at, update,...
Yuki Kimoto authored on 2011-06-08
472
    my $param;
473
    $param = shift if @_ % 2;
474
    my %args = @_;
cleanup
Yuki Kimoto authored on 2011-03-21
475
    my $table  = delete $args{table};
cleanup
Yuki Kimoto authored on 2011-04-25
476
    croak qq{"table" option must be specified } . _subname
simplified arguments check
Yuki Kimoto authored on 2011-07-11
477
      unless defined $table;
- insert, insert_at, update,...
Yuki Kimoto authored on 2011-06-08
478
    my $p = delete $args{param} || {};
479
    $param  ||= $p;
cleanup
Yuki Kimoto authored on 2011-03-21
480
    my $append = delete $args{append} || '';
insert_at is DEPRECATED! add...
Yuki Kimoto authored on 2011-06-08
481
    my $id = delete $args{id};
482
    my $primary_key = delete $args{primary_key};
cleanup
Yuki Kimoto authored on 2011-06-08
483
    croak "insert method primary_key option " .
added tests
Yuki Kimoto authored on 2011-06-08
484
          "must be specified when id is specified " . _subname
485
      if defined $id && !defined $primary_key;
insert_at is DEPRECATED! add...
Yuki Kimoto authored on 2011-06-08
486
    $primary_key = [$primary_key] unless ref $primary_key eq 'ARRAY';
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
487
    my $prefix = delete $args{prefix};
cleanup
Yuki Kimoto authored on 2011-04-02
488

            
insert_at is DEPRECATED! add...
Yuki Kimoto authored on 2011-06-08
489
    # Merge parameter
fixed small insert, update, ...
Yuki Kimoto authored on 2011-06-21
490
    if (defined $id) {
cleanup
Yuki Kimoto authored on 2011-06-08
491
        my $id_param = $self->_create_param_from_id($id, $primary_key);
insert_at is DEPRECATED! add...
Yuki Kimoto authored on 2011-06-08
492
        $param = $self->merge_param($id_param, $param);
493
    }
494

            
cleanup
Yuki Kimoto authored on 2011-04-02
495
    # Insert statement
cleanup
Yuki Kimoto authored on 2011-01-27
496
    my @sql;
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
497
    push @sql, "insert";
498
    push @sql, $prefix if defined $prefix;
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
499
    push @sql, "into " . $self->_q($table) . " " . $self->insert_param($param);
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
500
    push @sql, $append if defined $append;
cleanup
Yuki Kimoto authored on 2011-01-27
501
    my $sql = join (' ', @sql);
packaging one directory
yuki-kimoto authored on 2009-11-16
502
    
503
    # Execute query
updated pod
Yuki Kimoto authored on 2011-06-21
504
    return $self->execute($sql, $param, table => $table, %args);
packaging one directory
yuki-kimoto authored on 2009-11-16
505
}
506

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
507
sub insert_param {
remove experimental DBIx::Cu...
Yuki Kimoto authored on 2011-03-08
508
    my ($self, $param) = @_;
509
    
cleanup
Yuki Kimoto authored on 2011-04-02
510
    # Create insert parameter tag
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
511
    my $safety = $self->safety_character;
cleanup
Yuki Kimoto authored on 2011-04-02
512
    my @columns;
513
    my @placeholders;
insert and update method's p...
Yuki Kimoto authored on 2011-07-29
514
    foreach my $column (sort keys %$param) {
cleanup
Yuki Kimoto authored on 2011-04-25
515
        croak qq{"$column" is not safety column name } . _subname
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
516
          unless $column =~ /^[$safety\.]+$/;
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
517
        my $column_quote = $self->_q($column);
518
        $column_quote =~ s/\./$self->_q(".")/e;
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
519
        push @columns, $column_quote;
insert and update method's p...
Yuki Kimoto authored on 2011-07-29
520
        push @placeholders, ref $param->{$column} eq 'SCALAR'
521
          ? ${$param->{$column}} : ":$column";
remove experimental DBIx::Cu...
Yuki Kimoto authored on 2011-03-08
522
    }
523
    
cleanup
Yuki Kimoto authored on 2011-04-02
524
    return '(' . join(', ', @columns) . ') ' . 'values ' .
525
           '(' . join(', ', @placeholders) . ')'
remove experimental DBIx::Cu...
Yuki Kimoto authored on 2011-03-08
526
}
527

            
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
528
sub include_model {
529
    my ($self, $name_space, $model_infos) = @_;
530
    
cleanup
Yuki Kimoto authored on 2011-04-02
531
    # Name space
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
532
    $name_space ||= '';
cleanup
Yuki Kimoto authored on 2011-04-02
533
    
534
    # Get Model infomations
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
535
    unless ($model_infos) {
cleanup
Yuki Kimoto authored on 2011-04-02
536

            
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
537
        # Load name space module
cleanup
Yuki Kimoto authored on 2011-04-25
538
        croak qq{"$name_space" is invalid class name } . _subname
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
539
          if $name_space =~ /[^\w:]/;
540
        eval "use $name_space";
cleanup
Yuki Kimoto authored on 2011-04-25
541
        croak qq{Name space module "$name_space.pm" is needed. $@ }
542
            . _subname
improved error messages
Yuki Kimoto authored on 2011-04-18
543
          if $@;
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
544
        
545
        # Search model modules
546
        my $path = $INC{"$name_space.pm"};
547
        $path =~ s/\.pm$//;
548
        opendir my $dh, $path
cleanup
Yuki Kimoto authored on 2011-04-25
549
          or croak qq{Can't open directory "$path": $! } . _subname
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
550
        $model_infos = [];
551
        while (my $module = readdir $dh) {
552
            push @$model_infos, $module
553
              if $module =~ s/\.pm$//;
554
        }
555
        close $dh;
556
    }
557
    
cleanup
Yuki Kimoto authored on 2011-04-02
558
    # Include models
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
559
    foreach my $model_info (@$model_infos) {
560
        
cleanup
Yuki Kimoto authored on 2011-04-02
561
        # Load model
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
562
        my $model_class;
563
        my $model_name;
564
        my $model_table;
565
        if (ref $model_info eq 'HASH') {
566
            $model_class = $model_info->{class};
567
            $model_name  = $model_info->{name};
568
            $model_table = $model_info->{table};
569
            
570
            $model_name  ||= $model_class;
571
            $model_table ||= $model_name;
572
        }
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
573
        else { $model_class = $model_name = $model_table = $model_info }
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
574
        my $mclass = "${name_space}::$model_class";
cleanup
Yuki Kimoto authored on 2011-04-25
575
        croak qq{"$mclass" is invalid class name } . _subname
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
576
          if $mclass =~ /[^\w:]/;
577
        unless ($mclass->can('isa')) {
578
            eval "use $mclass";
cleanup
Yuki Kimoto authored on 2011-04-25
579
            croak "$@ " . _subname if $@;
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
580
        }
581
        
cleanup
Yuki Kimoto authored on 2011-04-02
582
        # Create model
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
583
        my $args = {};
584
        $args->{model_class} = $mclass if $mclass;
585
        $args->{name}        = $model_name if $model_name;
586
        $args->{table}       = $model_table if $model_table;
587
        $self->create_model($args);
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
588
    }
589
    
590
    return $self;
591
}
592

            
added EXPERIMENTAL map_param...
Yuki Kimoto authored on 2011-06-24
593
sub map_param {
594
    my $self = shift;
595
    my $param = shift;
596
    my %map = @_;
597
    
598
    # Mapping
599
    my $map_param = {};
600
    foreach my $key (keys %map) {
601
        my $value_cb;
602
        my $condition;
603
        my $map_key;
604
        
605
        # Get mapping information
606
        if (ref $map{$key} eq 'ARRAY') {
607
            foreach my $some (@{$map{$key}}) {
608
                $map_key = $some unless ref $some;
609
                $condition = $some->{if} if ref $some eq 'HASH';
610
                $value_cb = $some if ref $some eq 'CODE';
611
            }
612
        }
613
        else {
614
            $map_key = $map{$key};
615
        }
616
        $value_cb ||= sub { $_[0] };
617
        $condition ||= sub { defined $_[0] && length $_[0] };
618

            
619
        # Map parameter
620
        my $value;
621
        if (ref $condition eq 'CODE') {
622
            $map_param->{$map_key} = $value_cb->($param->{$key})
623
              if $condition->($param->{$key});
624
        }
625
        elsif ($condition eq 'exists') {
626
            $map_param->{$map_key} = $value_cb->($param->{$key})
627
              if exists $param->{$key};
628
        }
629
        else { croak qq/Condition must be code reference or "exists" / . _subname }
630
    }
631
    
632
    return $map_param;
633
}
634

            
added EXPERIMENTAL updat_par...
Yuki Kimoto authored on 2011-03-30
635
sub merge_param {
636
    my ($self, @params) = @_;
637
    
cleanup
Yuki Kimoto authored on 2011-04-02
638
    # Merge parameters
fixed merge_param bug
Yuki Kimoto authored on 2011-05-23
639
    my $merge = {};
640
    foreach my $param (@params) {
641
        foreach my $column (keys %$param) {
642
            my $param_is_array = ref $param->{$column} eq 'ARRAY' ? 1 : 0;
643
            
644
            if (exists $merge->{$column}) {
645
                $merge->{$column} = [$merge->{$column}]
646
                  unless ref $merge->{$column} eq 'ARRAY';
647
                push @{$merge->{$column}},
648
                  ref $param->{$column} ? @{$param->{$column}} : $param->{$column};
added EXPERIMENTAL updat_par...
Yuki Kimoto authored on 2011-03-30
649
            }
650
            else {
fixed merge_param bug
Yuki Kimoto authored on 2011-05-23
651
                $merge->{$column} = $param->{$column};
added EXPERIMENTAL updat_par...
Yuki Kimoto authored on 2011-03-30
652
            }
653
        }
654
    }
655
    
fixed merge_param bug
Yuki Kimoto authored on 2011-05-23
656
    return $merge;
added EXPERIMENTAL updat_par...
Yuki Kimoto authored on 2011-03-30
657
}
658

            
cleanup
Yuki Kimoto authored on 2011-03-21
659
sub method {
660
    my $self = shift;
661
    
cleanup
Yuki Kimoto authored on 2011-04-02
662
    # Register method
cleanup
Yuki Kimoto authored on 2011-03-21
663
    my $methods = ref $_[0] eq 'HASH' ? $_[0] : {@_};
664
    $self->{_methods} = {%{$self->{_methods} || {}}, %$methods};
665
    
666
    return $self;
667
}
668

            
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
669
sub model {
670
    my ($self, $name, $model) = @_;
671
    
cleanup
Yuki Kimoto authored on 2011-04-02
672
    # Set model
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
673
    if ($model) {
674
        $self->models->{$name} = $model;
675
        return $self;
676
    }
677
    
678
    # Check model existance
cleanup
Yuki Kimoto authored on 2011-04-25
679
    croak qq{Model "$name" is not included } . _subname
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
680
      unless $self->models->{$name};
681
    
cleanup
Yuki Kimoto authored on 2011-04-02
682
    # Get model
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-15
683
    return $self->models->{$name};
684
}
685

            
cleanup
Yuki Kimoto authored on 2011-03-21
686
sub mycolumn {
687
    my ($self, $table, $columns) = @_;
688
    
cleanup
Yuki Kimoto authored on 2011-04-02
689
    # Create column clause
690
    my @column;
cleanup
Yuki Kimoto authored on 2011-03-21
691
    $columns ||= [];
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
692
    push @column, $self->_q($table) . "." . $self->_q($_) .
693
      " as " . $self->_q($_)
694
      for @$columns;
cleanup
Yuki Kimoto authored on 2011-03-21
695
    
696
    return join (', ', @column);
697
}
698

            
added dbi_options attribute
kimoto authored on 2010-12-20
699
sub new {
700
    my $self = shift->SUPER::new(@_);
701
    
cleanup
Yuki Kimoto authored on 2011-04-02
702
    # Check attributes
added dbi_options attribute
kimoto authored on 2010-12-20
703
    my @attrs = keys %$self;
704
    foreach my $attr (@attrs) {
cleanup
Yuki Kimoto authored on 2011-04-25
705
        croak qq{"$attr" is wrong name } . _subname
added dbi_options attribute
kimoto authored on 2010-12-20
706
          unless $self->can($attr);
707
    }
cleanup
Yuki Kimoto authored on 2011-04-02
708
    
set reserved_word_quote auto...
Yuki Kimoto authored on 2011-06-08
709
    # DEPRECATED!
fixed DEPRECATED messages
Yuki Kimoto authored on 2011-06-08
710
    $self->query_builder->{tags} = {
cleanup
Yuki Kimoto authored on 2011-01-25
711
        '?'     => \&DBIx::Custom::Tag::placeholder,
712
        '='     => \&DBIx::Custom::Tag::equal,
713
        '<>'    => \&DBIx::Custom::Tag::not_equal,
714
        '>'     => \&DBIx::Custom::Tag::greater_than,
715
        '<'     => \&DBIx::Custom::Tag::lower_than,
716
        '>='    => \&DBIx::Custom::Tag::greater_than_equal,
717
        '<='    => \&DBIx::Custom::Tag::lower_than_equal,
718
        'like'  => \&DBIx::Custom::Tag::like,
719
        'in'    => \&DBIx::Custom::Tag::in,
720
        'insert_param' => \&DBIx::Custom::Tag::insert_param,
721
        'update_param' => \&DBIx::Custom::Tag::update_param
fixed DEPRECATED messages
Yuki Kimoto authored on 2011-06-08
722
    };
added dbi_options attribute
kimoto authored on 2010-12-20
723
    
724
    return $self;
725
}
726

            
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
727
sub not_exists { bless {}, 'DBIx::Custom::NotExists' }
728

            
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
729
sub order {
730
    my $self = shift;
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
731
    return DBIx::Custom::Order->new(dbi => $self, @_);
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
732
}
733

            
cleanup
yuki-kimoto authored on 2010-10-17
734
sub register_filter {
cleanup
Yuki Kimoto authored on 2011-04-02
735
    my $self = shift;
cleanup
yuki-kimoto authored on 2010-10-17
736
    
737
    # Register filter
738
    my $filters = ref $_[0] eq 'HASH' ? $_[0] : {@_};
cleanup
Yuki Kimoto authored on 2011-04-02
739
    $self->filters({%{$self->filters}, %$filters});
cleanup
yuki-kimoto authored on 2010-10-17
740
    
cleanup
Yuki Kimoto authored on 2011-04-02
741
    return $self;
cleanup
yuki-kimoto authored on 2010-10-17
742
}
packaging one directory
yuki-kimoto authored on 2009-11-16
743

            
744
sub select {
select, insert, update, upda...
yuki-kimoto authored on 2010-06-14
745
    my ($self, %args) = @_;
added EXPERIMENTAL reserved_...
Yuki Kimoto authored on 2011-03-30
746

            
refactoring select
yuki-kimoto authored on 2010-04-28
747
    # Arguments
cleanup
Yuki Kimoto authored on 2011-03-21
748
    my $table = delete $args{table};
added table not specified ex...
Yuki Kimoto authored on 2011-01-21
749
    my $tables = ref $table eq 'ARRAY' ? $table
750
               : defined $table ? [$table]
751
               : [];
cleanup
Yuki Kimoto authored on 2011-03-21
752
    my $columns   = delete $args{column};
753
    my $where     = delete $args{where} || {};
754
    my $append    = delete $args{append};
755
    my $join      = delete $args{join} || [];
cleanup
Yuki Kimoto authored on 2011-04-25
756
    croak qq{"join" must be array reference } . _subname
- added experimental DBIx::C...
Yuki Kimoto authored on 2011-03-08
757
      unless ref $join eq 'ARRAY';
cleanup
Yuki Kimoto authored on 2011-03-21
758
    my $relation = delete $args{relation};
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
759
    warn "select() relation option is DEPRECATED!"
added warnings
Yuki Kimoto authored on 2011-06-07
760
      if $relation;
DEPRECATED select() param op...
Yuki Kimoto authored on 2011-04-25
761
    my $param = delete $args{param} || {}; # DEPRECATED!
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
762
    warn "select() param option is DEPRECATED!"
DEPRECATED select() param op...
Yuki Kimoto authored on 2011-04-25
763
      if keys %$param;
764
    my $where_param = delete $args{where_param} || $param || {};
added EXPERIMENTAL select() ...
Yuki Kimoto authored on 2011-04-19
765
    my $wrap = delete $args{wrap};
select_at is DEPRECATED! use...
Yuki Kimoto authored on 2011-06-08
766
    my $id = delete $args{id};
767
    my $primary_key = delete $args{primary_key};
768
    croak "update method primary_key option " .
769
          "must be specified when id is specified " . _subname
770
      if defined $id && !defined $primary_key;
771
    $primary_key = [$primary_key] unless ref $primary_key eq 'ARRAY';
added EXPERIMENTAL select pr...
Yuki Kimoto authored on 2011-06-13
772
    my $prefix = delete $args{prefix};
select_at is DEPRECATED! use...
Yuki Kimoto authored on 2011-06-08
773
    
cleanup
Yuki Kimoto authored on 2011-03-09
774
    # Add relation tables(DEPRECATED!);
cleanup
Yuki Kimoto authored on 2011-03-21
775
    $self->_add_relation_table($tables, $relation);
packaging one directory
yuki-kimoto authored on 2009-11-16
776
    
cleanup
Yuki Kimoto authored on 2011-04-02
777
    # Select statement
cleanup
Yuki Kimoto authored on 2011-01-27
778
    my @sql;
779
    push @sql, 'select';
packaging one directory
yuki-kimoto authored on 2009-11-16
780
    
added EXPERIMENTAL select pr...
Yuki Kimoto authored on 2011-06-13
781
    # Prefix
782
    push @sql, $prefix if defined $prefix;
783
    
removed EXPERIMETNAL select(...
Yuki Kimoto authored on 2011-04-01
784
    # Column clause
cleanup
Yuki Kimoto authored on 2011-03-30
785
    if ($columns) {
- select() column option can...
Yuki Kimoto authored on 2011-06-07
786
        $columns = [$columns] unless ref $columns eq 'ARRAY';
removed EXPERIMETNAL select(...
Yuki Kimoto authored on 2011-04-01
787
        foreach my $column (@$columns) {
- select() column option can...
Yuki Kimoto authored on 2011-06-08
788
            if (ref $column eq 'HASH') {
EXPERIMTANL column method th...
Yuki Kimoto authored on 2011-06-13
789
                $column = $self->column(%$column) if ref $column eq 'HASH';
- select() column option can...
Yuki Kimoto authored on 2011-06-08
790
            }
791
            elsif (ref $column eq 'ARRAY') {
- select method column optio...
Yuki Kimoto authored on 2011-07-11
792
                if (@$column == 3 && $column->[1] eq 'as') {
793
                    warn "[COLUMN, as => ALIAS] is DEPRECATED! use [COLUMN => ALIAS]";
794
                    splice @$column, 1, 1;
795
                }
796
                
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
797
                $column = join(' ', $column->[0], 'as', $self->_q($column->[1]));
- select() column option can...
Yuki Kimoto authored on 2011-06-08
798
            }
cleanup
Yuki Kimoto authored on 2011-04-02
799
            unshift @$tables, @{$self->_search_tables($column)};
removed EXPERIMETNAL select(...
Yuki Kimoto authored on 2011-04-01
800
            push @sql, ($column, ',');
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
801
        }
removed EXPERIMETNAL select(...
Yuki Kimoto authored on 2011-04-01
802
        pop @sql if $sql[-1] eq ',';
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
803
    }
804
    else { push @sql, '*' }
805
    
806
    # Table
cleanup
Yuki Kimoto authored on 2011-03-30
807
    push @sql, 'from';
808
    if ($relation) {
809
        my $found = {};
810
        foreach my $table (@$tables) {
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
811
            push @sql, ($self->_q($table), ',') unless $found->{$table};
cleanup
Yuki Kimoto authored on 2011-03-30
812
            $found->{$table} = 1;
- added EXPERIMENTAL DBIx::C...
Yuki Kimoto authored on 2011-03-14
813
        }
packaging one directory
yuki-kimoto authored on 2009-11-16
814
    }
cleanup
Yuki Kimoto authored on 2011-03-30
815
    else {
816
        my $main_table = $tables->[-1] || '';
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
817
        push @sql, $self->_q($main_table);
cleanup
Yuki Kimoto authored on 2011-03-30
818
    }
819
    pop @sql if ($sql[-1] || '') eq ',';
cleanup
Yuki Kimoto authored on 2011-04-25
820
    croak "Not found table name " . _subname
improved error messages
Yuki Kimoto authored on 2011-04-18
821
      unless $tables->[-1];
cleanup
Yuki Kimoto authored on 2011-04-01
822

            
cleanup
Yuki Kimoto authored on 2011-04-02
823
    # Add tables in parameter
DEPRECATED select() param op...
Yuki Kimoto authored on 2011-04-25
824
    unshift @$tables,
825
            @{$self->_search_tables(join(' ', keys %$where_param) || '')};
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
826
    
select() where can't receive...
Yuki Kimoto authored on 2011-01-27
827
    # Where
select, update, and delete w...
Yuki Kimoto authored on 2011-04-25
828
    my $where_clause = '';
fixed small insert, update, ...
Yuki Kimoto authored on 2011-06-21
829
    $where = $self->_create_param_from_id($id, $primary_key) if defined $id;
updated pod
Yuki Kimoto authored on 2011-06-21
830
    if (ref $where eq 'ARRAY' && !ref $where->[0]) {
831
        $where_clause = "where " . $where->[0];
832
        $where_param = $where->[1];
833
    }
834
    elsif (ref $where) {
cleanup
Yuki Kimoto authored on 2011-04-25
835
        $where = $self->_where_to_obj($where);
DEPRECATED select() param op...
Yuki Kimoto authored on 2011-04-25
836
        $where_param = keys %$where_param
837
                     ? $self->merge_param($where_param, $where->param)
838
                     : $where->param;
cleanup
Yuki Kimoto authored on 2011-04-25
839
        
840
        # String where
841
        $where_clause = $where->to_string;
842
    }
select, update, and delete w...
Yuki Kimoto authored on 2011-04-25
843
    elsif ($where) { $where_clause = "where $where" }
remove experimental DBIx::Cu...
Yuki Kimoto authored on 2011-03-08
844
    
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
845
    # Add table names in where clause
cleanup
Yuki Kimoto authored on 2011-04-02
846
    unshift @$tables, @{$self->_search_tables($where_clause)};
remove experimental DBIx::Cu...
Yuki Kimoto authored on 2011-03-08
847
    
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
848
    # Push join
849
    $self->_push_join(\@sql, $join, $tables);
remove experimental DBIx::Cu...
Yuki Kimoto authored on 2011-03-08
850
    
cleanup
Yuki Kimoto authored on 2011-03-09
851
    # Add where clause
cleanup
Yuki Kimoto authored on 2011-04-02
852
    push @sql, $where_clause;
select() where can't receive...
Yuki Kimoto authored on 2011-01-27
853
    
cleanup
Yuki Kimoto authored on 2011-03-08
854
    # Relation(DEPRECATED!);
cleanup
Yuki Kimoto authored on 2011-04-02
855
    $self->_push_relation(\@sql, $tables, $relation, $where_clause eq '' ? 1 : 0);
cleanup
Yuki Kimoto authored on 2011-03-08
856
    
cleanup
Yuki Kimoto authored on 2011-04-02
857
    # Append
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
858
    push @sql, $append if defined $append;
cleanup
Yuki Kimoto authored on 2011-01-27
859
    
added EXPERIMENTAL select() ...
Yuki Kimoto authored on 2011-04-19
860
    # Wrap
861
    if ($wrap) {
cleanup
Yuki Kimoto authored on 2011-04-25
862
        croak "wrap option must be array refrence " . _subname
added EXPERIMENTAL select() ...
Yuki Kimoto authored on 2011-04-19
863
          unless ref $wrap eq 'ARRAY';
864
        unshift @sql, $wrap->[0];
865
        push @sql, $wrap->[1];
866
    }
867
    
cleanup
Yuki Kimoto authored on 2011-01-27
868
    # SQL
869
    my $sql = join (' ', @sql);
packaging one directory
yuki-kimoto authored on 2009-11-16
870
    
871
    # Execute query
updated pod
Yuki Kimoto authored on 2011-06-21
872
    my $result = $self->execute($sql, $where_param, table => $tables, %args);
packaging one directory
yuki-kimoto authored on 2009-11-16
873
    
874
    return $result;
875
}
876

            
added EXPERIMETNAL separator...
Yuki Kimoto authored on 2011-06-13
877
sub separator {
878
    my $self = shift;
879
    
880
    if (@_) {
881
        my $separator = $_[0] || '';
882
        croak qq{Separator must be "." or "__" or "-" } . _subname
883
          unless $separator eq '.' || $separator eq '__'
884
              || $separator eq '-';
885
        
886
        $self->{separator} = $separator;
887
    
888
        return $self;
889
    }
890
    return $self->{separator} ||= '.';
891
}
892

            
add experimental setup_model...
Yuki Kimoto authored on 2011-02-21
893
sub setup_model {
894
    my $self = shift;
895
    
cleanup
Yuki Kimoto authored on 2011-04-02
896
    # Setup model
add experimental setup_model...
Yuki Kimoto authored on 2011-02-21
897
    $self->each_column(
898
        sub {
899
            my ($self, $table, $column, $column_info) = @_;
900
            if (my $model = $self->models->{$table}) {
901
                push @{$model->columns}, $column;
902
            }
903
        }
904
    );
add experimental DBIx::Custo...
Yuki Kimoto authored on 2011-02-22
905
    return $self;
add experimental setup_model...
Yuki Kimoto authored on 2011-02-21
906
}
907

            
simplify type_rule
Yuki Kimoto authored on 2011-06-10
908
sub available_data_type {
909
    my $self = shift;
910
    
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
911
    my $data_types = '';
simplify type_rule
Yuki Kimoto authored on 2011-06-10
912
    foreach my $i (-1000 .. 1000) {
913
         my $type_info = $self->dbh->type_info($i);
914
         my $data_type = $type_info->{DATA_TYPE};
915
         my $type_name = $type_info->{TYPE_NAME};
916
         $data_types .= "$data_type ($type_name)\n"
917
           if defined $data_type;
918
    }
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
919
    return "Data Type maybe equal to Type Name" unless $data_types;
920
    $data_types = "Data Type (Type name)\n" . $data_types;
simplify type_rule
Yuki Kimoto authored on 2011-06-10
921
    return $data_types;
922
}
923

            
added EXPERIMENTAL available...
Yuki Kimoto authored on 2011-06-14
924
sub available_type_name {
925
    my $self = shift;
926
    
927
    # Type Names
928
    my $type_names = {};
929
    $self->each_column(sub {
930
        my ($self, $table, $column, $column_info) = @_;
931
        $type_names->{$column_info->{TYPE_NAME}} = 1
932
          if $column_info->{TYPE_NAME};
933
    });
934
    my @output = sort keys %$type_names;
935
    unshift @output, "Type Name";
936
    return join "\n", @output;
937
}
938

            
added type_rule method and f...
Yuki Kimoto authored on 2011-06-09
939
sub type_rule {
940
    my $self = shift;
941
    
942
    if (@_) {
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
943
        my $type_rule = ref $_[0] eq 'HASH' ? $_[0] : {@_};
fixed bug that type_rule fro...
Yuki Kimoto authored on 2011-06-13
944
        
945
        # Into
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
946
        foreach my $i (1 .. 2) {
947
            my $into = "into$i";
948
            $type_rule->{$into} = _array_to_hash($type_rule->{$into});
949
            $self->{type_rule} = $type_rule;
950
            $self->{"_$into"} = {};
951
            foreach my $type_name (keys %{$type_rule->{$into} || {}}) {
952
                croak qq{type name of $into section must be lower case}
953
                  if $type_name =~ /[A-Z]/;
954
            }
955
            $self->each_column(sub {
956
                my ($dbi, $table, $column, $column_info) = @_;
957
                
958
                my $type_name = lc $column_info->{TYPE_NAME};
959
                if ($type_rule->{$into} &&
960
                    (my $filter = $type_rule->{$into}->{$type_name}))
type_rule can receive filter...
Yuki Kimoto authored on 2011-06-12
961
                {
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
962
                    return unless exists $type_rule->{$into}->{$type_name};
963
                    if  (defined $filter && ref $filter ne 'CODE') 
964
                    {
965
                        my $fname = $filter;
966
                        croak qq{Filter "$fname" is not registered" } . _subname
967
                          unless exists $self->filters->{$fname};
968
                        
969
                        $filter = $self->filters->{$fname};
970
                    }
971

            
micro optimization
Yuki Kimoto authored on 2011-07-30
972
                    $self->{"_$into"}{key}{$table}{$column} = $filter;
973
                    $self->{"_$into"}{dot}{"$table.$column"} = $filter;
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
974
                }
975
            });
976
        }
977

            
978
        # From
979
        foreach my $i (1 .. 2) {
980
            $type_rule->{"from$i"} = _array_to_hash($type_rule->{"from$i"});
981
            foreach my $data_type (keys %{$type_rule->{"from$i"} || {}}) {
982
                croak qq{data type of from$i section must be lower case or number}
983
                  if $data_type =~ /[A-Z]/;
984
                my $fname = $type_rule->{"from$i"}{$data_type};
985
                if (defined $fname && ref $fname ne 'CODE') {
type_rule can receive filter...
Yuki Kimoto authored on 2011-06-12
986
                    croak qq{Filter "$fname" is not registered" } . _subname
987
                      unless exists $self->filters->{$fname};
988
                    
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
989
                    $type_rule->{"from$i"}{$data_type} = $self->filters->{$fname};
type_rule can receive filter...
Yuki Kimoto authored on 2011-06-12
990
                }
fixed bug that type_rule fro...
Yuki Kimoto authored on 2011-06-13
991
            }
992
        }
993
        
added type_rule method and f...
Yuki Kimoto authored on 2011-06-09
994
        return $self;
995
    }
996
    
997
    return $self->{type_rule} || {};
998
}
999

            
cleanup
yuki-kimoto authored on 2010-10-17
1000
sub update {
- insert, insert_at, update,...
Yuki Kimoto authored on 2011-06-08
1001
    my $self = shift;
added EXPERIMENTAL reserved_...
Yuki Kimoto authored on 2011-03-30
1002

            
cleanup
yuki-kimoto authored on 2010-10-17
1003
    # Arguments
- insert, insert_at, update,...
Yuki Kimoto authored on 2011-06-08
1004
    my $param;
1005
    $param = shift if @_ % 2;
1006
    my %args = @_;
cleanup
Yuki Kimoto authored on 2011-03-21
1007
    my $table = delete $args{table} || '';
cleanup
Yuki Kimoto authored on 2011-04-25
1008
    croak qq{"table" option must be specified } . _subname
improved error messages
Yuki Kimoto authored on 2011-04-18
1009
      unless $table;
- insert, insert_at, update,...
Yuki Kimoto authored on 2011-06-08
1010
    my $p = delete $args{param} || {};
1011
    $param  ||= $p;
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
1012
    my $where = delete $args{where} || {};
1013
    my $where_param = delete $args{where_param} || {};
1014
    my $append = delete $args{append} || '';
cleanup
Yuki Kimoto authored on 2011-03-21
1015
    my $allow_update_all = delete $args{allow_update_all};
cleanup
Yuki Kimoto authored on 2011-06-08
1016
    my $id = delete $args{id};
1017
    my $primary_key = delete $args{primary_key};
1018
    croak "update method primary_key option " .
1019
          "must be specified when id is specified " . _subname
1020
      if defined $id && !defined $primary_key;
1021
    $primary_key = [$primary_key] unless ref $primary_key eq 'ARRAY';
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
1022
    my $prefix = delete $args{prefix};
update_at is DEPRECATED! use...
Yuki Kimoto authored on 2011-06-08
1023

            
cleanup
yuki-kimoto authored on 2010-10-17
1024
    # Update clause
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
1025
    my $update_clause = $self->update_param($param);
improved delete() and update...
Yuki Kimoto authored on 2011-01-26
1026

            
1027
    # Where
fixed small insert, update, ...
Yuki Kimoto authored on 2011-06-21
1028
    $where = $self->_create_param_from_id($id, $primary_key) if defined $id;
select, update, and delete w...
Yuki Kimoto authored on 2011-04-25
1029
    my $where_clause = '';
updated pod
Yuki Kimoto authored on 2011-06-21
1030
    if (ref $where eq 'ARRAY' && !ref $where->[0]) {
1031
        $where_clause = "where " . $where->[0];
1032
        $where_param = $where->[1];
1033
    }
1034
    elsif (ref $where) {
select, update, and delete w...
Yuki Kimoto authored on 2011-04-25
1035
        $where = $self->_where_to_obj($where);
DEPRECATED select() param op...
Yuki Kimoto authored on 2011-04-25
1036
        $where_param = keys %$where_param
1037
                     ? $self->merge_param($where_param, $where->param)
1038
                     : $where->param;
select, update, and delete w...
Yuki Kimoto authored on 2011-04-25
1039
        
1040
        # String where
1041
        $where_clause = $where->to_string;
1042
    }
1043
    elsif ($where) { $where_clause = "where $where" }
cleanup
Yuki Kimoto authored on 2011-04-25
1044
    croak qq{"where" must be specified } . _subname
cleanup
Yuki Kimoto authored on 2011-04-02
1045
      if "$where_clause" eq '' && !$allow_update_all;
removed reconnect method
yuki-kimoto authored on 2010-05-28
1046
    
DEPRECATED select() param op...
Yuki Kimoto authored on 2011-04-25
1047
    # Merge param
1048
    $param = $self->merge_param($param, $where_param) if keys %$where_param;
1049
    
cleanup
Yuki Kimoto authored on 2011-04-02
1050
    # Update statement
cleanup
Yuki Kimoto authored on 2011-01-27
1051
    my @sql;
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
1052
    push @sql, "update";
1053
    push @sql, $prefix if defined $prefix;
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
1054
    push @sql, $self->_q($table) . " $update_clause $where_clause";
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
1055
    push @sql, $append if defined $append;
removed reconnect method
yuki-kimoto authored on 2010-05-28
1056
    
cleanup
Yuki Kimoto authored on 2011-01-27
1057
    # SQL
1058
    my $sql = join(' ', @sql);
1059
    
cleanup
yuki-kimoto authored on 2010-10-17
1060
    # Execute query
updated pod
Yuki Kimoto authored on 2011-06-21
1061
    return $self->execute($sql, $param, table => $table, %args);
removed reconnect method
yuki-kimoto authored on 2010-05-28
1062
}
1063

            
cleanup
yuki-kimoto authored on 2010-10-17
1064
sub update_all { shift->update(allow_update_all => 1, @_) };
1065

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
1066
sub update_param {
added EXPERIMENTAL updat_par...
Yuki Kimoto authored on 2011-03-30
1067
    my ($self, $param, $opt) = @_;
1068
    
cleanup
Yuki Kimoto authored on 2011-04-02
1069
    # Create update parameter tag
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
1070
    my $tag = $self->assign_param($param);
added EXPERIMENTAL assign_ta...
Yuki Kimoto authored on 2011-04-26
1071
    $tag = "set $tag" unless $opt->{no_set};
1072

            
cleanup
Yuki Kimoto authored on 2011-04-02
1073
    return $tag;
remove experimental DBIx::Cu...
Yuki Kimoto authored on 2011-03-08
1074
}
1075

            
cleanup
Yuki Kimoto authored on 2011-01-25
1076
sub where {
select() where can't receive...
Yuki Kimoto authored on 2011-01-27
1077
    my $self = shift;
cleanup
Yuki Kimoto authored on 2011-04-02
1078
    
1079
    # Create where
select() where can't receive...
Yuki Kimoto authored on 2011-01-27
1080
    return DBIx::Custom::Where->new(
1081
        query_builder => $self->query_builder,
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1082
        safety_character => $self->safety_character,
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1083
        quote => $self->_quote,
cleanup
Yuki Kimoto authored on 2011-03-09
1084
        @_
select() where can't receive...
Yuki Kimoto authored on 2011-01-27
1085
    );
cleanup
Yuki Kimoto authored on 2011-01-25
1086
}
added experimental DBIx::Cus...
Yuki Kimoto authored on 2011-01-18
1087

            
updated pod
Yuki Kimoto authored on 2011-06-21
1088
sub _create_query {
cleanup
Yuki Kimoto authored on 2011-06-13
1089
    
updated pod
Yuki Kimoto authored on 2011-06-21
1090
    my ($self, $source) = @_;
cleanup
Yuki Kimoto authored on 2011-06-13
1091
    
updated pod
Yuki Kimoto authored on 2011-06-21
1092
    # Cache
1093
    my $cache = $self->cache;
1094
    
1095
    # Query
1096
    my $query;
1097
    
1098
    # Get cached query
1099
    if ($cache) {
cleanup
Yuki Kimoto authored on 2011-06-13
1100
        
updated pod
Yuki Kimoto authored on 2011-06-21
1101
        # Get query
1102
        my $q = $self->cache_method->($self, $source);
cleanup
Yuki Kimoto authored on 2011-06-13
1103
        
updated pod
Yuki Kimoto authored on 2011-06-21
1104
        # Create query
1105
        if ($q) {
1106
            $query = DBIx::Custom::Query->new($q);
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
1107
            $query->{filters} = $self->filters;
cleanup
Yuki Kimoto authored on 2011-06-13
1108
        }
updated pod
Yuki Kimoto authored on 2011-06-21
1109
    }
1110
    
1111
    # Create query
1112
    unless ($query) {
1113

            
1114
        # Create query
1115
        my $builder = $self->query_builder;
added tag_parse attribute
Yuki Kimoto authored on 2011-06-28
1116
        $builder->{_tag_parse} = $self->tag_parse;
cleanup
Yuki Kimoto authored on 2011-07-29
1117
        $builder->safety_character($self->safety_character);
updated pod
Yuki Kimoto authored on 2011-06-21
1118
        $query = $builder->build_query($source);
1119

            
1120
        # Remove reserved word quote
1121
        if (my $q = $self->_quote) {
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
1122
            $q = quotemeta($q);
1123
            $_ =~ s/[$q]//g for @{$query->columns}
cleanup
Yuki Kimoto authored on 2011-06-13
1124
        }
updated pod
Yuki Kimoto authored on 2011-06-21
1125

            
1126
        # Save query to cache
1127
        $self->cache_method->(
1128
            $self, $source,
1129
            {
1130
                sql     => $query->sql, 
1131
                columns => $query->columns,
DBIx::Custom::Query tables a...
Yuki Kimoto authored on 2011-07-30
1132
                tables  => $query->{tables} || []
updated pod
Yuki Kimoto authored on 2011-06-21
1133
            }
1134
        ) if $cache;
cleanup
Yuki Kimoto authored on 2011-06-13
1135
    }
1136
    
added EXPERIMENTAL last_sql ...
Yuki Kimoto authored on 2011-07-11
1137
    # Save sql
1138
    $self->last_sql($query->sql);
1139
    
updated pod
Yuki Kimoto authored on 2011-06-21
1140
    # Prepare statement handle
1141
    my $sth;
1142
    eval { $sth = $self->dbh->prepare($query->{sql})};
1143
    
1144
    if ($@) {
1145
        $self->_croak($@, qq{. Following SQL is executed.\n}
1146
                        . qq{$query->{sql}\n} . _subname);
1147
    }
1148
    
1149
    # Set statement handle
1150
    $query->sth($sth);
1151
    
1152
    # Set filters
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
1153
    $query->{filters} = $self->filters;
updated pod
Yuki Kimoto authored on 2011-06-21
1154
    
1155
    return $query;
cleanup
Yuki Kimoto authored on 2011-06-13
1156
}
1157

            
cleanup
Yuki Kimoto authored on 2011-04-02
1158
sub _create_bind_values {
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
1159
    my ($self, $params, $columns, $filter, $type_filters, $bind_type) = @_;
removed reconnect method
yuki-kimoto authored on 2010-05-28
1160
    
cleanup
Yuki Kimoto authored on 2011-04-02
1161
    # Create bind values
- added EXPERIMENTAL type() ...
Yuki Kimoto authored on 2011-03-21
1162
    my $bind = [];
removed reconnect method
yuki-kimoto authored on 2010-05-28
1163
    my $count = {};
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
1164
    my $not_exists = {};
cleanup
Yuki Kimoto authored on 2011-01-12
1165
    foreach my $column (@$columns) {
removed reconnect method
yuki-kimoto authored on 2010-05-28
1166
        
1167
        # Value
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
1168
        my $value;
1169
        if(ref $params->{$column} eq 'ARRAY') {
1170
            my $i = $count->{$column} || 0;
1171
            $i += $not_exists->{$column} || 0;
1172
            my $found;
1173
            for (my $k = $i; $i < @{$params->{$column}}; $k++) {
1174
                if (ref $params->{$column}->[$k] eq 'DBIx::Custom::NotExists') {
1175
                    $not_exists->{$column}++;
1176
                }
1177
                else  {
1178
                    $value = $params->{$column}->[$k];
1179
                    $found = 1;
1180
                    last
1181
                }
1182
            }
1183
            next unless $found;
1184
        }
1185
        else { $value = $params->{$column} }
removed reconnect method
yuki-kimoto authored on 2010-05-28
1186
        
cleanup
Yuki Kimoto authored on 2011-01-12
1187
        # Filter
1188
        my $f = $filter->{$column} || $self->{default_out_filter} || '';
separate DBIx::Custom type_r...
Yuki Kimoto authored on 2011-06-15
1189
        $value = $f->($value) if $f;
1190
        
1191
        # Type rule
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
1192
        foreach my $i (1 .. 2) {
1193
            my $type_filter = $type_filters->{$i};
micro optimization
Yuki Kimoto authored on 2011-07-30
1194
            my $tf = $self->{"_into$i"}->{dot}->{$column} || $type_filter->{$column};
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
1195
            $value = $tf->($value) if $tf;
1196
        }
cleanup
kimoto.yuki@gmail.com authored on 2010-12-21
1197
        
separate DBIx::Custom type_r...
Yuki Kimoto authored on 2011-06-15
1198
        # Bind values
DBIx::Custom::Model type att...
Yuki Kimoto authored on 2011-06-17
1199
        push @$bind, {value => $value, bind_type => $bind_type->{$column}};
removed reconnect method
yuki-kimoto authored on 2010-05-28
1200
        
1201
        # Count up 
1202
        $count->{$column}++;
1203
    }
1204
    
- added EXPERIMENTAL type() ...
Yuki Kimoto authored on 2011-03-21
1205
    return $bind;
removed reconnect method
yuki-kimoto authored on 2010-05-28
1206
}
1207

            
cleanup
Yuki Kimoto authored on 2011-06-08
1208
sub _create_param_from_id {
1209
    my ($self, $id, $primary_keys) = @_;
improved error messages
Yuki Kimoto authored on 2011-04-18
1210
    
cleanup
Yuki Kimoto authored on 2011-06-08
1211
    # Create parameter
1212
    my $param = {};
fixed small insert, update, ...
Yuki Kimoto authored on 2011-06-21
1213
    if (defined $id) {
cleanup
Yuki Kimoto authored on 2011-06-08
1214
        $id = [$id] unless ref $id;
1215
        croak qq{"id" must be constant value or array reference}
improved error messages
Yuki Kimoto authored on 2011-04-18
1216
            . " (" . (caller 1)[3] . ")"
cleanup
Yuki Kimoto authored on 2011-06-08
1217
          unless !ref $id || ref $id eq 'ARRAY';
1218
        croak qq{"id" must contain values same count as primary key}
improved error messages
Yuki Kimoto authored on 2011-04-18
1219
            . " (" . (caller 1)[3] . ")"
cleanup
Yuki Kimoto authored on 2011-06-08
1220
          unless @$primary_keys eq @$id;
improved error messages
Yuki Kimoto authored on 2011-04-18
1221
        for(my $i = 0; $i < @$primary_keys; $i ++) {
cleanup
Yuki Kimoto authored on 2011-06-08
1222
           $param->{$primary_keys->[$i]} = $id->[$i];
improved error messages
Yuki Kimoto authored on 2011-04-18
1223
        }
1224
    }
1225
    
cleanup
Yuki Kimoto authored on 2011-06-08
1226
    return $param;
improved error messages
Yuki Kimoto authored on 2011-04-18
1227
}
1228

            
EXPERIMETAL fork safety impl...
Yuki Kimoto authored on 2011-03-12
1229
sub _connect {
1230
    my $self = shift;
1231
    
1232
    # Attributes
added warnings
Yuki Kimoto authored on 2011-06-07
1233
    my $dsn = $self->data_source;
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
1234
    warn "data_source is DEPRECATED!\n"
fixed bug that data_source D...
Yuki Kimoto authored on 2011-06-13
1235
      if $dsn;
added warnings
Yuki Kimoto authored on 2011-06-07
1236
    $dsn ||= $self->dsn;
data_source is DEPRECATED! I...
Yuki Kimoto authored on 2011-06-06
1237
    croak qq{"dsn" must be specified } . _subname
1238
      unless $dsn;
EXPERIMETAL fork safety impl...
Yuki Kimoto authored on 2011-03-12
1239
    my $user        = $self->user;
1240
    my $password    = $self->password;
1241
    my $dbi_option = {%{$self->dbi_options}, %{$self->dbi_option}};
added warnings
Yuki Kimoto authored on 2011-06-07
1242
    warn "dbi_options is DEPRECATED! use dbi_option instead\n"
1243
      if keys %{$self->dbi_options};
EXPERIMETAL fork safety impl...
Yuki Kimoto authored on 2011-03-12
1244
    
1245
    # Connect
1246
    my $dbh = eval {DBI->connect(
data_source is DEPRECATED! I...
Yuki Kimoto authored on 2011-06-06
1247
        $dsn,
EXPERIMETAL fork safety impl...
Yuki Kimoto authored on 2011-03-12
1248
        $user,
1249
        $password,
1250
        {
1251
            %{$self->default_dbi_option},
1252
            %$dbi_option
1253
        }
1254
    )};
1255
    
1256
    # Connect error
cleanup
Yuki Kimoto authored on 2011-04-25
1257
    croak "$@ " . _subname if $@;
EXPERIMETAL fork safety impl...
Yuki Kimoto authored on 2011-03-12
1258
    
1259
    return $dbh;
1260
}
1261

            
cleanup
yuki-kimoto authored on 2010-10-17
1262
sub _croak {
1263
    my ($self, $error, $append) = @_;
cleanup
Yuki Kimoto authored on 2011-04-02
1264
    
1265
    # Append
cleanup
yuki-kimoto authored on 2010-10-17
1266
    $append ||= "";
1267
    
1268
    # Verbose
1269
    if ($Carp::Verbose) { croak $error }
1270
    
1271
    # Not verbose
1272
    else {
1273
        
1274
        # Remove line and module infromation
1275
        my $at_pos = rindex($error, ' at ');
1276
        $error = substr($error, 0, $at_pos);
1277
        $error =~ s/\s+$//;
1278
        croak "$error$append";
1279
    }
1280
}
1281

            
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
1282
sub _need_tables {
1283
    my ($self, $tree, $need_tables, $tables) = @_;
1284
    
cleanup
Yuki Kimoto authored on 2011-04-02
1285
    # Get needed tables
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
1286
    foreach my $table (@$tables) {
1287
        if ($tree->{$table}) {
1288
            $need_tables->{$table} = 1;
1289
            $self->_need_tables($tree, $need_tables, [$tree->{$table}{parent}])
1290
        }
1291
    }
1292
}
1293

            
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
1294
sub _push_join {
1295
    my ($self, $sql, $join, $join_tables) = @_;
1296
    
cleanup
Yuki Kimoto authored on 2011-04-02
1297
    # No join
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
1298
    return unless @$join;
1299
    
cleanup
Yuki Kimoto authored on 2011-04-02
1300
    # Push join clause
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
1301
    my $tree = {};
1302
    for (my $i = 0; $i < @$join; $i++) {
1303
        
cleanup
Yuki Kimoto authored on 2011-07-28
1304
        # Arrange
added join new syntax
Yuki Kimoto authored on 2011-07-28
1305
        my $join_clause;;
1306
        my $option;
1307
        if (ref $join->[$i] eq 'HASH') {
1308
            $join_clause = $join->[$i]->{clause};
1309
            $option = {table => $join->[$i]->{table}};
1310
        }
1311
        else {
1312
            $join_clause = $join->[$i];
1313
            $option = {};
1314
        };
cleanup
Yuki Kimoto authored on 2011-07-28
1315

            
1316
        # Find tables in join clause
added join new syntax
Yuki Kimoto authored on 2011-07-28
1317
        my $table1;
1318
        my $table2;
1319
        if (my $table = $option->{table}) {
1320
            $table1 = $table->[0];
1321
            $table2 = $table->[1];
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
1322
        }
cleanup
Yuki Kimoto authored on 2011-07-28
1323
        else {
1324
            my $q = $self->_quote;
1325
            my $j_clause = (split /\s+on\s+/, $join_clause)[-1];
1326
            $j_clause =~ s/'.+?'//g;
1327
            my $q_re = quotemeta($q);
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
1328
            $j_clause =~ s/[$q_re]//g;
cleanup
Yuki Kimoto authored on 2011-07-28
1329
            my $c = $self->safety_character;
1330
            my $join_re = qr/(?:^|\s)($c+)\.$c+\s+=\s+($c+)\.$c+/;
1331
            if ($j_clause =~ $join_re) {
1332
                $table1 = $1;
1333
                $table2 = $2;
1334
            }
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
1335
        }
added join new syntax
Yuki Kimoto authored on 2011-07-28
1336
        croak qq{join clause must have two table name after "on" keyword. } .
1337
              qq{"$join_clause" is passed }  . _subname
1338
          unless defined $table1 && defined $table2;
1339
        croak qq{right side table of "$join_clause" must be unique }
1340
            . _subname
1341
          if exists $tree->{$table2};
1342
        croak qq{Same table "$table1" is specified} . _subname
1343
          if $table1 eq $table2;
1344
        $tree->{$table2}
1345
          = {position => $i, parent => $table1, join => $join_clause};
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
1346
    }
1347
    
cleanup
Yuki Kimoto authored on 2011-04-02
1348
    # Search need tables
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
1349
    my $need_tables = {};
1350
    $self->_need_tables($tree, $need_tables, $join_tables);
1351
    my @need_tables = sort { $tree->{$a}{position} <=> $tree->{$b}{position} } keys %$need_tables;
cleanup
Yuki Kimoto authored on 2011-04-02
1352
    
1353
    # Add join clause
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
1354
    foreach my $need_table (@need_tables) {
1355
        push @$sql, $tree->{$need_table}{join};
1356
    }
1357
}
cleanup
Yuki Kimoto authored on 2011-03-08
1358

            
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1359
sub _quote {
1360
    my $self = shift;
1361
    
1362
    return defined $self->reserved_word_quote ? $self->reserved_word_quote
1363
         : defined $self->quote ? $self->quote
1364
         : '';
1365
}
1366

            
cleanup
Yuki Kimoto authored on 2011-07-29
1367
sub _q {
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
1368
    my ($self, $value) = @_;
cleanup
Yuki Kimoto authored on 2011-07-29
1369
    
1370
    my $quote = $self->_quote;
1371
    my $q = substr($quote, 0, 1) || '';
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
1372
    my $p;
1373
    if (defined $quote && length $quote > 1) {
1374
        $p = substr($quote, 1, 1);
1375
    }
1376
    else { $p = $q }
cleanup
Yuki Kimoto authored on 2011-07-29
1377
    
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
1378
    return "$q$value$p";
cleanup
Yuki Kimoto authored on 2011-07-29
1379
}
1380

            
cleanup
Yuki Kimoto authored on 2011-04-02
1381
sub _remove_duplicate_table {
1382
    my ($self, $tables, $main_table) = @_;
1383
    
1384
    # Remove duplicate table
1385
    my %tables = map {defined $_ ? ($_ => 1) : ()} @$tables;
1386
    delete $tables{$main_table} if $main_table;
1387
    
micro optimization
Yuki Kimoto authored on 2011-07-30
1388
    my $new_tables = [keys %tables, $main_table ? $main_table : ()];
1389
    if (my $q = $self->_quote) {
1390
        $q = quotemeta($q);
1391
        $_ =~ s/[$q]//g for @$new_tables;
1392
    }
1393

            
1394
    return $new_tables;
cleanup
Yuki Kimoto authored on 2011-04-02
1395
}
1396

            
cleanup
Yuki Kimoto authored on 2011-04-02
1397
sub _search_tables {
cleanup
Yuki Kimoto authored on 2011-04-02
1398
    my ($self, $source) = @_;
1399
    
cleanup
Yuki Kimoto authored on 2011-04-02
1400
    # Search tables
cleanup
Yuki Kimoto authored on 2011-04-02
1401
    my $tables = [];
1402
    my $safety_character = $self->safety_character;
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1403
    my $q = $self->_quote;
cleanup
Yuki Kimoto authored on 2011-04-02
1404
    my $q_re = quotemeta($q);
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
1405
    my $quoted_safety_character_re = $self->_q("?([$safety_character]+)");
1406
    my $table_re = $q ? qr/(?:^|[^$safety_character])$quoted_safety_character_re?\./
improved table search in col...
Yuki Kimoto authored on 2011-04-12
1407
                      : qr/(?:^|[^$safety_character])([$safety_character]+)\./;
cleanup
Yuki Kimoto authored on 2011-04-02
1408
    while ($source =~ /$table_re/g) {
1409
        push @$tables, $1;
1410
    }
1411
    
1412
    return $tables;
1413
}
1414

            
cleanup
Yuki Kimoto authored on 2011-04-02
1415
sub _where_to_obj {
where can recieve array refr...
Yuki Kimoto authored on 2011-03-24
1416
    my ($self, $where) = @_;
1417
    
cleanup
Yuki Kimoto authored on 2011-04-02
1418
    my $obj;
1419
    
1420
    # Hash
where can recieve array refr...
Yuki Kimoto authored on 2011-03-24
1421
    if (ref $where eq 'HASH') {
1422
        my $clause = ['and'];
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1423
        my $q = $self->_quote;
added EXPERIMENTAL reserved_...
Yuki Kimoto authored on 2011-03-30
1424
        foreach my $column (keys %$where) {
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
1425
            my $column_quote = $self->_q($column);
1426
            $column_quote =~ s/\./$self->_q(".")/e;
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
1427
            push @$clause, "$column_quote = :$column" for keys %$where;
added EXPERIMENTAL reserved_...
Yuki Kimoto authored on 2011-03-30
1428
        }
cleanup
Yuki Kimoto authored on 2011-04-02
1429
        $obj = $self->where(clause => $clause, param => $where);
where can recieve array refr...
Yuki Kimoto authored on 2011-03-24
1430
    }
cleanup
Yuki Kimoto authored on 2011-04-02
1431
    
1432
    # DBIx::Custom::Where object
where can recieve array refr...
Yuki Kimoto authored on 2011-03-24
1433
    elsif (ref $where eq 'DBIx::Custom::Where') {
cleanup
Yuki Kimoto authored on 2011-04-02
1434
        $obj = $where;
where can recieve array refr...
Yuki Kimoto authored on 2011-03-24
1435
    }
cleanup
Yuki Kimoto authored on 2011-04-02
1436
    
updated pod
Yuki Kimoto authored on 2011-06-21
1437
    # Array
where can recieve array refr...
Yuki Kimoto authored on 2011-03-24
1438
    elsif (ref $where eq 'ARRAY') {
cleanup
Yuki Kimoto authored on 2011-04-02
1439
        $obj = $self->where(
where can recieve array refr...
Yuki Kimoto authored on 2011-03-24
1440
            clause => $where->[0],
1441
            param  => $where->[1]
1442
        );
1443
    }
1444
    
cleanup
Yuki Kimoto authored on 2011-04-02
1445
    # Check where argument
improved error messages
Yuki Kimoto authored on 2011-04-18
1446
    croak qq{"where" must be hash reference or DBIx::Custom::Where object}
DBIx::Custom::Model type att...
Yuki Kimoto authored on 2011-06-17
1447
        . qq{or array reference, which contains where clause and parameter}
cleanup
Yuki Kimoto authored on 2011-04-25
1448
        . _subname
cleanup
Yuki Kimoto authored on 2011-04-02
1449
      unless ref $obj eq 'DBIx::Custom::Where';
where can recieve array refr...
Yuki Kimoto authored on 2011-03-24
1450
    
cleanup
Yuki Kimoto authored on 2011-04-02
1451
    return $obj;
where can recieve array refr...
Yuki Kimoto authored on 2011-03-24
1452
}
1453

            
updated pod
Yuki Kimoto authored on 2011-06-21
1454
sub _apply_filter {
1455
    my ($self, $table, @cinfos) = @_;
1456

            
1457
    # Initialize filters
1458
    $self->{filter} ||= {};
micro optimization
Yuki Kimoto authored on 2011-07-30
1459
    $self->{filter}{on} = 1;
updated pod
Yuki Kimoto authored on 2011-06-21
1460
    $self->{filter}{out} ||= {};
1461
    $self->{filter}{in} ||= {};
1462
    $self->{filter}{end} ||= {};
1463
    
1464
    # Usage
1465
    my $usage = "Usage: \$dbi->apply_filter(" .
1466
                "TABLE, COLUMN1, {in => INFILTER1, out => OUTFILTER1, end => ENDFILTER1}, " .
1467
                "COLUMN2, {in => INFILTER2, out => OUTFILTER2, end => ENDFILTER2}, ...)";
1468
    
1469
    # Apply filter
1470
    for (my $i = 0; $i < @cinfos; $i += 2) {
1471
        
1472
        # Column
1473
        my $column = $cinfos[$i];
1474
        if (ref $column eq 'ARRAY') {
1475
            foreach my $c (@$column) {
1476
                push @cinfos, $c, $cinfos[$i + 1];
1477
            }
1478
            next;
1479
        }
1480
        
1481
        # Filter infomation
1482
        my $finfo = $cinfos[$i + 1] || {};
1483
        croak "$usage (table: $table) " . _subname
1484
          unless  ref $finfo eq 'HASH';
1485
        foreach my $ftype (keys %$finfo) {
1486
            croak "$usage (table: $table) " . _subname
1487
              unless $ftype eq 'in' || $ftype eq 'out' || $ftype eq 'end'; 
1488
        }
1489
        
1490
        # Set filters
1491
        foreach my $way (qw/in out end/) {
1492
        
1493
            # Filter
1494
            my $filter = $finfo->{$way};
1495
            
1496
            # Filter state
1497
            my $state = !exists $finfo->{$way} ? 'not_exists'
1498
                      : !defined $filter        ? 'not_defined'
1499
                      : ref $filter eq 'CODE'   ? 'code'
1500
                      : 'name';
1501
            
1502
            # Filter is not exists
1503
            next if $state eq 'not_exists';
1504
            
1505
            # Check filter name
1506
            croak qq{Filter "$filter" is not registered } . _subname
1507
              if  $state eq 'name'
1508
               && ! exists $self->filters->{$filter};
1509
            
1510
            # Set filter
1511
            my $f = $state eq 'not_defined' ? undef
1512
                  : $state eq 'code'        ? $filter
1513
                  : $self->filters->{$filter};
1514
            $self->{filter}{$way}{$table}{$column} = $f;
1515
            $self->{filter}{$way}{$table}{"$table.$column"} = $f;
1516
            $self->{filter}{$way}{$table}{"${table}__$column"} = $f;
1517
            $self->{filter}{$way}{$table}{"${table}-$column"} = $f;
1518
        }
1519
    }
1520
    
1521
    return $self;
1522
}
1523

            
1524
# DEPRECATED!
1525
sub create_query {
1526
    warn "create_query is DEPRECATED! use query option of each method";
1527
    shift->_create_query(@_);
1528
}
1529

            
cleanup
Yuki Kimoto authored on 2011-06-13
1530
# DEPRECATED!
1531
sub apply_filter {
1532
    my $self = shift;
1533
    
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
1534
    warn "apply_filter is DEPRECATED!";
cleanup
Yuki Kimoto authored on 2011-06-13
1535
    return $self->_apply_filter(@_);
1536
}
1537

            
select_at is DEPRECATED! use...
Yuki Kimoto authored on 2011-06-08
1538
# DEPRECATED!
simplified arguments check
Yuki Kimoto authored on 2011-07-11
1539
our %SELECT_AT_ARGS = (%VALID_ARGS, where => 1, primary_key => 1);
select_at is DEPRECATED! use...
Yuki Kimoto authored on 2011-06-08
1540
sub select_at {
1541
    my ($self, %args) = @_;
1542

            
updated pod
Yuki Kimoto authored on 2011-06-08
1543
    warn "select_at is DEPRECATED! use update and id option instead";
1544

            
select_at is DEPRECATED! use...
Yuki Kimoto authored on 2011-06-08
1545
    # Arguments
1546
    my $primary_keys = delete $args{primary_key};
1547
    $primary_keys = [$primary_keys] unless ref $primary_keys;
1548
    my $where = delete $args{where};
1549
    my $param = delete $args{param};
1550
    
1551
    # Check arguments
1552
    foreach my $name (keys %args) {
1553
        croak qq{"$name" is wrong option } . _subname
1554
          unless $SELECT_AT_ARGS{$name};
1555
    }
1556
    
1557
    # Table
1558
    croak qq{"table" option must be specified } . _subname
1559
      unless $args{table};
1560
    my $table = ref $args{table} ? $args{table}->[-1] : $args{table};
1561
    
1562
    # Create where parameter
1563
    my $where_param = $self->_create_param_from_id($where, $primary_keys);
1564
    
1565
    return $self->select(where => $where_param, %args);
1566
}
1567

            
delete_at is DEPRECATED! use...
Yuki Kimoto authored on 2011-06-08
1568
# DEPRECATED!
simplified arguments check
Yuki Kimoto authored on 2011-07-11
1569
our %DELETE_AT_ARGS = (%VALID_ARGS, where => 1, primary_key => 1);
delete_at is DEPRECATED! use...
Yuki Kimoto authored on 2011-06-08
1570
sub delete_at {
1571
    my ($self, %args) = @_;
updated pod
Yuki Kimoto authored on 2011-06-08
1572

            
1573
    warn "delete_at is DEPRECATED! use update and id option instead";
delete_at is DEPRECATED! use...
Yuki Kimoto authored on 2011-06-08
1574
    
1575
    # Arguments
1576
    my $primary_keys = delete $args{primary_key};
1577
    $primary_keys = [$primary_keys] unless ref $primary_keys;
1578
    my $where = delete $args{where};
1579
    
1580
    # Check arguments
1581
    foreach my $name (keys %args) {
1582
        croak qq{"$name" is wrong option } . _subname
1583
          unless $DELETE_AT_ARGS{$name};
1584
    }
1585
    
1586
    # Create where parameter
1587
    my $where_param = $self->_create_param_from_id($where, $primary_keys);
1588
    
1589
    return $self->delete(where => $where_param, %args);
1590
}
1591

            
cleanup
Yuki Kimoto authored on 2011-06-08
1592
# DEPRECATED!
simplified arguments check
Yuki Kimoto authored on 2011-07-11
1593
our %UPDATE_AT_ARGS = (%VALID_ARGS, where => 1, primary_key => 1);
cleanup
Yuki Kimoto authored on 2011-06-08
1594
sub update_at {
1595
    my $self = shift;
1596

            
1597
    warn "update_at is DEPRECATED! use update and id option instead";
1598
    
1599
    # Arguments
1600
    my $param;
1601
    $param = shift if @_ % 2;
1602
    my %args = @_;
1603
    my $primary_keys = delete $args{primary_key};
1604
    $primary_keys = [$primary_keys] unless ref $primary_keys;
1605
    my $where = delete $args{where};
1606
    my $p = delete $args{param} || {};
1607
    $param  ||= $p;
1608
    
1609
    # Check arguments
1610
    foreach my $name (keys %args) {
1611
        croak qq{"$name" is wrong option } . _subname
1612
          unless $UPDATE_AT_ARGS{$name};
1613
    }
1614
    
1615
    # Create where parameter
1616
    my $where_param = $self->_create_param_from_id($where, $primary_keys);
1617
    
1618
    return $self->update(where => $where_param, param => $param, %args);
1619
}
1620

            
insert_at is DEPRECATED! add...
Yuki Kimoto authored on 2011-06-08
1621
# DEPRECATED!
simplified arguments check
Yuki Kimoto authored on 2011-07-11
1622
our %INSERT_AT_ARGS = (%VALID_ARGS, where => 1, primary_key => 1);
insert_at is DEPRECATED! add...
Yuki Kimoto authored on 2011-06-08
1623
sub insert_at {
1624
    my $self = shift;
1625
    
1626
    warn "insert_at is DEPRECATED! use insert and id option instead";
1627
    
1628
    # Arguments
1629
    my $param;
1630
    $param = shift if @_ % 2;
1631
    my %args = @_;
1632
    my $primary_key = delete $args{primary_key};
1633
    $primary_key = [$primary_key] unless ref $primary_key;
1634
    my $where = delete $args{where};
1635
    my $p = delete $args{param} || {};
1636
    $param  ||= $p;
1637
    
1638
    # Check arguments
1639
    foreach my $name (keys %args) {
1640
        croak qq{"$name" is wrong option } . _subname
1641
          unless $INSERT_AT_ARGS{$name};
1642
    }
1643
    
1644
    # Create where parameter
cleanup
Yuki Kimoto authored on 2011-06-08
1645
    my $where_param = $self->_create_param_from_id($where, $primary_key);
insert_at is DEPRECATED! add...
Yuki Kimoto authored on 2011-06-08
1646
    $param = $self->merge_param($where_param, $param);
1647
    
1648
    return $self->insert(param => $param, %args);
1649
}
1650

            
added warnings
Yuki Kimoto authored on 2011-06-07
1651
# DEPRECATED!
1652
sub register_tag {
1653
    warn "register_tag is DEPRECATED!";
1654
    shift->query_builder->register_tag(@_)
1655
}
1656

            
data_source is DEPRECATED! I...
Yuki Kimoto authored on 2011-06-06
1657
# DEPRECATED!
cleanup
Yuki Kimoto authored on 2011-06-13
1658
has 'data_source';
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1659
has dbi_options => sub { {} };
1660
has filter_check  => 1;
1661
has 'reserved_word_quote';
renamed dbi_options to dbi_o...
Yuki Kimoto authored on 2011-01-23
1662

            
cleanup
Yuki Kimoto authored on 2011-01-25
1663
# DEPRECATED!
cleanup
Yuki Kimoto authored on 2011-01-12
1664
sub default_bind_filter {
1665
    my $self = shift;
1666
    
cleanup
Yuki Kimoto authored on 2011-06-13
1667
    warn "default_bind_filter is DEPRECATED!";
added warnings
Yuki Kimoto authored on 2011-06-07
1668
    
cleanup
Yuki Kimoto authored on 2011-01-12
1669
    if (@_) {
1670
        my $fname = $_[0];
1671
        
1672
        if (@_ && !$fname) {
1673
            $self->{default_out_filter} = undef;
1674
        }
1675
        else {
many changed
Yuki Kimoto authored on 2011-01-23
1676
            croak qq{Filter "$fname" is not registered}
cleanup
Yuki Kimoto authored on 2011-01-12
1677
              unless exists $self->filters->{$fname};
1678
        
1679
            $self->{default_out_filter} = $self->filters->{$fname};
1680
        }
1681
        return $self;
1682
    }
1683
    
1684
    return $self->{default_out_filter};
1685
}
1686

            
cleanup
Yuki Kimoto authored on 2011-01-25
1687
# DEPRECATED!
cleanup
Yuki Kimoto authored on 2011-01-12
1688
sub default_fetch_filter {
1689
    my $self = shift;
added warnings
Yuki Kimoto authored on 2011-06-07
1690

            
cleanup
Yuki Kimoto authored on 2011-06-13
1691
    warn "default_fetch_filter is DEPRECATED!";
cleanup
Yuki Kimoto authored on 2011-01-12
1692
    
1693
    if (@_) {
many changed
Yuki Kimoto authored on 2011-01-23
1694
        my $fname = $_[0];
1695

            
cleanup
Yuki Kimoto authored on 2011-01-12
1696
        if (@_ && !$fname) {
1697
            $self->{default_in_filter} = undef;
1698
        }
1699
        else {
many changed
Yuki Kimoto authored on 2011-01-23
1700
            croak qq{Filter "$fname" is not registered}
cleanup
Yuki Kimoto authored on 2011-01-12
1701
              unless exists $self->filters->{$fname};
1702
        
1703
            $self->{default_in_filter} = $self->filters->{$fname};
1704
        }
1705
        
1706
        return $self;
1707
    }
1708
    
many changed
Yuki Kimoto authored on 2011-01-23
1709
    return $self->{default_in_filter};
cleanup
Yuki Kimoto authored on 2011-01-12
1710
}
1711

            
- renamed update_param to up...
Yuki Kimoto authored on 2011-03-30
1712
# DEPRECATED!
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
1713
sub insert_param_tag {
1714
    warn "insert_param_tag is DEPRECATED! " .
1715
         "use insert_param instead!";
1716
    return shift->insert_param(@_);
- renamed update_param to up...
Yuki Kimoto authored on 2011-03-30
1717
}
1718

            
cleanup
Yuki Kimoto authored on 2011-01-25
1719
# DEPRECATED!
renamed DBIx::Custom::TagPro...
Yuki Kimoto authored on 2011-01-24
1720
sub register_tag_processor {
added warnings
Yuki Kimoto authored on 2011-06-07
1721
    warn "register_tag_processor is DEPRECATED!";
renamed DBIx::Custom::TagPro...
Yuki Kimoto authored on 2011-01-24
1722
    return shift->query_builder->register_tag_processor(@_);
1723
}
1724

            
- renamed update_param to up...
Yuki Kimoto authored on 2011-03-30
1725
# DEPRECATED!
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
1726
sub update_param_tag {
fixed DEPRECATED message bug
Yuki Kimoto authored on 2011-06-10
1727
    warn "update_param_tag is DEPRECATED! " .
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
1728
         "use update_param instead";
1729
    return shift->update_param(@_);
- renamed update_param to up...
Yuki Kimoto authored on 2011-03-30
1730
}
cleanup
Yuki Kimoto authored on 2011-03-08
1731
# DEPRECATED!
1732
sub _push_relation {
1733
    my ($self, $sql, $tables, $relation, $need_where) = @_;
1734
    
1735
    if (keys %{$relation || {}}) {
1736
        push @$sql, $need_where ? 'where' : 'and';
1737
        foreach my $rcolumn (keys %$relation) {
1738
            my $table1 = (split (/\./, $rcolumn))[0];
1739
            my $table2 = (split (/\./, $relation->{$rcolumn}))[0];
1740
            push @$tables, ($table1, $table2);
1741
            push @$sql, ("$rcolumn = " . $relation->{$rcolumn},  'and');
1742
        }
1743
    }
1744
    pop @$sql if $sql->[-1] eq 'and';    
1745
}
1746

            
1747
# DEPRECATED!
1748
sub _add_relation_table {
cleanup
Yuki Kimoto authored on 2011-03-09
1749
    my ($self, $tables, $relation) = @_;
cleanup
Yuki Kimoto authored on 2011-03-08
1750
    
1751
    if (keys %{$relation || {}}) {
1752
        foreach my $rcolumn (keys %$relation) {
1753
            my $table1 = (split (/\./, $rcolumn))[0];
1754
            my $table2 = (split (/\./, $relation->{$rcolumn}))[0];
1755
            my $table1_exists;
1756
            my $table2_exists;
1757
            foreach my $table (@$tables) {
1758
                $table1_exists = 1 if $table eq $table1;
1759
                $table2_exists = 1 if $table eq $table2;
1760
            }
1761
            unshift @$tables, $table1 unless $table1_exists;
1762
            unshift @$tables, $table2 unless $table2_exists;
1763
        }
1764
    }
1765
}
1766

            
fixed DBIx::Custom::QueryBui...
yuki-kimoto authored on 2010-08-15
1767
1;
1768

            
removed reconnect method
yuki-kimoto authored on 2010-05-28
1769
=head1 NAME
1770

            
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
1771
DBIx::Custom - Execute insert, update, delete, and select statement easily
removed reconnect method
yuki-kimoto authored on 2010-05-28
1772

            
1773
=head1 SYNOPSYS
cleanup
yuki-kimoto authored on 2010-08-05
1774

            
renamed build_query to creat...
yuki-kimoto authored on 2010-08-06
1775
    use DBIx::Custom;
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1776
    
1777
    # Connect
1778
    my $dbi = DBIx::Custom->connect(
data_source is DEPRECATED! I...
Yuki Kimoto authored on 2011-06-06
1779
        dsn => "dbi:mysql:database=dbname",
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1780
        user => 'ken',
1781
        password => '!LFKD%$&',
1782
        dbi_option => {mysql_enable_utf8 => 1}
1783
    );
cleanup
yuki-kimoto authored on 2010-08-05
1784

            
removed reconnect method
yuki-kimoto authored on 2010-05-28
1785
    # Insert 
updated pod
Yuki Kimoto authored on 2011-06-21
1786
    $dbi->insert({title => 'Perl', author => 'Ken'}, table  => 'book');
removed reconnect method
yuki-kimoto authored on 2010-05-28
1787
    
1788
    # Update 
updated pod
Yuki Kimoto authored on 2011-06-21
1789
    $dbi->update({title => 'Perl', author => 'Ken'}, table  => 'book',
1790
      where  => {id => 5});
removed reconnect method
yuki-kimoto authored on 2010-05-28
1791
    
1792
    # Delete
updated pod
Yuki Kimoto authored on 2011-06-21
1793
    $dbi->delete(table  => 'book', where => {author => 'Ken'});
cleanup
yuki-kimoto authored on 2010-08-05
1794

            
removed reconnect method
yuki-kimoto authored on 2010-05-28
1795
    # Select
updated pod
Yuki Kimoto authored on 2011-06-21
1796
    my $result = $dbi->select(table  => 'book',
1797
      column => ['title', 'author'], where  => {author => 'Ken'});
cleanup
yuki-kimoto authored on 2010-08-05
1798

            
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1799
    # Select, more complex
1800
    my $result = $dbi->select(
1801
        table  => 'book',
1802
        column => [
cleanup
Yuki Kimoto authored on 2011-06-13
1803
            {book => [qw/title author/]},
1804
            {company => ['name']}
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1805
        ],
1806
        where  => {'book.author' => 'Ken'},
1807
        join => ['left outer join company on book.company_id = company.id'],
1808
        append => 'order by id limit 5'
removed reconnect method
yuki-kimoto authored on 2010-05-28
1809
    );
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1810
    
removed register_format()
yuki-kimoto authored on 2010-05-26
1811
    # Fetch
1812
    while (my $row = $result->fetch) {
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1813
        
removed register_format()
yuki-kimoto authored on 2010-05-26
1814
    }
1815
    
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1816
    # Fetch as hash
removed register_format()
yuki-kimoto authored on 2010-05-26
1817
    while (my $row = $result->fetch_hash) {
1818
        
1819
    }
1820
    
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1821
    # Execute SQL with parameter.
1822
    $dbi->execute(
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
1823
        "select id from book where author = :author and title like :title",
updated pod
Yuki Kimoto authored on 2011-06-21
1824
        {author => 'ken', title => '%Perl%'}
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1825
    );
1826
    
renamed update tag to update...
yuki-kimoto authored on 2010-08-09
1827
=head1 DESCRIPTIONS
removed reconnect method
yuki-kimoto authored on 2010-05-28
1828

            
cleanup
Yuki Kimoto authored on 2011-07-29
1829
L<DBIx::Custom> is L<DBI> wrapper module to execute SQL easily.
updated pod
Yuki Kimoto authored on 2011-06-21
1830
This module have the following features.
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1831

            
updated pod
Yuki Kimoto authored on 2011-06-21
1832
=over 4
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1833

            
cleanup
Yuki Kimoto authored on 2011-07-29
1834
=item *
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1835

            
cleanup
Yuki Kimoto authored on 2011-07-29
1836
Execute C<insert>, C<update>, C<delete>, or C<select> statement easily
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1837

            
cleanup
Yuki Kimoto authored on 2011-07-29
1838
=item *
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1839

            
cleanup
Yuki Kimoto authored on 2011-07-29
1840
Create C<where> clause flexibly
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1841

            
cleanup
Yuki Kimoto authored on 2011-07-29
1842
=item *
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1843

            
micro optimization
Yuki Kimoto authored on 2011-07-30
1844
Named place holder support
1845

            
1846
=item *
1847

            
cleanup
Yuki Kimoto authored on 2011-07-29
1848
Model support
1849

            
1850
=item *
1851

            
1852
Connection manager support
1853

            
1854
=item *
pod fix
Yuki Kimoto authored on 2011-01-21
1855

            
cleanup
Yuki Kimoto authored on 2011-07-30
1856
Choice your favorite relational database management system,
cleanup
Yuki Kimoto authored on 2011-07-29
1857
C<MySQL>, C<SQLite>, C<PostgreSQL>, C<Oracle>,
1858
C<Microsoft SQL Server>, C<Microsoft Access>, C<DB2> or anything, 
1859

            
1860
=item *
1861

            
1862
Filtering by data type or column name(EXPERIMENTAL)
1863

            
1864
=item *
1865

            
1866
Create C<order by> clause flexibly(EXPERIMENTAL)
1867

            
1868
=back
pod fix
Yuki Kimoto authored on 2011-01-21
1869

            
cleanup
Yuki Kimoto authored on 2011-07-29
1870
=head1 DOCUMENTATIONS
pod fix
Yuki Kimoto authored on 2011-01-21
1871

            
cleanup
Yuki Kimoto authored on 2011-07-29
1872
L<DBIx::Custom::Guide> - How to use L<DBIx::Custom>
pod fix
Yuki Kimoto authored on 2011-01-21
1873

            
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1874
L<DBIx::Custom Wiki|https://github.com/yuki-kimoto/DBIx-Custom/wiki>
cleanup
Yuki Kimoto authored on 2011-07-29
1875
- Theare are various examples.
1876

            
micro optimization
Yuki Kimoto authored on 2011-07-30
1877
Module documentations - 
cleanup
Yuki Kimoto authored on 2011-07-29
1878
L<DBIx::Custom::Result>,
1879
L<DBIx::Custom::Query>,
1880
L<DBIx::Custom::Where>,
1881
L<DBIx::Custom::Model>,
1882
L<DBIx::Custom::Order>
updated document
yuki-kimoto authored on 2010-08-08
1883

            
update document
yuki-kimoto authored on 2010-01-30
1884
=head1 ATTRIBUTES
packaging one directory
yuki-kimoto authored on 2009-11-16
1885

            
- removed DEPRECATED DBIx::C...
Yuki Kimoto authored on 2011-04-11
1886
=head2 C<connector>
- removed EXPERIMENTAL Prefo...
Yuki Kimoto authored on 2011-04-04
1887

            
1888
    my $connector = $dbi->connector;
micro optimization
Yuki Kimoto authored on 2011-07-30
1889
    $dbi = $dbi->connector($connector);
- removed EXPERIMENTAL Prefo...
Yuki Kimoto authored on 2011-04-04
1890

            
micro optimization
Yuki Kimoto authored on 2011-07-30
1891
Connection manager object. if C<connector> is set, you can get C<dbh>
1892
through connection manager. Conection manager object must have C<dbh> mehtod.
- removed EXPERIMENTAL Prefo...
Yuki Kimoto authored on 2011-04-04
1893

            
1894
This is L<DBIx::Connector> example. Please pass
updated pod
Yuki Kimoto authored on 2011-06-21
1895
C<default_dbi_option> to L<DBIx::Connector> C<new> method.
- removed EXPERIMENTAL Prefo...
Yuki Kimoto authored on 2011-04-04
1896

            
1897
    my $connector = DBIx::Connector->new(
1898
        "dbi:mysql:database=$DATABASE",
1899
        $USER,
1900
        $PASSWORD,
1901
        DBIx::Custom->new->default_dbi_option
1902
    );
1903
    
updated pod
Yuki Kimoto authored on 2011-06-21
1904
    my $dbi = DBIx::Custom->connect(connector => $connector);
- removed EXPERIMENTAL Prefo...
Yuki Kimoto authored on 2011-04-04
1905

            
data_source is DEPRECATED! I...
Yuki Kimoto authored on 2011-06-06
1906
=head2 C<dsn>
1907

            
1908
    my $dsn = $dbi->dsn;
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1909
    $dbi = $dbi->dsn("DBI:mysql:database=dbname");
packaging one directory
yuki-kimoto authored on 2009-11-16
1910

            
updated pod
Yuki Kimoto authored on 2011-06-21
1911
Data source name, used when C<connect> method is executed.
removed DESTROY method(not b...
yuki-kimoto authored on 2010-07-18
1912

            
renamed dbi_options to dbi_o...
Yuki Kimoto authored on 2011-01-23
1913
=head2 C<dbi_option>
added dbi_options attribute
kimoto authored on 2010-12-20
1914

            
renamed dbi_options to dbi_o...
Yuki Kimoto authored on 2011-01-23
1915
    my $dbi_option = $dbi->dbi_option;
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1916
    $dbi = $dbi->dbi_option($dbi_option);
add default_dbi_option()
Yuki Kimoto authored on 2011-02-19
1917

            
updated pod
Yuki Kimoto authored on 2011-06-21
1918
L<DBI> option, used when C<connect> method is executed.
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1919
Each value in option override the value of C<default_dbi_option>.
add default_dbi_option()
Yuki Kimoto authored on 2011-02-19
1920

            
1921
=head2 C<default_dbi_option>
1922

            
1923
    my $default_dbi_option = $dbi->default_dbi_option;
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1924
    $dbi = $dbi->default_dbi_option($default_dbi_option);
add default_dbi_option()
Yuki Kimoto authored on 2011-02-19
1925

            
updated pod
Yuki Kimoto authored on 2011-06-21
1926
L<DBI> default option, used when C<connect> method is executed,
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1927
default to the following values.
add default_dbi_option()
Yuki Kimoto authored on 2011-02-19
1928

            
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1929
    {
1930
        RaiseError => 1,
1931
        PrintError => 0,
1932
        AutoCommit => 1,
1933
    }
packaging one directory
yuki-kimoto authored on 2009-11-16
1934

            
cleanup
yuki-kimoto authored on 2010-10-17
1935
=head2 C<filters>
bind_filter argument is chan...
yuki-kimoto authored on 2009-11-19
1936

            
cleanup
yuki-kimoto authored on 2010-10-17
1937
    my $filters = $dbi->filters;
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1938
    $dbi = $dbi->filters(\%filters);
packaging one directory
yuki-kimoto authored on 2009-11-16
1939

            
updated pod
Yuki Kimoto authored on 2011-06-21
1940
Filters, registered by C<register_filter> method.
add models() attribute
Yuki Kimoto authored on 2011-02-21
1941

            
- removed EXPERIMENTAL statu...
Yuki Kimoto authored on 2011-07-26
1942
=head2 C<last_sql>
added EXPERIMENTAL last_sql ...
Yuki Kimoto authored on 2011-07-11
1943

            
1944
    my $last_sql = $dbi->last_sql;
1945
    $dbi = $dbi->last_sql($last_sql);
1946

            
1947
Get last successed SQL executed by C<execute> method.
1948

            
- removed DEPRECATED DBIx::C...
Yuki Kimoto authored on 2011-04-11
1949
=head2 C<models>
add models() attribute
Yuki Kimoto authored on 2011-02-21
1950

            
1951
    my $models = $dbi->models;
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1952
    $dbi = $dbi->models(\%models);
add models() attribute
Yuki Kimoto authored on 2011-02-21
1953

            
updated pod
Yuki Kimoto authored on 2011-06-21
1954
Models, included by C<include_model> method.
add models() attribute
Yuki Kimoto authored on 2011-02-21
1955

            
cleanup
yuki-kimoto authored on 2010-10-17
1956
=head2 C<password>
1957

            
1958
    my $password = $dbi->password;
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1959
    $dbi = $dbi->password('lkj&le`@s');
cleanup
yuki-kimoto authored on 2010-10-17
1960

            
updated pod
Yuki Kimoto authored on 2011-06-21
1961
Password, used when C<connect> method is executed.
update document
yuki-kimoto authored on 2010-01-30
1962

            
renamed update tag to update...
yuki-kimoto authored on 2010-08-09
1963
=head2 C<query_builder>
added commit method
yuki-kimoto authored on 2010-05-27
1964

            
renamed update tag to update...
yuki-kimoto authored on 2010-08-09
1965
    my $sql_class = $dbi->query_builder;
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1966
    $dbi = $dbi->query_builder(DBIx::Custom::QueryBuilder->new);
added commit method
yuki-kimoto authored on 2010-05-27
1967

            
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1968
Query builder, default to L<DBIx::Custom::QueryBuilder> object.
cleanup
yuki-kimoto authored on 2010-08-05
1969

            
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1970
=head2 C<quote>
added EXPERIMENTAL reserved_...
Yuki Kimoto authored on 2011-03-30
1971

            
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1972
     my quote = $dbi->quote;
1973
     $dbi = $dbi->quote('"');
added EXPERIMENTAL reserved_...
Yuki Kimoto authored on 2011-03-30
1974

            
DBIx::Custom::Model type att...
Yuki Kimoto authored on 2011-06-17
1975
Reserved word quote.
1976
Default to double quote '"' except for mysql.
1977
In mysql, default to back quote '`'
added EXPERIMENTAL reserved_...
Yuki Kimoto authored on 2011-03-30
1978

            
cleanup
Yuki Kimoto authored on 2011-07-30
1979
You can set quote pair.
1980

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

            
cleanup
yuki-kimoto authored on 2010-10-17
1983
=head2 C<result_class>
cleanup
yuki-kimoto authored on 2010-08-05
1984

            
cleanup
yuki-kimoto authored on 2010-10-17
1985
    my $result_class = $dbi->result_class;
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1986
    $dbi = $dbi->result_class('DBIx::Custom::Result');
cleanup
yuki-kimoto authored on 2010-08-05
1987

            
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1988
Result class, default to L<DBIx::Custom::Result>.
cleanup
yuki-kimoto authored on 2010-08-05
1989

            
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
1990
=head2 C<safety_character>
update pod
Yuki Kimoto authored on 2011-01-27
1991

            
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1992
    my $safety_character = $self->safety_character;
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1993
    $dbi = $self->safety_character($character);
update pod
Yuki Kimoto authored on 2011-01-27
1994

            
update pod
Yuki Kimoto authored on 2011-03-13
1995
Regex of safety character for table and column name, default to '\w'.
cleanup
Yuki Kimoto authored on 2011-03-10
1996
Note that you don't have to specify like '[\w]'.
update pod
Yuki Kimoto authored on 2011-01-27
1997

            
added tag_parse attribute
Yuki Kimoto authored on 2011-06-28
1998
=head2 C<tag_parse>
1999

            
2000
    my $tag_parse = $dbi->tag_parse(0);
2001
    $dbi = $dbi->tag_parse;
2002

            
2003
Enable DEPRECATED tag parsing functionality, default to 1.
2004
If you want to disable tag parsing functionality, set to 0.
2005

            
cleanup
yuki-kimoto authored on 2010-10-17
2006
=head2 C<user>
cleanup
yuki-kimoto authored on 2010-08-05
2007

            
cleanup
yuki-kimoto authored on 2010-10-17
2008
    my $user = $dbi->user;
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
2009
    $dbi = $dbi->user('Ken');
cleanup
yuki-kimoto authored on 2010-08-05
2010

            
updated pod
Yuki Kimoto authored on 2011-06-21
2011
User name, used when C<connect> method is executed.
update pod
Yuki Kimoto authored on 2011-01-27
2012

            
cleanup
yuki-kimoto authored on 2010-10-17
2013
=head1 METHODS
added commit method
yuki-kimoto authored on 2010-05-27
2014

            
cleanup
yuki-kimoto authored on 2010-10-17
2015
L<DBIx::Custom> inherits all methods from L<Object::Simple>
cleanup
Yuki Kimoto authored on 2011-03-10
2016
and use all methods of L<DBI>
cleanup
yuki-kimoto authored on 2010-10-17
2017
and implements the following new ones.
added check_filter attribute
yuki-kimoto authored on 2010-08-08
2018

            
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2019
=head2 C<available_data_type> EXPERIMENTAL
2020

            
2021
    print $dbi->available_data_type;
2022

            
added EXPERIMENTAL available...
Yuki Kimoto authored on 2011-06-14
2023
Get available data types. You can use these data types
updated pod
Yuki Kimoto authored on 2011-06-21
2024
in C<type rule>'s C<from1> and C<from2> section.
added EXPERIMENTAL available...
Yuki Kimoto authored on 2011-06-14
2025

            
2026
=head2 C<available_type_name> EXPERIMENTAL
2027

            
2028
    print $dbi->available_type_name;
2029

            
2030
Get available type names. You can use these type names in
updated pod
Yuki Kimoto authored on 2011-06-21
2031
C<type_rule>'s C<into1> and C<into2> section.
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2032

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
2033
=head2 C<assign_param> EXPERIMENTAL
added EXPERIMENTAL assign_ta...
Yuki Kimoto authored on 2011-04-26
2034

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
2035
    my $assign_param = $dbi->assign_param({title => 'a', age => 2});
added EXPERIMENTAL assign_ta...
Yuki Kimoto authored on 2011-04-26
2036

            
updated pod
Yuki Kimoto authored on 2011-06-09
2037
Create assign parameter.
added EXPERIMENTAL assign_ta...
Yuki Kimoto authored on 2011-04-26
2038

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
2039
    title = :title, author = :author
added EXPERIMENTAL assign_ta...
Yuki Kimoto authored on 2011-04-26
2040

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
2041
This is equal to C<update_param> exept that set is not added.
added EXPERIMENTAL assign_ta...
Yuki Kimoto authored on 2011-04-26
2042

            
added EXPERIMENTAL parameter...
Yuki Kimoto authored on 2011-07-29
2043
=head2 C<column>
- select() EXPERIMETNAL colu...
Yuki Kimoto authored on 2011-06-08
2044

            
cleanup
Yuki Kimoto authored on 2011-06-13
2045
    my $column = $dbi->column(book => ['author', 'title']);
- select() EXPERIMETNAL colu...
Yuki Kimoto authored on 2011-06-08
2046

            
2047
Create column clause. The follwoing column clause is created.
2048

            
2049
    book.author as "book.author",
2050
    book.title as "book.title"
2051

            
cleanup
Yuki Kimoto authored on 2011-06-13
2052
You can change separator by C<separator> method.
- select() EXPERIMETNAL colu...
Yuki Kimoto authored on 2011-06-08
2053

            
cleanup
Yuki Kimoto authored on 2011-06-13
2054
    # Separator is double underbar
2055
    $dbi->separator('__');
2056
    
2057
    book.author as "book__author",
2058
    book.title as "book__title"
- select() EXPERIMETNAL colu...
Yuki Kimoto authored on 2011-06-08
2059

            
cleanup
Yuki Kimoto authored on 2011-06-13
2060
    # Separator is hyphen
2061
    $dbi->separator('-');
2062
    
2063
    book.author as "book-author",
2064
    book.title as "book-title"
2065
    
removed DBIx::Custom commit ...
yuki-kimoto authored on 2010-07-14
2066
=head2 C<connect>
packaging one directory
yuki-kimoto authored on 2009-11-16
2067

            
update pod
Yuki Kimoto authored on 2011-03-13
2068
    my $dbi = DBIx::Custom->connect(
data_source is DEPRECATED! I...
Yuki Kimoto authored on 2011-06-06
2069
        dsn => "dbi:mysql:database=dbname",
update pod
Yuki Kimoto authored on 2011-03-13
2070
        user => 'ken',
2071
        password => '!LFKD%$&',
2072
        dbi_option => {mysql_enable_utf8 => 1}
2073
    );
2074

            
2075
Connect to the database and create a new L<DBIx::Custom> object.
bind_filter argument is chan...
yuki-kimoto authored on 2009-11-19
2076

            
renamed build_query to creat...
yuki-kimoto authored on 2010-08-06
2077
L<DBIx::Custom> is a wrapper of L<DBI>.
cleanup
yuki-kimoto authored on 2010-08-09
2078
C<AutoCommit> and C<RaiseError> options are true, 
update pod
Yuki Kimoto authored on 2011-03-13
2079
and C<PrintError> option is false by default.
packaging one directory
yuki-kimoto authored on 2009-11-16
2080

            
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
2081
=head2 create_model
2082

            
adeed EXPERIMENTAL DBIx::Cus...
Yuki Kimoto authored on 2011-03-29
2083
    my $model = $dbi->create_model(
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
2084
        table => 'book',
2085
        primary_key => 'id',
2086
        join => [
2087
            'inner join company on book.comparny_id = company.id'
2088
        ],
2089
    );
2090

            
2091
Create L<DBIx::Custom::Model> object and initialize model.
updated pod
Yuki Kimoto authored on 2011-06-21
2092
the module is also used from C<model> method.
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
2093

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

            
EXPERIMETAL fork safety impl...
Yuki Kimoto authored on 2011-03-12
2096
=head2 C<dbh>
2097

            
2098
    my $dbh = $dbi->dbh;
2099

            
- removed EXPERIMENTAL Prefo...
Yuki Kimoto authored on 2011-04-04
2100
Get L<DBI> database handle. if C<connector> is set, you can get
updated pod
Yuki Kimoto authored on 2011-06-21
2101
database handle through C<connector> object.
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
2102

            
2103
=head2 C<each_column>
2104

            
2105
    $dbi->each_column(
2106
        sub {
2107
            my ($dbi, $table, $column, $column_info) = @_;
2108
            
2109
            my $type = $column_info->{TYPE_NAME};
2110
            
2111
            if ($type eq 'DATE') {
2112
                # ...
2113
            }
2114
        }
2115
    );
2116

            
2117
Iterate all column informations of all table from database.
2118
Argument is callback when one column is found.
2119
Callback receive four arguments, dbi object, table name,
2120
column name and column information.
EXPERIMETAL fork safety impl...
Yuki Kimoto authored on 2011-03-12
2121

            
- removed EXPERIMENTAL statu...
Yuki Kimoto authored on 2011-07-26
2122
=head2 C<each_table>
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
2123

            
2124
    $dbi->each_table(
2125
        sub {
2126
            my ($dbi, $table, $table_info) = @_;
2127
            
2128
            my $table_name = $table_info->{TABLE_NAME};
2129
        }
2130
    );
2131

            
2132
Iterate all table informationsfrom database.
2133
Argument is callback when one table is found.
2134
Callback receive three arguments, dbi object, table name,
2135
table information.
2136

            
cleanup
yuki-kimoto authored on 2010-10-17
2137
=head2 C<execute>
packaging one directory
yuki-kimoto authored on 2009-11-16
2138

            
update pod
Yuki Kimoto authored on 2011-03-13
2139
    my $result = $dbi->execute(
updated pod
Yuki Kimoto authored on 2011-06-21
2140
      "select * from book where title = :title and author like :author",
2141
      {title => 'Perl', author => '%Ken%'}
2142
    );
2143

            
2144
    my $result = $dbi->execute(
2145
      "select * from book where title = :book.title and author like :book.author",
2146
      {'book.title' => 'Perl', 'book.author' => '%Ken%'}
update pod
Yuki Kimoto authored on 2011-03-13
2147
    );
2148

            
updated pod
Yuki Kimoto authored on 2011-06-21
2149
Execute SQL. SQL can contain column parameter such as :author and :title.
2150
You can append table name to column name such as :book.title and :book.author.
2151
Second argunet is data, embedded into column parameter.
2152
Return value is L<DBIx::Custom::Result> object when select statement is executed,
2153
or the count of affected rows when insert, update, delete statement is executed.
update pod
Yuki Kimoto authored on 2011-03-13
2154

            
I call :title named placehol...
Yuki Kimoto authored on 2011-07-30
2155
Named placeholder such as C<:title> is replaced by placeholder C<?>.
added EXPERIMENTAL parameter...
Yuki Kimoto authored on 2011-07-29
2156
    
micro optimization
Yuki Kimoto authored on 2011-07-30
2157
    # Original
added EXPERIMENTAL parameter...
Yuki Kimoto authored on 2011-07-29
2158
    select * from book where title = :title and author like :author
2159
    
micro optimization
Yuki Kimoto authored on 2011-07-30
2160
    # Replaced
added EXPERIMENTAL parameter...
Yuki Kimoto authored on 2011-07-29
2161
    select * from where title = ? and author like ?;
update pod
Yuki Kimoto authored on 2011-03-13
2162

            
I call :title named placehol...
Yuki Kimoto authored on 2011-07-30
2163
You can specify operator with named placeholder
2164
 by C<name{operator}> syntax.
added EXPERIMENTAL parameter...
Yuki Kimoto authored on 2011-07-29
2165

            
micro optimization
Yuki Kimoto authored on 2011-07-30
2166
    # Original
added EXPERIMENTAL parameter...
Yuki Kimoto authored on 2011-07-29
2167
    select * from book where :title{=} and :author{like}
2168
    
micro optimization
Yuki Kimoto authored on 2011-07-30
2169
    # Replaced
update pod
Yuki Kimoto authored on 2011-03-13
2170
    select * from where title = ? and author like ?;
2171

            
fixed named placeholder bug ...
Yuki Kimoto authored on 2011-08-01
2172
Note that colons in time format such as 12:13:15 is exeption,
2173
it is not parsed as named placeholder.
2174
If you want to use colon generally, you must escape it by C<\\>
2175

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

            
updated pod
Yuki Kimoto authored on 2011-06-09
2178
The following opitons are available.
update pod
Yuki Kimoto authored on 2011-03-13
2179

            
2180
=over 4
2181

            
2182
=item C<filter>
updated pod
Yuki Kimoto authored on 2011-06-09
2183
    
2184
    filter => {
2185
        title  => sub { uc $_[0] }
2186
        author => sub { uc $_[0] }
2187
    }
update pod
Yuki Kimoto authored on 2011-03-13
2188

            
updated pod
Yuki Kimoto authored on 2011-06-09
2189
    # Filter name
2190
    filter => {
2191
        title  => 'upper_case',
2192
        author => 'upper_case'
2193
    }
2194
        
2195
    # At once
2196
    filter => [
2197
        [qw/title author/]  => sub { uc $_[0] }
2198
    ]
2199

            
separate DBIx::Custom type_r...
Yuki Kimoto authored on 2011-06-15
2200
Filter. You can set subroutine or filter name
updated pod
Yuki Kimoto authored on 2011-06-21
2201
registered by by C<register_filter>.
separate DBIx::Custom type_r...
Yuki Kimoto authored on 2011-06-15
2202
This filter is executed before data is saved into database.
2203
and before type rule filter is executed.
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2204

            
updated document
Yuki Kimoto authored on 2011-06-09
2205
=item C<query>
2206

            
2207
    query => 1
2208

            
2209
C<execute> method return L<DBIx::Custom::Query> object, not executing SQL.
cleanup
Yuki Kimoto authored on 2011-07-30
2210
You can check SQL or get statment handle.
updated pod
Yuki Kimoto authored on 2011-06-21
2211

            
2212
    my $sql = $query->sql;
cleanup
Yuki Kimoto authored on 2011-07-30
2213
    my $sth = $query->sth;
Added execute method's query...
Yuki Kimoto authored on 2011-07-30
2214
    my $columns = $query->columns;
2215
    
2216
If you want to execute SQL fast, you can do the following way.
2217

            
2218
    my $query;
2219
    foreach my $row (@$rows) {
2220
      $query ||= $dbi->insert($row, table => 'table1', query => 1);
2221
      $dbi->execute($query, $row, filter => {ab => sub { $_[0] * 2 }});
2222
    }
2223

            
2224
Statement handle is reused and SQL parsing is finished,
2225
so you can get more performance than normal way.
cleanup
Yuki Kimoto authored on 2011-07-30
2226

            
2227
If you want to execute SQL as possible as fast and don't need filtering.
Added execute method's query...
Yuki Kimoto authored on 2011-07-30
2228
You can do the following way.
cleanup
Yuki Kimoto authored on 2011-07-30
2229
    
2230
    my $query;
2231
    my $sth;
2232
    foreach my $row (@$rows) {
2233
      $query ||= $dbi->insert($row, table => 'book', query => 1);
2234
      $sth ||= $query->sth;
2235
      $sth->execute(map { $row->{$_} } sort keys %$row);
2236
    }
2237

            
2238
Note that $row must be simple hash reference, such as
2239
{title => 'Perl', author => 'Ken'}.
2240
and don't forget to sort $row values by $row key asc order.
updated document
Yuki Kimoto authored on 2011-06-09
2241

            
updated pod
Yuki Kimoto authored on 2011-06-09
2242
=item C<table>
2243
    
2244
    table => 'author'
2245

            
updated pod
Yuki Kimoto authored on 2011-06-21
2246
If you want to omit table name in column name
2247
and enable C<into1> and C<into2> type filter,
2248
You must set C<table> option.
updated pod
Yuki Kimoto authored on 2011-06-09
2249

            
updated pod
Yuki Kimoto authored on 2011-06-21
2250
    $dbi->execute("select * from book where title = :title and author = :author",
2251
        {title => 'Perl', author => 'Ken', table => 'book');
updated pod
Yuki Kimoto authored on 2011-06-09
2252

            
updated pod
Yuki Kimoto authored on 2011-06-21
2253
    # Same
2254
    $dbi->execute(
2255
      "select * from book where title = :book.title and author = :book.author",
2256
      {title => 'Perl', author => 'Ken');
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2257

            
updated pod
Yuki Kimoto authored on 2011-06-21
2258
=item C<bind_type>
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2259

            
updated pod
Yuki Kimoto authored on 2011-06-21
2260
Specify database bind data type.
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2261

            
updated pod
Yuki Kimoto authored on 2011-06-21
2262
    bind_type => [image => DBI::SQL_BLOB]
2263
    bind_type => [[qw/image audio/] => DBI::SQL_BLOB]
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2264

            
updated pod
Yuki Kimoto authored on 2011-06-21
2265
This is used to bind parameter by C<bind_param> of statment handle.
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2266

            
updated pod
Yuki Kimoto authored on 2011-06-21
2267
    $sth->bind_param($pos, $value, DBI::SQL_BLOB);
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2268

            
added EXPERIMENTAL execute m...
Yuki Kimoto authored on 2011-06-27
2269
=item C<table_alias> EXPERIMENTAL
2270

            
2271
    table_alias => {user => 'hiker'}
2272

            
2273
Table alias. Key is real table name, value is alias table name.
2274
If you set C<table_alias>, you can enable C<into1> and C<into2> type rule
2275
on alias table name.
2276

            
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2277
=item C<type_rule_off> EXPERIMENTAL
2278

            
2279
    type_rule_off => 1
2280

            
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2281
Turn C<into1> and C<into2> type rule off.
2282

            
2283
=item C<type_rule1_off> EXPERIMENTAL
2284

            
2285
    type_rule1_off => 1
2286

            
2287
Turn C<into1> type rule off.
2288

            
2289
=item C<type_rule2_off> EXPERIMENTAL
2290

            
2291
    type_rule2_off => 1
2292

            
2293
Turn C<into2> type rule off.
update document
yuki-kimoto authored on 2009-11-19
2294

            
update pod
Yuki Kimoto authored on 2011-03-13
2295
=back
version 0.0901
yuki-kimoto authored on 2009-12-17
2296

            
removed DBIx::Custom commit ...
yuki-kimoto authored on 2010-07-14
2297
=head2 C<delete>
packaging one directory
yuki-kimoto authored on 2009-11-16
2298

            
update pod
Yuki Kimoto authored on 2011-03-13
2299
    $dbi->delete(table => 'book', where => {title => 'Perl'});
2300

            
updated document
Yuki Kimoto authored on 2011-06-09
2301
Execute delete statement.
update pod
Yuki Kimoto authored on 2011-03-13
2302

            
updated document
Yuki Kimoto authored on 2011-06-09
2303
The following opitons are available.
update pod
Yuki Kimoto authored on 2011-03-13
2304

            
update pod
Yuki Kimoto authored on 2011-03-13
2305
=over 4
2306

            
update pod
Yuki Kimoto authored on 2011-03-13
2307
=item C<append>
2308

            
updated document
Yuki Kimoto authored on 2011-06-09
2309
Same as C<select> method's C<append> option.
update pod
Yuki Kimoto authored on 2011-03-13
2310

            
2311
=item C<filter>
2312

            
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2313
Same as C<execute> method's C<filter> option.
update pod
Yuki Kimoto authored on 2011-03-13
2314

            
updated document
Yuki Kimoto authored on 2011-06-09
2315
=item C<id>
update pod
Yuki Kimoto authored on 2011-03-13
2316

            
updated document
Yuki Kimoto authored on 2011-06-09
2317
    id => 4
2318
    id => [4, 5]
update pod
Yuki Kimoto authored on 2011-03-13
2319

            
updated document
Yuki Kimoto authored on 2011-06-09
2320
ID corresponding to C<primary_key>.
2321
You can delete rows by C<id> and C<primary_key>.
update pod
Yuki Kimoto authored on 2011-03-13
2322

            
updated document
Yuki Kimoto authored on 2011-06-09
2323
    $dbi->delete(
2324
        parimary_key => ['id1', 'id2'],
2325
        id => [4, 5],
2326
        table => 'book',
2327
    );
update pod
Yuki Kimoto authored on 2011-03-13
2328

            
updated document
Yuki Kimoto authored on 2011-06-09
2329
The above is same as the followin one.
renamed build_query to creat...
yuki-kimoto authored on 2010-08-06
2330

            
updated document
Yuki Kimoto authored on 2011-06-09
2331
    $dbi->delete(where => {id1 => 4, id2 => 5}, table => 'book');
add experimental update_at()...
Yuki Kimoto authored on 2011-02-21
2332

            
- removed EXPERIMENTAL statu...
Yuki Kimoto authored on 2011-07-26
2333
=item C<prefix>
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
2334

            
2335
    prefix => 'some'
2336

            
2337
prefix before table name section.
2338

            
2339
    delete some from book
2340

            
updated document
Yuki Kimoto authored on 2011-06-09
2341
=item C<query>
add experimental update_at()...
Yuki Kimoto authored on 2011-02-21
2342

            
updated document
Yuki Kimoto authored on 2011-06-09
2343
Same as C<execute> method's C<query> option.
add experimental update_at()...
Yuki Kimoto authored on 2011-02-21
2344

            
updated document
Yuki Kimoto authored on 2011-06-09
2345
=item C<table>
update pod
Yuki Kimoto authored on 2011-03-13
2346

            
updated document
Yuki Kimoto authored on 2011-06-09
2347
    table => 'book'
update pod
Yuki Kimoto authored on 2011-03-13
2348

            
updated pod
Yuki Kimoto authored on 2011-06-21
2349
Table name.
2350

            
updated document
Yuki Kimoto authored on 2011-06-09
2351
=item C<where>
update pod
Yuki Kimoto authored on 2011-03-13
2352

            
updated document
Yuki Kimoto authored on 2011-06-09
2353
Same as C<select> method's C<where> option.
update pod
Yuki Kimoto authored on 2011-03-13
2354

            
updated pod
Yuki Kimoto authored on 2011-06-08
2355
=item C<primary_key>
update pod
Yuki Kimoto authored on 2011-03-13
2356

            
updated pod
Yuki Kimoto authored on 2011-06-08
2357
See C<id> option.
update pod
Yuki Kimoto authored on 2011-03-13
2358

            
updated pod
Yuki Kimoto authored on 2011-06-21
2359
=item C<bind_type>
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2360

            
updated pod
Yuki Kimoto authored on 2011-06-21
2361
Same as C<execute> method's C<bind_type> option.
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2362

            
2363
=item C<type_rule_off> EXPERIMENTAL
2364

            
2365
Same as C<execute> method's C<type_rule_off> option.
2366

            
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2367
=item C<type_rule1_off> EXPERIMENTAL
2368

            
2369
    type_rule1_off => 1
2370

            
2371
Same as C<execute> method's C<type_rule1_off> option.
2372

            
2373
=item C<type_rule2_off> EXPERIMENTAL
2374

            
2375
    type_rule2_off => 1
2376

            
2377
Same as C<execute> method's C<type_rule2_off> option.
2378

            
updated pod
Yuki Kimoto authored on 2011-06-08
2379
=back
update pod
Yuki Kimoto authored on 2011-03-13
2380

            
updated pod
Yuki Kimoto authored on 2011-06-08
2381
=head2 C<delete_all>
update pod
Yuki Kimoto authored on 2011-03-13
2382

            
updated pod
Yuki Kimoto authored on 2011-06-08
2383
    $dbi->delete_all(table => $table);
add experimental update_at()...
Yuki Kimoto authored on 2011-02-21
2384

            
updated document
Yuki Kimoto authored on 2011-06-09
2385
Execute delete statement for all rows.
updated pod
Yuki Kimoto authored on 2011-06-21
2386
Options is same as C<delete>.
update pod
Yuki Kimoto authored on 2011-03-13
2387

            
cleanup
yuki-kimoto authored on 2010-10-17
2388
=head2 C<insert>
2389

            
cleanup
Yuki Kimoto authored on 2011-06-09
2390
    $dbi->insert({title => 'Perl', author => 'Ken'}, table  => 'book');
update pod
Yuki Kimoto authored on 2011-03-13
2391

            
updated pod
Yuki Kimoto authored on 2011-06-21
2392
Execute insert statement. First argument is row data. Return value is
2393
affected row count.
update pod
Yuki Kimoto authored on 2011-03-13
2394

            
insert and update method's p...
Yuki Kimoto authored on 2011-07-29
2395
If you want to set constant value to row data, use scalar reference
2396
as parameter value.
2397

            
2398
    {date => \"NOW()"}
2399

            
cleanup
Yuki Kimoto authored on 2011-06-09
2400
The following opitons are available.
update pod
Yuki Kimoto authored on 2011-03-13
2401

            
cleanup
Yuki Kimoto authored on 2011-06-09
2402
=over 4
- insert, insert_at, update,...
Yuki Kimoto authored on 2011-06-08
2403

            
update pod
Yuki Kimoto authored on 2011-03-13
2404
=item C<append>
2405

            
cleanup
Yuki Kimoto authored on 2011-06-09
2406
Same as C<select> method's C<append> option.
update pod
Yuki Kimoto authored on 2011-03-13
2407

            
2408
=item C<filter>
2409

            
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2410
Same as C<execute> method's C<filter> option.
2411

            
2412
=item C<id>
2413

            
updated document
Yuki Kimoto authored on 2011-06-09
2414
    id => 4
2415
    id => [4, 5]
update pod
Yuki Kimoto authored on 2011-03-13
2416

            
updated document
Yuki Kimoto authored on 2011-06-09
2417
ID corresponding to C<primary_key>.
2418
You can insert a row by C<id> and C<primary_key>.
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2419

            
update pod
Yuki Kimoto authored on 2011-03-13
2420
    $dbi->insert(
updated document
Yuki Kimoto authored on 2011-06-09
2421
        {title => 'Perl', author => 'Ken'}
2422
        parimary_key => ['id1', 'id2'],
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2423
        id => [4, 5],
updated document
Yuki Kimoto authored on 2011-06-09
2424
        table => 'book'
update pod
Yuki Kimoto authored on 2011-03-13
2425
    );
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2426

            
updated document
Yuki Kimoto authored on 2011-06-09
2427
The above is same as the followin one.
update pod
Yuki Kimoto authored on 2011-03-13
2428

            
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2429
    $dbi->insert(
updated document
Yuki Kimoto authored on 2011-06-09
2430
        {id1 => 4, id2 => 5, title => 'Perl', author => 'Ken'},
2431
        table => 'book'
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2432
    );
update pod
Yuki Kimoto authored on 2011-03-13
2433

            
- removed EXPERIMENTAL statu...
Yuki Kimoto authored on 2011-07-26
2434
=item C<prefix>
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
2435

            
2436
    prefix => 'or replace'
2437

            
2438
prefix before table name section
2439

            
2440
    insert or replace into book
2441

            
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2442
=item C<primary_key>
update pod
Yuki Kimoto authored on 2011-03-13
2443

            
updated document
Yuki Kimoto authored on 2011-06-09
2444
    primary_key => 'id'
2445
    primary_key => ['id1', 'id2']
update pod
Yuki Kimoto authored on 2011-03-13
2446

            
updated document
Yuki Kimoto authored on 2011-06-09
2447
Primary key. This is used by C<id> option.
cleanup
Yuki Kimoto authored on 2011-06-09
2448

            
updated document
Yuki Kimoto authored on 2011-06-09
2449
=item C<query>
2450

            
2451
Same as C<execute> method's C<query> option.
2452

            
2453
=item C<table>
2454

            
2455
    table => 'book'
2456

            
2457
Table name.
2458

            
updated pod
Yuki Kimoto authored on 2011-06-21
2459
=item C<bind_type>
cleanup
yuki-kimoto authored on 2010-10-17
2460

            
updated pod
Yuki Kimoto authored on 2011-06-21
2461
Same as C<execute> method's C<bind_type> option.
cleanup
yuki-kimoto authored on 2010-10-17
2462

            
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2463
=item C<type_rule_off> EXPERIMENTAL
2464

            
updated document
Yuki Kimoto authored on 2011-06-09
2465
Same as C<execute> method's C<type_rule_off> option.
update pod
Yuki Kimoto authored on 2011-03-13
2466

            
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2467
=item C<type_rule1_off> EXPERIMENTAL
2468

            
2469
    type_rule1_off => 1
2470

            
2471
Same as C<execute> method's C<type_rule1_off> option.
2472

            
2473
=item C<type_rule2_off> EXPERIMENTAL
2474

            
2475
    type_rule2_off => 1
2476

            
2477
Same as C<execute> method's C<type_rule2_off> option.
2478

            
update pod
Yuki Kimoto authored on 2011-03-13
2479
=back
2480

            
2481
=over 4
2482

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
2483
=head2 C<insert_param>
added experimental update_pa...
Yuki Kimoto authored on 2011-03-08
2484

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
2485
    my $insert_param = $dbi->insert_param({title => 'a', age => 2});
added experimental update_pa...
Yuki Kimoto authored on 2011-03-08
2486

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
2487
Create insert parameters.
added experimental update_pa...
Yuki Kimoto authored on 2011-03-08
2488

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
2489
    (title, author) values (title = :title, age = :age);
added experimental update_pa...
Yuki Kimoto authored on 2011-03-08
2490

            
- removed DEPRECATED DBIx::C...
Yuki Kimoto authored on 2011-04-11
2491
=head2 C<include_model>
removed experimental base_ta...
Yuki Kimoto authored on 2011-02-15
2492

            
update pod
Yuki Kimoto authored on 2011-03-13
2493
    $dbi->include_model('MyModel');
removed experimental base_ta...
Yuki Kimoto authored on 2011-02-15
2494

            
update pod
Yuki Kimoto authored on 2011-03-13
2495
Include models from specified namespace,
2496
the following layout is needed to include models.
removed experimental base_ta...
Yuki Kimoto authored on 2011-02-15
2497

            
update pod
Yuki Kimoto authored on 2011-03-13
2498
    lib / MyModel.pm
2499
        / MyModel / book.pm
2500
                  / company.pm
add feture. all model class ...
Yuki Kimoto authored on 2011-02-18
2501

            
update pod
Yuki Kimoto authored on 2011-03-13
2502
Name space module, extending L<DBIx::Custom::Model>.
add feture. all model class ...
Yuki Kimoto authored on 2011-02-18
2503

            
update pod
Yuki Kimoto authored on 2011-03-13
2504
B<MyModel.pm>
add feture. all model class ...
Yuki Kimoto authored on 2011-02-18
2505

            
2506
    package MyModel;
updated pod
Yuki Kimoto authored on 2011-06-21
2507
    use DBIx::Custom::Model -base;
update pod
Yuki Kimoto authored on 2011-03-13
2508
    
2509
    1;
add feture. all model class ...
Yuki Kimoto authored on 2011-02-18
2510

            
update pod
Yuki Kimoto authored on 2011-03-13
2511
Model modules, extending name space module.
removed experimental base_ta...
Yuki Kimoto authored on 2011-02-15
2512

            
update pod
Yuki Kimoto authored on 2011-03-13
2513
B<MyModel/book.pm>
removed experimental base_ta...
Yuki Kimoto authored on 2011-02-15
2514

            
update pod
Yuki Kimoto authored on 2011-03-13
2515
    package MyModel::book;
updated pod
Yuki Kimoto authored on 2011-06-21
2516
    use MyModel -base;
update pod
Yuki Kimoto authored on 2011-03-13
2517
    
2518
    1;
removed experimental base_ta...
Yuki Kimoto authored on 2011-02-15
2519

            
update pod
Yuki Kimoto authored on 2011-03-13
2520
B<MyModel/company.pm>
removed experimental base_ta...
Yuki Kimoto authored on 2011-02-15
2521

            
update pod
Yuki Kimoto authored on 2011-03-13
2522
    package MyModel::company;
updated pod
Yuki Kimoto authored on 2011-06-21
2523
    use MyModel -base;
update pod
Yuki Kimoto authored on 2011-03-13
2524
    
2525
    1;
2526
    
updated pod
Yuki Kimoto authored on 2011-06-21
2527
MyModel::book and MyModel::company is included by C<include_model>.
removed experimental base_ta...
Yuki Kimoto authored on 2011-02-15
2528

            
updated pod
Yuki Kimoto authored on 2011-06-21
2529
You can get model object by C<model>.
update pod
Yuki Kimoto authored on 2011-03-13
2530

            
updated pod
Yuki Kimoto authored on 2011-06-21
2531
    my $book_model = $dbi->model('book');
update pod
Yuki Kimoto authored on 2011-03-13
2532
    my $company_model = $dbi->model('company');
removed experimental base_ta...
Yuki Kimoto authored on 2011-02-15
2533

            
update pod
Yuki Kimoto authored on 2011-03-13
2534
See L<DBIx::Custom::Model> to know model features.
2535

            
added EXPERIMENTAL map_param...
Yuki Kimoto authored on 2011-06-24
2536
=head2 C<map_param> EXPERIMENTAL
2537

            
2538
    my $map_param = $dbi->map_param(
2539
        {id => 1, authro => 'Ken', price => 1900},
2540
        'id' => 'book.id',
2541
        'author' => ['book.author' => sub { '%' . $_[0] . '%' }],
2542
        'price' => [
2543
            'book.price', {if => sub { length $_[0] }}
2544
        ]
2545
    );
2546

            
2547
Map paramters to other key and value. First argument is original
2548
parameter. this is hash reference. Rest argument is mapping.
2549
By default, Mapping is done if the value length is not zero.
2550

            
2551
=over 4
2552

            
2553
=item Key mapping
2554

            
2555
    'id' => 'book.id'
2556

            
2557
This is only key mapping. Value is same as original one.
2558

            
2559
    (id => 1) is mapped to ('book.id' => 1) if value length is not zero.
2560

            
2561
=item Key and value mapping
2562

            
2563
    'author' => ['book.author' => sub { '%' . $_[0] . '%' }]
2564

            
2565
This is key and value mapping. Frist element of array reference
2566
is mapped key name, second element is code reference to map the value.
2567

            
2568
    (author => 'Ken') is mapped to ('book.author' => '%Ken%')
2569
      if value length is not zero.
2570

            
2571
=item Condition
2572

            
2573
    'price' => ['book.price', {if => 'exists'}]
2574
    'price' => ['book.price', sub { '%' . $_[0] . '%' }, {if => 'exists'}]
2575
    'price' => ['book.price', {if => sub { defined shift }}]
2576

            
2577
If you need condition, you can sepecify it. this is code reference
2578
or 'exists'. By default, condition is the following one.
2579

            
2580
    sub { defined $_[0] && length $_[0] }
2581

            
2582
=back
2583

            
- removed DEPRECATED DBIx::C...
Yuki Kimoto authored on 2011-04-11
2584
=head2 C<merge_param>
added EXPERIMENTAL updat_par...
Yuki Kimoto authored on 2011-03-30
2585

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

            
DBIx::Custom::Model type att...
Yuki Kimoto authored on 2011-06-17
2588
Merge parameters.
added EXPERIMENTAL updat_par...
Yuki Kimoto authored on 2011-03-30
2589

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

            
- removed DEPRECATED DBIx::C...
Yuki Kimoto authored on 2011-04-11
2592
=head2 C<method>
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
2593

            
2594
    $dbi->method(
2595
        update_or_insert => sub {
2596
            my $self = shift;
update pod
Yuki Kimoto authored on 2011-03-13
2597
            
2598
            # Process
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
2599
        },
2600
        find_or_create   => sub {
2601
            my $self = shift;
update pod
Yuki Kimoto authored on 2011-03-13
2602
            
2603
            # Process
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
2604
        }
2605
    );
2606

            
update pod
Yuki Kimoto authored on 2011-03-13
2607
Register method. These method is called directly from L<DBIx::Custom> object.
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
2608

            
2609
    $dbi->update_or_insert;
2610
    $dbi->find_or_create;
2611

            
- removed DEPRECATED DBIx::C...
Yuki Kimoto authored on 2011-04-11
2612
=head2 C<model>
update pod
Yuki Kimoto authored on 2011-03-13
2613

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

            
updated pod
Yuki Kimoto authored on 2011-06-21
2616
Get a L<DBIx::Custom::Model> object,
update pod
Yuki Kimoto authored on 2011-03-13
2617

            
- removed DEPRECATED DBIx::C...
Yuki Kimoto authored on 2011-04-11
2618
=head2 C<mycolumn>
cleanup
Yuki Kimoto authored on 2011-03-21
2619

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

            
2622
Create column clause for myself. The follwoing column clause is created.
2623

            
2624
    book.author as author,
2625
    book.title as title
2626

            
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
2627
=head2 C<new>
2628

            
update pod
Yuki Kimoto authored on 2011-03-13
2629
    my $dbi = DBIx::Custom->new(
data_source is DEPRECATED! I...
Yuki Kimoto authored on 2011-06-06
2630
        dsn => "dbi:mysql:database=dbname",
update pod
Yuki Kimoto authored on 2011-03-13
2631
        user => 'ken',
2632
        password => '!LFKD%$&',
2633
        dbi_option => {mysql_enable_utf8 => 1}
2634
    );
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
2635

            
2636
Create a new L<DBIx::Custom> object.
2637

            
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
2638
=head2 C<not_exists>
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
2639

            
2640
    my $not_exists = $dbi->not_exists;
2641

            
update pod
Yuki Kimoto authored on 2011-03-13
2642
DBIx::Custom::NotExists object, indicating the column is not exists.
2643
This is used by C<clause> of L<DBIx::Custom::Where> .
experimental extended select...
Yuki Kimoto authored on 2011-01-17
2644

            
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
2645
=head2 C<order> EXPERIMENTAL
2646

            
2647
    my $order = $dbi->order;
2648

            
2649
Create a new L<DBIx::Custom::Order> object.
2650

            
cleanup
yuki-kimoto authored on 2010-10-17
2651
=head2 C<register_filter>
2652

            
update pod
Yuki Kimoto authored on 2011-03-13
2653
    $dbi->register_filter(
2654
        # Time::Piece object to database DATE format
2655
        tp_to_date => sub {
2656
            my $tp = shift;
2657
            return $tp->strftime('%Y-%m-%d');
2658
        },
2659
        # database DATE format to Time::Piece object
2660
        date_to_tp => sub {
2661
           my $date = shift;
2662
           return Time::Piece->strptime($date, '%Y-%m-%d');
2663
        }
2664
    );
cleanup
yuki-kimoto authored on 2010-10-17
2665
    
update pod
Yuki Kimoto authored on 2011-03-13
2666
Register filters, used by C<filter> option of many methods.
cleanup
yuki-kimoto authored on 2010-10-17
2667

            
added type_rule into logic
Yuki Kimoto authored on 2011-06-09
2668
=head2 C<type_rule> EXPERIMENTAL
2669

            
2670
    $dbi->type_rule(
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2671
        into1 => {
separate DBIx::Custom type_r...
Yuki Kimoto authored on 2011-06-15
2672
            date => sub { ... },
2673
            datetime => sub { ... }
added type_rule into logic
Yuki Kimoto authored on 2011-06-09
2674
        },
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2675
        into2 => {
2676
            date => sub { ... },
2677
            datetime => sub { ... }
2678
        },
2679
        from1 => {
2680
            # DATE
2681
            9 => sub { ... },
2682
            # DATETIME or TIMESTAMP
2683
            11 => sub { ... },
2684
        }
2685
        from2 => {
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2686
            # DATE
2687
            9 => sub { ... },
2688
            # DATETIME or TIMESTAMP
2689
            11 => sub { ... },
added type_rule into logic
Yuki Kimoto authored on 2011-06-09
2690
        }
2691
    );
2692

            
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2693
Filtering rule when data is send into and get from database.
separate DBIx::Custom type_r...
Yuki Kimoto authored on 2011-06-15
2694
This has a little complex problem.
cleanup
Yuki Kimoto authored on 2011-06-13
2695

            
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2696
In C<into1> and C<into2> you can specify
2697
type name as same as type name defined
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2698
by create table, such as C<DATETIME> or C<DATE>.
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2699

            
separate DBIx::Custom type_r...
Yuki Kimoto authored on 2011-06-15
2700
Note that type name and data type don't contain upper case.
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2701
If these contain upper case charactor, you convert it to lower case.
2702

            
updated pod
Yuki Kimoto authored on 2011-06-21
2703
C<into2> is executed after C<into1>.
2704

            
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2705
Type rule of C<into1> and C<into2> is enabled on the following
2706
column name.
separate DBIx::Custom type_r...
Yuki Kimoto authored on 2011-06-15
2707

            
cleanup
Yuki Kimoto authored on 2011-06-13
2708
=over 4
2709

            
2710
=item 1. column name
2711

            
2712
    issue_date
2713
    issue_datetime
2714

            
updated pod
Yuki Kimoto authored on 2011-06-21
2715
This need C<table> option in each method.
2716

            
cleanup
Yuki Kimoto authored on 2011-06-13
2717
=item 2. table name and column name, separator is dot
2718

            
2719
    book.issue_date
2720
    book.issue_datetime
2721

            
2722
=back
2723

            
update pod
Yuki Kimoto authored on 2011-06-15
2724
You get all type name used in database by C<available_type_name>.
2725

            
2726
    print $dbi->available_type_name;
2727

            
updated pod
Yuki Kimoto authored on 2011-06-21
2728
In C<from1> and C<from2> you specify data type, not type name.
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2729
C<from2> is executed after C<from1>.
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2730
You get all data type by C<available_data_type>.
2731

            
2732
    print $dbi->available_data_type;
2733

            
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2734
You can also specify multiple types at once.
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2735

            
2736
    $dbi->type_rule(
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2737
        into1 => [
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2738
            [qw/DATE DATETIME/] => sub { ... },
2739
        ],
2740
    );
added type_rule into logic
Yuki Kimoto authored on 2011-06-09
2741

            
removed DBIx::Custom commit ...
yuki-kimoto authored on 2010-07-14
2742
=head2 C<select>
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2743

            
select method column option ...
Yuki Kimoto authored on 2011-02-22
2744
    my $result = $dbi->select(
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2745
        table  => 'book',
2746
        column => ['author', 'title'],
2747
        where  => {author => 'Ken'},
select method column option ...
Yuki Kimoto authored on 2011-02-22
2748
    );
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2749
    
updated document
Yuki Kimoto authored on 2011-06-09
2750
Execute select statement.
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2751

            
updated document
Yuki Kimoto authored on 2011-06-09
2752
The following opitons are available.
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2753

            
2754
=over 4
2755

            
updated document
Yuki Kimoto authored on 2011-06-09
2756
=item C<append>
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2757

            
updated document
Yuki Kimoto authored on 2011-06-09
2758
    append => 'order by title'
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2759

            
updated document
Yuki Kimoto authored on 2011-06-09
2760
Append statement to last of SQL.
2761
    
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2762
=item C<column>
2763
    
updated document
Yuki Kimoto authored on 2011-06-09
2764
    column => 'author'
2765
    column => ['author', 'title']
2766

            
2767
Column clause.
updated pod
Yuki Kimoto authored on 2011-06-07
2768
    
updated document
Yuki Kimoto authored on 2011-06-09
2769
if C<column> is not specified, '*' is set.
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2770

            
updated document
Yuki Kimoto authored on 2011-06-09
2771
    column => '*'
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2772

            
- removed EXPERIMENTAL statu...
Yuki Kimoto authored on 2011-07-26
2773
You can specify hash of array reference.
updated pod
Yuki Kimoto authored on 2011-06-07
2774

            
updated document
Yuki Kimoto authored on 2011-06-09
2775
    column => [
updated pod
Yuki Kimoto authored on 2011-06-07
2776
        {book => [qw/author title/]},
2777
        {person => [qw/name age/]}
updated document
Yuki Kimoto authored on 2011-06-09
2778
    ]
updated pod
Yuki Kimoto authored on 2011-06-07
2779

            
updated pod
Yuki Kimoto authored on 2011-06-21
2780
This is expanded to the following one by using C<colomn> method.
- select() column option can...
Yuki Kimoto authored on 2011-06-08
2781

            
2782
    book.author as "book.author",
2783
    book.title as "book.title",
2784
    person.name as "person.name",
2785
    person.age as "person.age"
2786

            
- select method column optio...
Yuki Kimoto authored on 2011-07-11
2787
You can specify array of array reference, first argument is
2788
column name, second argument is alias.
- select() column option can...
Yuki Kimoto authored on 2011-06-08
2789

            
updated document
Yuki Kimoto authored on 2011-06-09
2790
    column => [
- select method column optio...
Yuki Kimoto authored on 2011-07-11
2791
        ['date(book.register_datetime)' => 'book.register_date']
updated document
Yuki Kimoto authored on 2011-06-09
2792
    ];
- select() column option can...
Yuki Kimoto authored on 2011-06-08
2793

            
- select method column optio...
Yuki Kimoto authored on 2011-07-11
2794
Alias is quoted properly and joined.
- select() column option can...
Yuki Kimoto authored on 2011-06-08
2795

            
2796
    date(book.register_datetime) as "book.register_date"
updated pod
Yuki Kimoto authored on 2011-06-07
2797

            
updated document
Yuki Kimoto authored on 2011-06-09
2798
=item C<filter>
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2799

            
updated document
Yuki Kimoto authored on 2011-06-09
2800
Same as C<execute> method's C<filter> option.
2801

            
2802
=item C<id>
2803

            
2804
    id => 4
2805
    id => [4, 5]
2806

            
2807
ID corresponding to C<primary_key>.
2808
You can select rows by C<id> and C<primary_key>.
2809

            
2810
    $dbi->select(
2811
        parimary_key => ['id1', 'id2'],
2812
        id => [4, 5],
2813
        table => 'book'
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2814
    );
2815

            
updated document
Yuki Kimoto authored on 2011-06-09
2816
The above is same as the followin one.
2817

            
updated pod
Yuki Kimoto authored on 2011-04-25
2818
    $dbi->select(
updated document
Yuki Kimoto authored on 2011-06-09
2819
        where => {id1 => 4, id2 => 5},
2820
        table => 'book'
where can recieve array refr...
Yuki Kimoto authored on 2011-03-24
2821
    );
2822
    
updated document
Yuki Kimoto authored on 2011-06-09
2823
=item C<param> EXPERIMETNAL
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2824

            
updated document
Yuki Kimoto authored on 2011-06-09
2825
    param => {'table2.key3' => 5}
update pod
Yuki Kimoto authored on 2011-03-12
2826

            
updated document
Yuki Kimoto authored on 2011-06-09
2827
Parameter shown before where clause.
2828
    
2829
For example, if you want to contain tag in join clause, 
2830
you can pass parameter by C<param> option.
update pod
Yuki Kimoto authored on 2011-03-12
2831

            
updated document
Yuki Kimoto authored on 2011-06-09
2832
    join  => ['inner join (select * from table2 where table2.key3 = :table2.key3)' . 
2833
              ' as table2 on table1.key1 = table2.key1']
2834

            
- removed EXPERIMENTAL statu...
Yuki Kimoto authored on 2011-07-26
2835
=itme C<prefix>
added EXPERIMENTAL select pr...
Yuki Kimoto authored on 2011-06-13
2836

            
2837
    prefix => 'SQL_CALC_FOUND_ROWS'
2838

            
2839
Prefix of column cluase
2840

            
2841
    select SQL_CALC_FOUND_ROWS title, author from book;
2842

            
updated document
Yuki Kimoto authored on 2011-06-09
2843
=item C<join>
2844

            
2845
    join => [
2846
        'left outer join company on book.company_id = company_id',
2847
        'left outer join location on company.location_id = location.id'
2848
    ]
2849
        
2850
Join clause. If column cluase or where clause contain table name like "company.name",
2851
join clausees needed when SQL is created is used automatically.
update pod
Yuki Kimoto authored on 2011-03-12
2852

            
2853
    $dbi->select(
2854
        table => 'book',
cleanup
Yuki Kimoto authored on 2011-06-13
2855
        column => ['company.location_id as location_id'],
update pod
Yuki Kimoto authored on 2011-03-12
2856
        where => {'company.name' => 'Orange'},
2857
        join => [
2858
            'left outer join company on book.company_id = company.id',
2859
            'left outer join location on company.location_id = location.id'
2860
        ]
2861
    );
2862

            
updated document
Yuki Kimoto authored on 2011-06-09
2863
In above select, column and where clause contain "company" table,
2864
the following SQL is created
update pod
Yuki Kimoto authored on 2011-03-12
2865

            
cleanup
Yuki Kimoto authored on 2011-06-13
2866
    select company.location_id as location_id
update pod
Yuki Kimoto authored on 2011-03-12
2867
    from book
2868
      left outer join company on book.company_id = company.id
cleanup
Yuki Kimoto authored on 2011-06-13
2869
    where company.name = ?;
update pod
Yuki Kimoto authored on 2011-03-12
2870

            
added join new syntax
Yuki Kimoto authored on 2011-07-28
2871
You can specify two table by yourself. This is useful when join parser can't parse
cleanup
Yuki Kimoto authored on 2011-07-28
2872
the join clause correctly. This is EXPERIMENTAL.
added join new syntax
Yuki Kimoto authored on 2011-07-28
2873

            
2874
    $dbi->select(
2875
        table => 'book',
2876
        column => ['company.location_id as location_id'],
2877
        where => {'company.name' => 'Orange'},
2878
        join => [
2879
            {
2880
                clause => 'left outer join location on company.location_id = location.id',
2881
                table => ['company', 'location']
2882
            }
2883
        ]
2884
    );
2885

            
updated document
Yuki Kimoto authored on 2011-06-09
2886
=item C<primary_key>
added EXPERIMENTAL replace()...
Yuki Kimoto authored on 2011-04-01
2887

            
updated document
Yuki Kimoto authored on 2011-06-09
2888
    primary_key => 'id'
2889
    primary_key => ['id1', 'id2']
added EXPERIMENTAL replace()...
Yuki Kimoto authored on 2011-04-01
2890

            
updated document
Yuki Kimoto authored on 2011-06-09
2891
Primary key. This is used by C<id> option.
added EXPERIMENTAL replace()...
Yuki Kimoto authored on 2011-04-01
2892

            
updated document
Yuki Kimoto authored on 2011-06-09
2893
=item C<query>
update pod
Yuki Kimoto authored on 2011-03-12
2894

            
updated document
Yuki Kimoto authored on 2011-06-09
2895
Same as C<execute> method's C<query> option.
update pod
Yuki Kimoto authored on 2011-03-12
2896

            
updated pod
Yuki Kimoto authored on 2011-06-21
2897
=item C<bind_type>
updated pod
Yuki Kimoto authored on 2011-06-08
2898

            
cleanup
Yuki Kimoto authored on 2011-07-28
2899
Same as C<execute> method's C<bind_type> option.
updated pod
Yuki Kimoto authored on 2011-06-08
2900

            
updated document
Yuki Kimoto authored on 2011-06-09
2901
=item C<table>
updated pod
Yuki Kimoto authored on 2011-06-08
2902

            
updated document
Yuki Kimoto authored on 2011-06-09
2903
    table => 'book'
updated pod
Yuki Kimoto authored on 2011-06-08
2904

            
updated document
Yuki Kimoto authored on 2011-06-09
2905
Table name.
updated pod
Yuki Kimoto authored on 2011-06-08
2906

            
updated document
Yuki Kimoto authored on 2011-06-09
2907
=item C<type_rule_off> EXPERIMENTAL
updated pod
Yuki Kimoto authored on 2011-06-08
2908

            
updated document
Yuki Kimoto authored on 2011-06-09
2909
Same as C<execute> method's C<type_rule_off> option.
updated pod
Yuki Kimoto authored on 2011-06-08
2910

            
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2911
=item C<type_rule1_off> EXPERIMENTAL
2912

            
2913
    type_rule1_off => 1
2914

            
2915
Same as C<execute> method's C<type_rule1_off> option.
2916

            
2917
=item C<type_rule2_off> EXPERIMENTAL
2918

            
2919
    type_rule2_off => 1
2920

            
2921
Same as C<execute> method's C<type_rule2_off> option.
2922

            
updated document
Yuki Kimoto authored on 2011-06-09
2923
=item C<where>
2924
    
2925
    # Hash refrence
2926
    where => {author => 'Ken', 'title' => 'Perl'}
2927
    
2928
    # DBIx::Custom::Where object
2929
    where => $dbi->where(
2930
        clause => ['and', 'author = :author', 'title like :title'],
2931
        param  => {author => 'Ken', title => '%Perl%'}
2932
    );
updated pod
Yuki Kimoto authored on 2011-06-21
2933
    
2934
    # Array reference 1 (array reference, hash referenc). same as above
2935
    where => [
2936
        ['and', 'author = :author', 'title like :title'],
2937
        {author => 'Ken', title => '%Perl%'}
2938
    ];    
2939
    
2940
    # Array reference 2 (String, hash reference)
2941
    where => [
2942
        'title like :title',
2943
        {title => '%Perl%'}
2944
    ]
2945
    
2946
    # String
2947
    where => 'title is null'
update pod
Yuki Kimoto authored on 2011-03-12
2948

            
updated document
Yuki Kimoto authored on 2011-06-09
2949
Where clause.
2950
    
improved pod
Yuki Kimoto authored on 2011-04-19
2951
=item C<wrap> EXPERIMENTAL
2952

            
2953
Wrap statement. This is array reference.
2954

            
2955
    $dbi->select(wrap => ['select * from (', ') as t where ROWNUM < 10']);
2956

            
2957
This option is for Oracle and SQL Server paging process.
2958

            
update pod
Yuki Kimoto authored on 2011-03-12
2959
=back
cleanup
Yuki Kimoto authored on 2011-03-08
2960

            
cleanup
yuki-kimoto authored on 2010-10-17
2961
=head2 C<update>
removed reconnect method
yuki-kimoto authored on 2010-05-28
2962

            
updated document
Yuki Kimoto authored on 2011-06-09
2963
    $dbi->update({title => 'Perl'}, table  => 'book', where  => {id => 4});
removed reconnect method
yuki-kimoto authored on 2010-05-28
2964

            
insert and update method's p...
Yuki Kimoto authored on 2011-07-29
2965
Execute update statement. First argument is update row data.
2966

            
2967
If you want to set constant value to row data, use scalar reference
2968
as parameter value.
2969

            
2970
    {date => \"NOW()"}
added experimental update_pa...
Yuki Kimoto authored on 2011-03-08
2971

            
updated document
Yuki Kimoto authored on 2011-06-09
2972
The following opitons are available.
added experimental update_pa...
Yuki Kimoto authored on 2011-03-08
2973

            
update pod
Yuki Kimoto authored on 2011-03-13
2974
=over 4
2975

            
updated document
Yuki Kimoto authored on 2011-06-09
2976
=item C<append>
update pod
Yuki Kimoto authored on 2011-03-13
2977

            
updated document
Yuki Kimoto authored on 2011-06-09
2978
Same as C<select> method's C<append> option.
- insert, insert_at, update,...
Yuki Kimoto authored on 2011-06-08
2979

            
updated document
Yuki Kimoto authored on 2011-06-09
2980
=item C<filter>
- insert, insert_at, update,...
Yuki Kimoto authored on 2011-06-08
2981

            
updated document
Yuki Kimoto authored on 2011-06-09
2982
Same as C<execute> method's C<filter> option.
- insert, insert_at, update,...
Yuki Kimoto authored on 2011-06-08
2983

            
updated document
Yuki Kimoto authored on 2011-06-09
2984
=item C<id>
- insert, insert_at, update,...
Yuki Kimoto authored on 2011-06-08
2985

            
updated document
Yuki Kimoto authored on 2011-06-09
2986
    id => 4
2987
    id => [4, 5]
- insert, insert_at, update,...
Yuki Kimoto authored on 2011-06-08
2988

            
updated document
Yuki Kimoto authored on 2011-06-09
2989
ID corresponding to C<primary_key>.
2990
You can update rows by C<id> and C<primary_key>.
update pod
Yuki Kimoto authored on 2011-03-13
2991

            
DEPRECATED select() param op...
Yuki Kimoto authored on 2011-04-25
2992
    $dbi->update(
updated document
Yuki Kimoto authored on 2011-06-09
2993
        {title => 'Perl', author => 'Ken'}
2994
        parimary_key => ['id1', 'id2'],
2995
        id => [4, 5],
2996
        table => 'book'
where can recieve array refr...
Yuki Kimoto authored on 2011-03-24
2997
    );
update pod
Yuki Kimoto authored on 2011-03-13
2998

            
updated document
Yuki Kimoto authored on 2011-06-09
2999
The above is same as the followin one.
update pod
Yuki Kimoto authored on 2011-03-13
3000

            
updated document
Yuki Kimoto authored on 2011-06-09
3001
    $dbi->update(
3002
        {title => 'Perl', author => 'Ken'}
3003
        where => {id1 => 4, id2 => 5},
3004
        table => 'book'
3005
    );
update pod
Yuki Kimoto authored on 2011-03-13
3006

            
- removed EXPERIMENTAL statu...
Yuki Kimoto authored on 2011-07-26
3007
=item C<prefix>
added EXPERIMENTAL insert, u...
Yuki Kimoto authored on 2011-06-21
3008

            
3009
    prefix => 'or replace'
3010

            
3011
prefix before table name section
3012

            
3013
    update or replace book
3014

            
updated document
Yuki Kimoto authored on 2011-06-09
3015
=item C<primary_key>
add experimental setup_model...
Yuki Kimoto authored on 2011-02-21
3016

            
updated document
Yuki Kimoto authored on 2011-06-09
3017
    primary_key => 'id'
3018
    primary_key => ['id1', 'id2']
update pod
Yuki Kimoto authored on 2011-03-13
3019

            
updated document
Yuki Kimoto authored on 2011-06-09
3020
Primary key. This is used by C<id> option.
update pod
Yuki Kimoto authored on 2011-03-13
3021

            
updated document
Yuki Kimoto authored on 2011-06-09
3022
=item C<query>
update pod
Yuki Kimoto authored on 2011-03-13
3023

            
updated document
Yuki Kimoto authored on 2011-06-09
3024
Same as C<execute> method's C<query> option.
update pod
Yuki Kimoto authored on 2011-03-13
3025

            
updated document
Yuki Kimoto authored on 2011-06-09
3026
=item C<table>
update pod
Yuki Kimoto authored on 2011-03-13
3027

            
updated document
Yuki Kimoto authored on 2011-06-09
3028
    table => 'book'
update pod
Yuki Kimoto authored on 2011-03-13
3029

            
updated document
Yuki Kimoto authored on 2011-06-09
3030
Table name.
update pod
Yuki Kimoto authored on 2011-03-13
3031

            
updated document
Yuki Kimoto authored on 2011-06-09
3032
=item C<where>
update pod
Yuki Kimoto authored on 2011-03-13
3033

            
updated document
Yuki Kimoto authored on 2011-06-09
3034
Same as C<select> method's C<where> option.
update pod
Yuki Kimoto authored on 2011-03-13
3035

            
updated pod
Yuki Kimoto authored on 2011-06-21
3036
=item C<bind_type>
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
3037

            
cleanup
Yuki Kimoto authored on 2011-07-28
3038
Same as C<execute> method's C<bind_type> option.
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
3039

            
3040
=item C<type_rule_off> EXPERIMENTAL
3041

            
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
3042
Same as C<execute> method's C<type_rule_off> option.
3043

            
3044
=item C<type_rule1_off> EXPERIMENTAL
3045

            
3046
    type_rule1_off => 1
3047

            
3048
Same as C<execute> method's C<type_rule1_off> option.
3049

            
3050
=item C<type_rule2_off> EXPERIMENTAL
3051

            
3052
    type_rule2_off => 1
3053

            
3054
Same as C<execute> method's C<type_rule2_off> option.
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
3055

            
updated pod
Yuki Kimoto authored on 2011-06-08
3056
=back
update pod
Yuki Kimoto authored on 2011-03-13
3057

            
updated pod
Yuki Kimoto authored on 2011-06-08
3058
=head2 C<update_all>
update pod
Yuki Kimoto authored on 2011-03-13
3059

            
updated pod
Yuki Kimoto authored on 2011-06-21
3060
    $dbi->update_all({title => 'Perl'}, table => 'book', );
update pod
Yuki Kimoto authored on 2011-03-13
3061

            
updated document
Yuki Kimoto authored on 2011-06-09
3062
Execute update statement for all rows.
updated pod
Yuki Kimoto authored on 2011-06-21
3063
Options is same as C<update> method.
update pod
Yuki Kimoto authored on 2011-03-13
3064

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
3065
=head2 C<update_param>
update pod
Yuki Kimoto authored on 2011-03-13
3066

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
3067
    my $update_param = $dbi->update_param({title => 'a', age => 2});
update pod
Yuki Kimoto authored on 2011-03-13
3068

            
3069
Create update parameter tag.
3070

            
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
3071
    set title = :title, author = :author
added EXPERIMENTAL updat_par...
Yuki Kimoto authored on 2011-03-30
3072

            
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
3073
=head2 C<where>
fix tests
Yuki Kimoto authored on 2011-01-18
3074

            
cleanup
Yuki Kimoto authored on 2011-03-09
3075
    my $where = $dbi->where(
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
3076
        clause => ['and', 'title = :title', 'author = :author'],
cleanup
Yuki Kimoto authored on 2011-03-09
3077
        param => {title => 'Perl', author => 'Ken'}
3078
    );
fix tests
Yuki Kimoto authored on 2011-01-18
3079

            
3080
Create a new L<DBIx::Custom::Where> object.
3081

            
- removed DEPRECATED DBIx::C...
Yuki Kimoto authored on 2011-04-11
3082
=head2 C<setup_model>
cleanup
Yuki Kimoto authored on 2011-01-12
3083

            
update pod
Yuki Kimoto authored on 2011-03-13
3084
    $dbi->setup_model;
cleanup
Yuki Kimoto authored on 2011-01-12
3085

            
update pod
Yuki Kimoto authored on 2011-03-13
3086
Setup all model objects.
update pod
Yuki Kimoto authored on 2011-03-13
3087
C<columns> of model object is automatically set, parsing database information.
cleanup
Yuki Kimoto authored on 2011-01-12
3088

            
added environment variable D...
Yuki Kimoto authored on 2011-04-02
3089
=head1 ENVIRONMENT VARIABLE
3090

            
3091
=head2 C<DBIX_CUSTOM_DEBUG>
3092

            
3093
If environment variable C<DBIX_CUSTOM_DEBUG> is set to true,
improved debug message
Yuki Kimoto authored on 2011-05-23
3094
executed SQL and bind values are printed to STDERR.
3095

            
3096
=head2 C<DBIX_CUSTOM_DEBUG_ENCODING>
3097

            
3098
DEBUG output encoding. Default to UTF-8.
added environment variable D...
Yuki Kimoto authored on 2011-04-02
3099

            
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3100
=head1 DEPRECATED FUNCTIONALITIES
3101

            
3102
L<DBIx::Custom>
3103

            
3104
    # Attribute methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3105
    data_source # will be removed at 2017/1/1
3106
    dbi_options # will be removed at 2017/1/1
3107
    filter_check # will be removed at 2017/1/1
3108
    reserved_word_quote # will be removed at 2017/1/1
3109
    cache_method # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3110
    
3111
    # Methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3112
    create_query # will be removed at 2017/1/1
3113
    apply_filter # will be removed at 2017/1/1
3114
    select_at # will be removed at 2017/1/1
3115
    delete_at # will be removed at 2017/1/1
3116
    update_at # will be removed at 2017/1/1
3117
    insert_at # will be removed at 2017/1/1
3118
    register_tag # will be removed at 2017/1/1
3119
    default_bind_filter # will be removed at 2017/1/1
3120
    default_fetch_filter # will be removed at 2017/1/1
3121
    insert_param_tag # will be removed at 2017/1/1
3122
    register_tag_processor # will be removed at 2017/1/1
3123
    update_param_tag # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3124
    
3125
    # Options
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3126
    select method relation option # will be removed at 2017/1/1
3127
    select method param option # will be removed at 2017/1/1
3128
    select method column option [COLUMN, as => ALIAS] format
3129
      # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3130
    
3131
    # Others
cleanup
Yuki Kimoto authored on 2011-07-28
3132
    execute("select * from {= title}"); # execute method's
3133
                                        # tag parsing functionality
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3134
                                        # will be removed at 2017/1/1
3135
    Query caching # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3136

            
3137
L<DBIx::Custom::Model>
3138

            
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
3139
    # Attribute methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3140
    filter # will be removed at 2017/1/1
3141
    name # will be removed at 2017/1/1
3142
    type # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3143

            
3144
L<DBIx::Custom::Query>
3145
    
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
3146
    # Attribute methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3147
    default_filter # will be removed at 2017/1/1
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
3148
    table # will be removed at 2017/1/1
3149
    filters # will be removed at 2017/1/1
3150
    
3151
    # Methods
3152
    filter # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3153

            
3154
L<DBIx::Custom::QueryBuilder>
3155
    
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
3156
    # Attribute methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3157
    tags # will be removed at 2017/1/1
3158
    tag_processors # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3159
    
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
3160
    # Methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3161
    register_tag # will be removed at 2017/1/1
3162
    register_tag_processor # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3163
    
3164
    # Others
3165
    build_query("select * from {= title}"); # tag parsing functionality
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3166
                                            # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3167

            
3168
L<DBIx::Custom::Result>
3169
    
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
3170
    # Attribute methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3171
    filter_check # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3172
    
3173
    # Methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3174
    end_filter # will be removed at 2017/1/1
3175
    remove_end_filter # will be removed at 2017/1/1
3176
    remove_filter # will be removed at 2017/1/1
3177
    default_filter # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3178

            
3179
L<DBIx::Custom::Tag>
3180

            
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3181
    This module is DEPRECATED! # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3182

            
3183
=head1 BACKWORD COMPATIBLE POLICY
3184

            
3185
If a functionality is DEPRECATED, you can know it by DEPRECATED warnings
3186
except for attribute method.
3187
You can check all DEPRECATED functionalities by document.
3188
DEPRECATED functionality is removed after five years,
3189
but if at least one person use the functionality and tell me that thing
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3190
I extend one year each time he tell me it.
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3191

            
3192
EXPERIMENTAL functionality will be changed without warnings.
DBIx::Custom is now stable
yuki-kimoto authored on 2010-09-07
3193

            
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3194
This policy was changed at 2011/6/28
DBIx::Custom is now stable
yuki-kimoto authored on 2010-09-07
3195

            
removed DESTROY method(not b...
yuki-kimoto authored on 2010-07-18
3196
=head1 BUGS
3197

            
renamed build_query to creat...
yuki-kimoto authored on 2010-08-06
3198
Please tell me bugs if found.
removed DESTROY method(not b...
yuki-kimoto authored on 2010-07-18
3199

            
3200
C<< <kimoto.yuki at gmail.com> >>
3201

            
3202
L<http://github.com/yuki-kimoto/DBIx-Custom>
3203

            
removed reconnect method
yuki-kimoto authored on 2010-05-28
3204
=head1 AUTHOR
3205

            
3206
Yuki Kimoto, C<< <kimoto.yuki at gmail.com> >>
version 0.0901
yuki-kimoto authored on 2009-12-17
3207

            
packaging one directory
yuki-kimoto authored on 2009-11-16
3208
=head1 COPYRIGHT & LICENSE
3209

            
cleanup
Yuki Kimoto authored on 2011-01-25
3210
Copyright 2009-2011 Yuki Kimoto, all rights reserved.
packaging one directory
yuki-kimoto authored on 2009-11-16
3211

            
3212
This program is free software; you can redistribute it and/or modify it
3213
under the same terms as Perl itself.
3214

            
3215
=cut