DBIx-Custom / lib / DBIx / Custom.pm /
Newer Older
3203 lines | 83.26kb
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

            
cleanup test
Yuki Kimoto authored on 2011-08-06
4
our $VERSION = '0.1711';
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 { {} },
removed undocumented DBIx::C...
Yuki Kimoto authored on 2011-08-02
54
    query_builder => sub { DBIx::Custom::QueryBuilder->new(dbi => shift) },
update pod
Yuki Kimoto authored on 2011-03-13
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,
sub module use DBIx::Custom ...
Yuki Kimoto authored on 2011-08-02
451
            dbi => $self,
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

            
added EXPERIMENTAL DBIx::Cus...
Yuki Kimoto authored on 2011-08-09
908
sub available_datatype {
simplify type_rule
Yuki Kimoto authored on 2011-06-10
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 DBIx::Cus...
Yuki Kimoto authored on 2011-08-09
924
sub available_typename {
added EXPERIMENTAL available...
Yuki Kimoto authored on 2011-06-14
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

            
sub module use DBIx::Custom ...
Yuki Kimoto authored on 2011-08-02
1076
sub where { DBIx::Custom::Where->new(dbi => shift, @_) }
added experimental DBIx::Cus...
Yuki Kimoto authored on 2011-01-18
1077

            
updated pod
Yuki Kimoto authored on 2011-06-21
1078
sub _create_query {
cleanup
Yuki Kimoto authored on 2011-06-13
1079
    
updated pod
Yuki Kimoto authored on 2011-06-21
1080
    my ($self, $source) = @_;
cleanup
Yuki Kimoto authored on 2011-06-13
1081
    
updated pod
Yuki Kimoto authored on 2011-06-21
1082
    # Cache
1083
    my $cache = $self->cache;
1084
    
1085
    # Query
1086
    my $query;
1087
    
1088
    # Get cached query
1089
    if ($cache) {
cleanup
Yuki Kimoto authored on 2011-06-13
1090
        
updated pod
Yuki Kimoto authored on 2011-06-21
1091
        # Get query
1092
        my $q = $self->cache_method->($self, $source);
cleanup
Yuki Kimoto authored on 2011-06-13
1093
        
updated pod
Yuki Kimoto authored on 2011-06-21
1094
        # Create query
1095
        if ($q) {
1096
            $query = DBIx::Custom::Query->new($q);
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
1097
            $query->{filters} = $self->filters;
cleanup
Yuki Kimoto authored on 2011-06-13
1098
        }
updated pod
Yuki Kimoto authored on 2011-06-21
1099
    }
1100
    
1101
    # Create query
1102
    unless ($query) {
1103

            
1104
        # Create query
1105
        my $builder = $self->query_builder;
1106
        $query = $builder->build_query($source);
1107

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

            
1114
        # Save query to cache
1115
        $self->cache_method->(
1116
            $self, $source,
1117
            {
1118
                sql     => $query->sql, 
1119
                columns => $query->columns,
DBIx::Custom::Query tables a...
Yuki Kimoto authored on 2011-07-30
1120
                tables  => $query->{tables} || []
updated pod
Yuki Kimoto authored on 2011-06-21
1121
            }
1122
        ) if $cache;
cleanup
Yuki Kimoto authored on 2011-06-13
1123
    }
1124
    
added EXPERIMENTAL last_sql ...
Yuki Kimoto authored on 2011-07-11
1125
    # Save sql
1126
    $self->last_sql($query->sql);
1127
    
updated pod
Yuki Kimoto authored on 2011-06-21
1128
    # Prepare statement handle
1129
    my $sth;
1130
    eval { $sth = $self->dbh->prepare($query->{sql})};
1131
    
1132
    if ($@) {
1133
        $self->_croak($@, qq{. Following SQL is executed.\n}
1134
                        . qq{$query->{sql}\n} . _subname);
1135
    }
1136
    
1137
    # Set statement handle
1138
    $query->sth($sth);
1139
    
1140
    # Set filters
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
1141
    $query->{filters} = $self->filters;
updated pod
Yuki Kimoto authored on 2011-06-21
1142
    
1143
    return $query;
cleanup
Yuki Kimoto authored on 2011-06-13
1144
}
1145

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

            
cleanup
Yuki Kimoto authored on 2011-06-08
1196
sub _create_param_from_id {
1197
    my ($self, $id, $primary_keys) = @_;
improved error messages
Yuki Kimoto authored on 2011-04-18
1198
    
cleanup
Yuki Kimoto authored on 2011-06-08
1199
    # Create parameter
1200
    my $param = {};
fixed small insert, update, ...
Yuki Kimoto authored on 2011-06-21
1201
    if (defined $id) {
cleanup
Yuki Kimoto authored on 2011-06-08
1202
        $id = [$id] unless ref $id;
1203
        croak qq{"id" must be constant value or array reference}
improved error messages
Yuki Kimoto authored on 2011-04-18
1204
            . " (" . (caller 1)[3] . ")"
cleanup
Yuki Kimoto authored on 2011-06-08
1205
          unless !ref $id || ref $id eq 'ARRAY';
1206
        croak qq{"id" must contain values same count as primary key}
improved error messages
Yuki Kimoto authored on 2011-04-18
1207
            . " (" . (caller 1)[3] . ")"
cleanup
Yuki Kimoto authored on 2011-06-08
1208
          unless @$primary_keys eq @$id;
improved error messages
Yuki Kimoto authored on 2011-04-18
1209
        for(my $i = 0; $i < @$primary_keys; $i ++) {
cleanup
Yuki Kimoto authored on 2011-06-08
1210
           $param->{$primary_keys->[$i]} = $id->[$i];
improved error messages
Yuki Kimoto authored on 2011-04-18
1211
        }
1212
    }
1213
    
cleanup
Yuki Kimoto authored on 2011-06-08
1214
    return $param;
improved error messages
Yuki Kimoto authored on 2011-04-18
1215
}
1216

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

            
cleanup
yuki-kimoto authored on 2010-10-17
1250
sub _croak {
1251
    my ($self, $error, $append) = @_;
cleanup
Yuki Kimoto authored on 2011-04-02
1252
    
1253
    # Append
cleanup
yuki-kimoto authored on 2010-10-17
1254
    $append ||= "";
1255
    
1256
    # Verbose
1257
    if ($Carp::Verbose) { croak $error }
1258
    
1259
    # Not verbose
1260
    else {
1261
        
1262
        # Remove line and module infromation
1263
        my $at_pos = rindex($error, ' at ');
1264
        $error = substr($error, 0, $at_pos);
1265
        $error =~ s/\s+$//;
1266
        croak "$error$append";
1267
    }
1268
}
1269

            
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
1270
sub _need_tables {
1271
    my ($self, $tree, $need_tables, $tables) = @_;
1272
    
cleanup
Yuki Kimoto authored on 2011-04-02
1273
    # Get needed tables
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
1274
    foreach my $table (@$tables) {
1275
        if ($tree->{$table}) {
1276
            $need_tables->{$table} = 1;
1277
            $self->_need_tables($tree, $need_tables, [$tree->{$table}{parent}])
1278
        }
1279
    }
1280
}
1281

            
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
1282
sub _push_join {
1283
    my ($self, $sql, $join, $join_tables) = @_;
1284
    
cleanup
Yuki Kimoto authored on 2011-04-02
1285
    # No join
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
1286
    return unless @$join;
1287
    
cleanup
Yuki Kimoto authored on 2011-04-02
1288
    # Push join clause
fixed some select() join opi...
Yuki Kimoto authored on 2011-03-09
1289
    my $tree = {};
1290
    for (my $i = 0; $i < @$join; $i++) {
1291
        
cleanup
Yuki Kimoto authored on 2011-07-28
1292
        # Arrange
added join new syntax
Yuki Kimoto authored on 2011-07-28
1293
        my $join_clause;;
1294
        my $option;
1295
        if (ref $join->[$i] eq 'HASH') {
1296
            $join_clause = $join->[$i]->{clause};
1297
            $option = {table => $join->[$i]->{table}};
1298
        }
1299
        else {
1300
            $join_clause = $join->[$i];
1301
            $option = {};
1302
        };
cleanup
Yuki Kimoto authored on 2011-07-28
1303

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

            
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1347
sub _quote {
1348
    my $self = shift;
1349
    
1350
    return defined $self->reserved_word_quote ? $self->reserved_word_quote
1351
         : defined $self->quote ? $self->quote
1352
         : '';
1353
}
1354

            
cleanup
Yuki Kimoto authored on 2011-07-29
1355
sub _q {
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
1356
    my ($self, $value) = @_;
cleanup
Yuki Kimoto authored on 2011-07-29
1357
    
1358
    my $quote = $self->_quote;
1359
    my $q = substr($quote, 0, 1) || '';
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
1360
    my $p;
1361
    if (defined $quote && length $quote > 1) {
1362
        $p = substr($quote, 1, 1);
1363
    }
1364
    else { $p = $q }
cleanup
Yuki Kimoto authored on 2011-07-29
1365
    
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
1366
    return "$q$value$p";
cleanup
Yuki Kimoto authored on 2011-07-29
1367
}
1368

            
cleanup
Yuki Kimoto authored on 2011-04-02
1369
sub _remove_duplicate_table {
1370
    my ($self, $tables, $main_table) = @_;
1371
    
1372
    # Remove duplicate table
1373
    my %tables = map {defined $_ ? ($_ => 1) : ()} @$tables;
1374
    delete $tables{$main_table} if $main_table;
1375
    
micro optimization
Yuki Kimoto authored on 2011-07-30
1376
    my $new_tables = [keys %tables, $main_table ? $main_table : ()];
1377
    if (my $q = $self->_quote) {
1378
        $q = quotemeta($q);
1379
        $_ =~ s/[$q]//g for @$new_tables;
1380
    }
1381

            
1382
    return $new_tables;
cleanup
Yuki Kimoto authored on 2011-04-02
1383
}
1384

            
cleanup
Yuki Kimoto authored on 2011-04-02
1385
sub _search_tables {
cleanup
Yuki Kimoto authored on 2011-04-02
1386
    my ($self, $source) = @_;
1387
    
cleanup
Yuki Kimoto authored on 2011-04-02
1388
    # Search tables
cleanup
Yuki Kimoto authored on 2011-04-02
1389
    my $tables = [];
1390
    my $safety_character = $self->safety_character;
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1391
    my $q = $self->_quote;
cleanup
Yuki Kimoto authored on 2011-04-02
1392
    my $q_re = quotemeta($q);
added quote method's two cha...
Yuki Kimoto authored on 2011-07-29
1393
    my $quoted_safety_character_re = $self->_q("?([$safety_character]+)");
1394
    my $table_re = $q ? qr/(?:^|[^$safety_character])$quoted_safety_character_re?\./
improved table search in col...
Yuki Kimoto authored on 2011-04-12
1395
                      : qr/(?:^|[^$safety_character])([$safety_character]+)\./;
cleanup
Yuki Kimoto authored on 2011-04-02
1396
    while ($source =~ /$table_re/g) {
1397
        push @$tables, $1;
1398
    }
1399
    
1400
    return $tables;
1401
}
1402

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

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

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

            
1512
# DEPRECATED!
1513
sub create_query {
1514
    warn "create_query is DEPRECATED! use query option of each method";
1515
    shift->_create_query(@_);
1516
}
1517

            
cleanup
Yuki Kimoto authored on 2011-06-13
1518
# DEPRECATED!
1519
sub apply_filter {
1520
    my $self = shift;
1521
    
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
1522
    warn "apply_filter is DEPRECATED!";
cleanup
Yuki Kimoto authored on 2011-06-13
1523
    return $self->_apply_filter(@_);
1524
}
1525

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

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

            
select_at is DEPRECATED! use...
Yuki Kimoto authored on 2011-06-08
1533
    # Arguments
1534
    my $primary_keys = delete $args{primary_key};
1535
    $primary_keys = [$primary_keys] unless ref $primary_keys;
1536
    my $where = delete $args{where};
1537
    my $param = delete $args{param};
1538
    
1539
    # Check arguments
1540
    foreach my $name (keys %args) {
1541
        croak qq{"$name" is wrong option } . _subname
1542
          unless $SELECT_AT_ARGS{$name};
1543
    }
1544
    
1545
    # Table
1546
    croak qq{"table" option must be specified } . _subname
1547
      unless $args{table};
1548
    my $table = ref $args{table} ? $args{table}->[-1] : $args{table};
1549
    
1550
    # Create where parameter
1551
    my $where_param = $self->_create_param_from_id($where, $primary_keys);
1552
    
1553
    return $self->select(where => $where_param, %args);
1554
}
1555

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

            
1561
    warn "delete_at is DEPRECATED! use update and id option instead";
delete_at is DEPRECATED! use...
Yuki Kimoto authored on 2011-06-08
1562
    
1563
    # Arguments
1564
    my $primary_keys = delete $args{primary_key};
1565
    $primary_keys = [$primary_keys] unless ref $primary_keys;
1566
    my $where = delete $args{where};
1567
    
1568
    # Check arguments
1569
    foreach my $name (keys %args) {
1570
        croak qq{"$name" is wrong option } . _subname
1571
          unless $DELETE_AT_ARGS{$name};
1572
    }
1573
    
1574
    # Create where parameter
1575
    my $where_param = $self->_create_param_from_id($where, $primary_keys);
1576
    
1577
    return $self->delete(where => $where_param, %args);
1578
}
1579

            
cleanup
Yuki Kimoto authored on 2011-06-08
1580
# DEPRECATED!
simplified arguments check
Yuki Kimoto authored on 2011-07-11
1581
our %UPDATE_AT_ARGS = (%VALID_ARGS, where => 1, primary_key => 1);
cleanup
Yuki Kimoto authored on 2011-06-08
1582
sub update_at {
1583
    my $self = shift;
1584

            
1585
    warn "update_at is DEPRECATED! use update and id option instead";
1586
    
1587
    # Arguments
1588
    my $param;
1589
    $param = shift if @_ % 2;
1590
    my %args = @_;
1591
    my $primary_keys = delete $args{primary_key};
1592
    $primary_keys = [$primary_keys] unless ref $primary_keys;
1593
    my $where = delete $args{where};
1594
    my $p = delete $args{param} || {};
1595
    $param  ||= $p;
1596
    
1597
    # Check arguments
1598
    foreach my $name (keys %args) {
1599
        croak qq{"$name" is wrong option } . _subname
1600
          unless $UPDATE_AT_ARGS{$name};
1601
    }
1602
    
1603
    # Create where parameter
1604
    my $where_param = $self->_create_param_from_id($where, $primary_keys);
1605
    
1606
    return $self->update(where => $where_param, param => $param, %args);
1607
}
1608

            
insert_at is DEPRECATED! add...
Yuki Kimoto authored on 2011-06-08
1609
# DEPRECATED!
simplified arguments check
Yuki Kimoto authored on 2011-07-11
1610
our %INSERT_AT_ARGS = (%VALID_ARGS, where => 1, primary_key => 1);
insert_at is DEPRECATED! add...
Yuki Kimoto authored on 2011-06-08
1611
sub insert_at {
1612
    my $self = shift;
1613
    
1614
    warn "insert_at is DEPRECATED! use insert and id option instead";
1615
    
1616
    # Arguments
1617
    my $param;
1618
    $param = shift if @_ % 2;
1619
    my %args = @_;
1620
    my $primary_key = delete $args{primary_key};
1621
    $primary_key = [$primary_key] unless ref $primary_key;
1622
    my $where = delete $args{where};
1623
    my $p = delete $args{param} || {};
1624
    $param  ||= $p;
1625
    
1626
    # Check arguments
1627
    foreach my $name (keys %args) {
1628
        croak qq{"$name" is wrong option } . _subname
1629
          unless $INSERT_AT_ARGS{$name};
1630
    }
1631
    
1632
    # Create where parameter
cleanup
Yuki Kimoto authored on 2011-06-08
1633
    my $where_param = $self->_create_param_from_id($where, $primary_key);
insert_at is DEPRECATED! add...
Yuki Kimoto authored on 2011-06-08
1634
    $param = $self->merge_param($where_param, $param);
1635
    
1636
    return $self->insert(param => $param, %args);
1637
}
1638

            
added warnings
Yuki Kimoto authored on 2011-06-07
1639
# DEPRECATED!
1640
sub register_tag {
1641
    warn "register_tag is DEPRECATED!";
1642
    shift->query_builder->register_tag(@_)
1643
}
1644

            
data_source is DEPRECATED! I...
Yuki Kimoto authored on 2011-06-06
1645
# DEPRECATED!
cleanup
Yuki Kimoto authored on 2011-06-13
1646
has 'data_source';
reserved_word_quote is DEPRE...
Yuki Kimoto authored on 2011-06-17
1647
has dbi_options => sub { {} };
1648
has filter_check  => 1;
1649
has 'reserved_word_quote';
renamed dbi_options to dbi_o...
Yuki Kimoto authored on 2011-01-23
1650

            
cleanup
Yuki Kimoto authored on 2011-01-25
1651
# DEPRECATED!
cleanup
Yuki Kimoto authored on 2011-01-12
1652
sub default_bind_filter {
1653
    my $self = shift;
1654
    
cleanup
Yuki Kimoto authored on 2011-06-13
1655
    warn "default_bind_filter is DEPRECATED!";
added warnings
Yuki Kimoto authored on 2011-06-07
1656
    
cleanup
Yuki Kimoto authored on 2011-01-12
1657
    if (@_) {
1658
        my $fname = $_[0];
1659
        
1660
        if (@_ && !$fname) {
1661
            $self->{default_out_filter} = undef;
1662
        }
1663
        else {
many changed
Yuki Kimoto authored on 2011-01-23
1664
            croak qq{Filter "$fname" is not registered}
cleanup
Yuki Kimoto authored on 2011-01-12
1665
              unless exists $self->filters->{$fname};
1666
        
1667
            $self->{default_out_filter} = $self->filters->{$fname};
1668
        }
1669
        return $self;
1670
    }
1671
    
1672
    return $self->{default_out_filter};
1673
}
1674

            
cleanup
Yuki Kimoto authored on 2011-01-25
1675
# DEPRECATED!
cleanup
Yuki Kimoto authored on 2011-01-12
1676
sub default_fetch_filter {
1677
    my $self = shift;
added warnings
Yuki Kimoto authored on 2011-06-07
1678

            
cleanup
Yuki Kimoto authored on 2011-06-13
1679
    warn "default_fetch_filter is DEPRECATED!";
cleanup
Yuki Kimoto authored on 2011-01-12
1680
    
1681
    if (@_) {
many changed
Yuki Kimoto authored on 2011-01-23
1682
        my $fname = $_[0];
1683

            
cleanup
Yuki Kimoto authored on 2011-01-12
1684
        if (@_ && !$fname) {
1685
            $self->{default_in_filter} = undef;
1686
        }
1687
        else {
many changed
Yuki Kimoto authored on 2011-01-23
1688
            croak qq{Filter "$fname" is not registered}
cleanup
Yuki Kimoto authored on 2011-01-12
1689
              unless exists $self->filters->{$fname};
1690
        
1691
            $self->{default_in_filter} = $self->filters->{$fname};
1692
        }
1693
        
1694
        return $self;
1695
    }
1696
    
many changed
Yuki Kimoto authored on 2011-01-23
1697
    return $self->{default_in_filter};
cleanup
Yuki Kimoto authored on 2011-01-12
1698
}
1699

            
- renamed update_param to up...
Yuki Kimoto authored on 2011-03-30
1700
# DEPRECATED!
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
1701
sub insert_param_tag {
1702
    warn "insert_param_tag is DEPRECATED! " .
1703
         "use insert_param instead!";
1704
    return shift->insert_param(@_);
- renamed update_param to up...
Yuki Kimoto authored on 2011-03-30
1705
}
1706

            
cleanup
Yuki Kimoto authored on 2011-01-25
1707
# DEPRECATED!
renamed DBIx::Custom::TagPro...
Yuki Kimoto authored on 2011-01-24
1708
sub register_tag_processor {
added warnings
Yuki Kimoto authored on 2011-06-07
1709
    warn "register_tag_processor is DEPRECATED!";
renamed DBIx::Custom::TagPro...
Yuki Kimoto authored on 2011-01-24
1710
    return shift->query_builder->register_tag_processor(@_);
1711
}
1712

            
- renamed update_param to up...
Yuki Kimoto authored on 2011-03-30
1713
# DEPRECATED!
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
1714
sub update_param_tag {
fixed DEPRECATED message bug
Yuki Kimoto authored on 2011-06-10
1715
    warn "update_param_tag is DEPRECATED! " .
- update_param_tag is DEPREC...
Yuki Kimoto authored on 2011-06-07
1716
         "use update_param instead";
1717
    return shift->update_param(@_);
- renamed update_param to up...
Yuki Kimoto authored on 2011-03-30
1718
}
cleanup
Yuki Kimoto authored on 2011-03-08
1719
# DEPRECATED!
1720
sub _push_relation {
1721
    my ($self, $sql, $tables, $relation, $need_where) = @_;
1722
    
1723
    if (keys %{$relation || {}}) {
1724
        push @$sql, $need_where ? 'where' : 'and';
1725
        foreach my $rcolumn (keys %$relation) {
1726
            my $table1 = (split (/\./, $rcolumn))[0];
1727
            my $table2 = (split (/\./, $relation->{$rcolumn}))[0];
1728
            push @$tables, ($table1, $table2);
1729
            push @$sql, ("$rcolumn = " . $relation->{$rcolumn},  'and');
1730
        }
1731
    }
1732
    pop @$sql if $sql->[-1] eq 'and';    
1733
}
1734

            
1735
# DEPRECATED!
1736
sub _add_relation_table {
cleanup
Yuki Kimoto authored on 2011-03-09
1737
    my ($self, $tables, $relation) = @_;
cleanup
Yuki Kimoto authored on 2011-03-08
1738
    
1739
    if (keys %{$relation || {}}) {
1740
        foreach my $rcolumn (keys %$relation) {
1741
            my $table1 = (split (/\./, $rcolumn))[0];
1742
            my $table2 = (split (/\./, $relation->{$rcolumn}))[0];
1743
            my $table1_exists;
1744
            my $table2_exists;
1745
            foreach my $table (@$tables) {
1746
                $table1_exists = 1 if $table eq $table1;
1747
                $table2_exists = 1 if $table eq $table2;
1748
            }
1749
            unshift @$tables, $table1 unless $table1_exists;
1750
            unshift @$tables, $table2 unless $table2_exists;
1751
        }
1752
    }
1753
}
1754

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

            
removed reconnect method
yuki-kimoto authored on 2010-05-28
1757
=head1 NAME
1758

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

            
1761
=head1 SYNOPSYS
cleanup
yuki-kimoto authored on 2010-08-05
1762

            
renamed build_query to creat...
yuki-kimoto authored on 2010-08-06
1763
    use DBIx::Custom;
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1764
    
1765
    # Connect
1766
    my $dbi = DBIx::Custom->connect(
data_source is DEPRECATED! I...
Yuki Kimoto authored on 2011-06-06
1767
        dsn => "dbi:mysql:database=dbname",
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1768
        user => 'ken',
1769
        password => '!LFKD%$&',
1770
        dbi_option => {mysql_enable_utf8 => 1}
1771
    );
cleanup
yuki-kimoto authored on 2010-08-05
1772

            
removed reconnect method
yuki-kimoto authored on 2010-05-28
1773
    # Insert 
updated pod
Yuki Kimoto authored on 2011-06-21
1774
    $dbi->insert({title => 'Perl', author => 'Ken'}, table  => 'book');
removed reconnect method
yuki-kimoto authored on 2010-05-28
1775
    
1776
    # Update 
updated pod
Yuki Kimoto authored on 2011-06-21
1777
    $dbi->update({title => 'Perl', author => 'Ken'}, table  => 'book',
1778
      where  => {id => 5});
removed reconnect method
yuki-kimoto authored on 2010-05-28
1779
    
1780
    # Delete
updated pod
Yuki Kimoto authored on 2011-06-21
1781
    $dbi->delete(table  => 'book', where => {author => 'Ken'});
cleanup
yuki-kimoto authored on 2010-08-05
1782

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

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

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

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

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

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

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

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

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

            
micro optimization
Yuki Kimoto authored on 2011-07-30
1832
Named place holder support
1833

            
1834
=item *
1835

            
cleanup
Yuki Kimoto authored on 2011-07-29
1836
Model support
1837

            
1838
=item *
1839

            
1840
Connection manager support
1841

            
1842
=item *
pod fix
Yuki Kimoto authored on 2011-01-21
1843

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

            
1848
=item *
1849

            
1850
Filtering by data type or column name(EXPERIMENTAL)
1851

            
1852
=item *
1853

            
1854
Create C<order by> clause flexibly(EXPERIMENTAL)
1855

            
1856
=back
pod fix
Yuki Kimoto authored on 2011-01-21
1857

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

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

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

            
micro optimization
Yuki Kimoto authored on 2011-07-30
1865
Module documentations - 
cleanup
Yuki Kimoto authored on 2011-07-29
1866
L<DBIx::Custom::Result>,
1867
L<DBIx::Custom::Query>,
1868
L<DBIx::Custom::Where>,
1869
L<DBIx::Custom::Model>,
1870
L<DBIx::Custom::Order>
updated document
yuki-kimoto authored on 2010-08-08
1871

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

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

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

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

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

            
1885
    my $connector = DBIx::Connector->new(
1886
        "dbi:mysql:database=$DATABASE",
1887
        $USER,
1888
        $PASSWORD,
1889
        DBIx::Custom->new->default_dbi_option
1890
    );
1891
    
updated pod
Yuki Kimoto authored on 2011-06-21
1892
    my $dbi = DBIx::Custom->connect(connector => $connector);
- removed EXPERIMENTAL Prefo...
Yuki Kimoto authored on 2011-04-04
1893

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

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

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

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

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

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

            
1909
=head2 C<default_dbi_option>
1910

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

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

            
- remaned experimental safty...
Yuki Kimoto authored on 2011-03-10
1917
    {
1918
        RaiseError => 1,
1919
        PrintError => 0,
1920
        AutoCommit => 1,
1921
    }
packaging one directory
yuki-kimoto authored on 2009-11-16
1922

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

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

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

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

            
1932
    my $last_sql = $dbi->last_sql;
1933
    $dbi = $dbi->last_sql($last_sql);
1934

            
1935
Get last successed SQL executed by C<execute> method.
1936

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

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

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

            
cleanup
yuki-kimoto authored on 2010-10-17
1944
=head2 C<password>
1945

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

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

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

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

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

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

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

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

            
cleanup
Yuki Kimoto authored on 2011-07-30
1967
You can set quote pair.
1968

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

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

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

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

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

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

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

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

            
1988
    my $tag_parse = $dbi->tag_parse(0);
1989
    $dbi = $dbi->tag_parse;
1990

            
1991
Enable DEPRECATED tag parsing functionality, default to 1.
1992
If you want to disable tag parsing functionality, set to 0.
1993

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

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

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

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

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

            
added EXPERIMENTAL DBIx::Cus...
Yuki Kimoto authored on 2011-08-09
2007
=head2 C<available_datatype> EXPERIMENTAL
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2008

            
added EXPERIMENTAL DBIx::Cus...
Yuki Kimoto authored on 2011-08-09
2009
    print $dbi->available_datatype;
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2010

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

            
added EXPERIMENTAL DBIx::Cus...
Yuki Kimoto authored on 2011-08-09
2014
=head2 C<available_typename> EXPERIMENTAL
added EXPERIMENTAL available...
Yuki Kimoto authored on 2011-06-14
2015

            
added EXPERIMENTAL DBIx::Cus...
Yuki Kimoto authored on 2011-08-09
2016
    print $dbi->available_typename;
added EXPERIMENTAL available...
Yuki Kimoto authored on 2011-06-14
2017

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

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

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

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

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

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

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

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

            
2035
Create column clause. The follwoing column clause is created.
2036

            
2037
    book.author as "book.author",
2038
    book.title as "book.title"
2039

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

            
cleanup
Yuki Kimoto authored on 2011-06-13
2042
    # Separator is double underbar
2043
    $dbi->separator('__');
2044
    
2045
    book.author as "book__author",
2046
    book.title as "book__title"
- select() EXPERIMETNAL colu...
Yuki Kimoto authored on 2011-06-08
2047

            
cleanup
Yuki Kimoto authored on 2011-06-13
2048
    # Separator is hyphen
2049
    $dbi->separator('-');
2050
    
2051
    book.author as "book-author",
2052
    book.title as "book-title"
2053
    
removed DBIx::Custom commit ...
yuki-kimoto authored on 2010-07-14
2054
=head2 C<connect>
packaging one directory
yuki-kimoto authored on 2009-11-16
2055

            
update pod
Yuki Kimoto authored on 2011-03-13
2056
    my $dbi = DBIx::Custom->connect(
data_source is DEPRECATED! I...
Yuki Kimoto authored on 2011-06-06
2057
        dsn => "dbi:mysql:database=dbname",
update pod
Yuki Kimoto authored on 2011-03-13
2058
        user => 'ken',
2059
        password => '!LFKD%$&',
2060
        dbi_option => {mysql_enable_utf8 => 1}
2061
    );
2062

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

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

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

            
adeed EXPERIMENTAL DBIx::Cus...
Yuki Kimoto authored on 2011-03-29
2071
    my $model = $dbi->create_model(
removed EXPERIMETNAL flag fr...
Yuki Kimoto authored on 2011-03-25
2072
        table => 'book',
2073
        primary_key => 'id',
2074
        join => [
2075
            'inner join company on book.comparny_id = company.id'
2076
        ],
2077
    );
2078

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

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

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

            
2086
    my $dbh = $dbi->dbh;
2087

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

            
2091
=head2 C<each_column>
2092

            
2093
    $dbi->each_column(
2094
        sub {
2095
            my ($dbi, $table, $column, $column_info) = @_;
2096
            
2097
            my $type = $column_info->{TYPE_NAME};
2098
            
2099
            if ($type eq 'DATE') {
2100
                # ...
2101
            }
2102
        }
2103
    );
2104

            
2105
Iterate all column informations of all table from database.
2106
Argument is callback when one column is found.
2107
Callback receive four arguments, dbi object, table name,
2108
column name and column information.
EXPERIMETAL fork safety impl...
Yuki Kimoto authored on 2011-03-12
2109

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

            
2112
    $dbi->each_table(
2113
        sub {
2114
            my ($dbi, $table, $table_info) = @_;
2115
            
2116
            my $table_name = $table_info->{TABLE_NAME};
2117
        }
2118
    );
2119

            
2120
Iterate all table informationsfrom database.
2121
Argument is callback when one table is found.
2122
Callback receive three arguments, dbi object, table name,
2123
table information.
2124

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

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

            
2132
    my $result = $dbi->execute(
2133
      "select * from book where title = :book.title and author like :book.author",
2134
      {'book.title' => 'Perl', 'book.author' => '%Ken%'}
update pod
Yuki Kimoto authored on 2011-03-13
2135
    );
2136

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

            
I call :title named placehol...
Yuki Kimoto authored on 2011-07-30
2143
Named placeholder such as C<:title> is replaced by placeholder C<?>.
added EXPERIMENTAL parameter...
Yuki Kimoto authored on 2011-07-29
2144
    
micro optimization
Yuki Kimoto authored on 2011-07-30
2145
    # Original
added EXPERIMENTAL parameter...
Yuki Kimoto authored on 2011-07-29
2146
    select * from book where title = :title and author like :author
2147
    
micro optimization
Yuki Kimoto authored on 2011-07-30
2148
    # Replaced
added EXPERIMENTAL parameter...
Yuki Kimoto authored on 2011-07-29
2149
    select * from where title = ? and author like ?;
update pod
Yuki Kimoto authored on 2011-03-13
2150

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

            
micro optimization
Yuki Kimoto authored on 2011-07-30
2154
    # Original
added EXPERIMENTAL parameter...
Yuki Kimoto authored on 2011-07-29
2155
    select * from book where :title{=} and :author{like}
2156
    
micro optimization
Yuki Kimoto authored on 2011-07-30
2157
    # Replaced
update pod
Yuki Kimoto authored on 2011-03-13
2158
    select * from where title = ? and author like ?;
2159

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

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

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

            
2168
=over 4
2169

            
2170
=item C<filter>
updated pod
Yuki Kimoto authored on 2011-06-09
2171
    
2172
    filter => {
2173
        title  => sub { uc $_[0] }
2174
        author => sub { uc $_[0] }
2175
    }
update pod
Yuki Kimoto authored on 2011-03-13
2176

            
updated pod
Yuki Kimoto authored on 2011-06-09
2177
    # Filter name
2178
    filter => {
2179
        title  => 'upper_case',
2180
        author => 'upper_case'
2181
    }
2182
        
2183
    # At once
2184
    filter => [
2185
        [qw/title author/]  => sub { uc $_[0] }
2186
    ]
2187

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

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

            
2195
    query => 1
2196

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

            
2200
    my $sql = $query->sql;
cleanup
Yuki Kimoto authored on 2011-07-30
2201
    my $sth = $query->sth;
Added execute method's query...
Yuki Kimoto authored on 2011-07-30
2202
    my $columns = $query->columns;
2203
    
2204
If you want to execute SQL fast, you can do the following way.
2205

            
2206
    my $query;
2207
    foreach my $row (@$rows) {
2208
      $query ||= $dbi->insert($row, table => 'table1', query => 1);
2209
      $dbi->execute($query, $row, filter => {ab => sub { $_[0] * 2 }});
2210
    }
2211

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

            
2215
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
2216
You can do the following way.
cleanup
Yuki Kimoto authored on 2011-07-30
2217
    
2218
    my $query;
2219
    my $sth;
2220
    foreach my $row (@$rows) {
2221
      $query ||= $dbi->insert($row, table => 'book', query => 1);
2222
      $sth ||= $query->sth;
2223
      $sth->execute(map { $row->{$_} } sort keys %$row);
2224
    }
2225

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

            
updated pod
Yuki Kimoto authored on 2011-06-09
2230
=item C<table>
2231
    
2232
    table => 'author'
2233

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

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

            
updated pod
Yuki Kimoto authored on 2011-06-21
2241
    # Same
2242
    $dbi->execute(
2243
      "select * from book where title = :book.title and author = :book.author",
2244
      {title => 'Perl', author => 'Ken');
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2245

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

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

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

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

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

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

            
2259
    table_alias => {user => 'hiker'}
2260

            
2261
Table alias. Key is real table name, value is alias table name.
2262
If you set C<table_alias>, you can enable C<into1> and C<into2> type rule
2263
on alias table name.
2264

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

            
2267
    type_rule_off => 1
2268

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

            
2271
=item C<type_rule1_off> EXPERIMENTAL
2272

            
2273
    type_rule1_off => 1
2274

            
2275
Turn C<into1> type rule off.
2276

            
2277
=item C<type_rule2_off> EXPERIMENTAL
2278

            
2279
    type_rule2_off => 1
2280

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

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

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

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

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

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

            
update pod
Yuki Kimoto authored on 2011-03-13
2293
=over 4
2294

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

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

            
2299
=item C<filter>
2300

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

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

            
updated document
Yuki Kimoto authored on 2011-06-09
2305
    id => 4
2306
    id => [4, 5]
update pod
Yuki Kimoto authored on 2011-03-13
2307

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

            
updated document
Yuki Kimoto authored on 2011-06-09
2311
    $dbi->delete(
2312
        parimary_key => ['id1', 'id2'],
2313
        id => [4, 5],
2314
        table => 'book',
2315
    );
update pod
Yuki Kimoto authored on 2011-03-13
2316

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

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

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

            
2323
    prefix => 'some'
2324

            
2325
prefix before table name section.
2326

            
2327
    delete some from book
2328

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

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

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

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

            
updated pod
Yuki Kimoto authored on 2011-06-21
2337
Table name.
2338

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

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

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

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

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

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

            
2351
=item C<type_rule_off> EXPERIMENTAL
2352

            
2353
Same as C<execute> method's C<type_rule_off> option.
2354

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

            
2357
    type_rule1_off => 1
2358

            
2359
Same as C<execute> method's C<type_rule1_off> option.
2360

            
2361
=item C<type_rule2_off> EXPERIMENTAL
2362

            
2363
    type_rule2_off => 1
2364

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

            
updated pod
Yuki Kimoto authored on 2011-06-08
2367
=back
update pod
Yuki Kimoto authored on 2011-03-13
2368

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

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

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

            
cleanup
yuki-kimoto authored on 2010-10-17
2376
=head2 C<insert>
2377

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

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

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

            
2386
    {date => \"NOW()"}
2387

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

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

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

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

            
2396
=item C<filter>
2397

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

            
2400
=item C<id>
2401

            
updated document
Yuki Kimoto authored on 2011-06-09
2402
    id => 4
2403
    id => [4, 5]
update pod
Yuki Kimoto authored on 2011-03-13
2404

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

            
update pod
Yuki Kimoto authored on 2011-03-13
2408
    $dbi->insert(
updated document
Yuki Kimoto authored on 2011-06-09
2409
        {title => 'Perl', author => 'Ken'}
2410
        parimary_key => ['id1', 'id2'],
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2411
        id => [4, 5],
updated document
Yuki Kimoto authored on 2011-06-09
2412
        table => 'book'
update pod
Yuki Kimoto authored on 2011-03-13
2413
    );
added EXPERIMENTAL execute()...
Yuki Kimoto authored on 2011-06-09
2414

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

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

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

            
2424
    prefix => 'or replace'
2425

            
2426
prefix before table name section
2427

            
2428
    insert or replace into book
2429

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

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

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

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

            
2439
Same as C<execute> method's C<query> option.
2440

            
2441
=item C<table>
2442

            
2443
    table => 'book'
2444

            
2445
Table name.
2446

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

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

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

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

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

            
2457
    type_rule1_off => 1
2458

            
2459
Same as C<execute> method's C<type_rule1_off> option.
2460

            
2461
=item C<type_rule2_off> EXPERIMENTAL
2462

            
2463
    type_rule2_off => 1
2464

            
2465
Same as C<execute> method's C<type_rule2_off> option.
2466

            
update pod
Yuki Kimoto authored on 2011-03-13
2467
=back
2468

            
2469
=over 4
2470

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

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

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

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

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

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

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

            
update pod
Yuki Kimoto authored on 2011-03-13
2486
    lib / MyModel.pm
2487
        / MyModel / book.pm
2488
                  / company.pm
add feture. all model class ...
Yuki Kimoto authored on 2011-02-18
2489

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

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

            
2494
    package MyModel;
updated pod
Yuki Kimoto authored on 2011-06-21
2495
    use DBIx::Custom::Model -base;
update pod
Yuki Kimoto authored on 2011-03-13
2496
    
2497
    1;
add feture. all model class ...
Yuki Kimoto authored on 2011-02-18
2498

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

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

            
update pod
Yuki Kimoto authored on 2011-03-13
2503
    package MyModel::book;
updated pod
Yuki Kimoto authored on 2011-06-21
2504
    use MyModel -base;
update pod
Yuki Kimoto authored on 2011-03-13
2505
    
2506
    1;
removed experimental base_ta...
Yuki Kimoto authored on 2011-02-15
2507

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

            
update pod
Yuki Kimoto authored on 2011-03-13
2510
    package MyModel::company;
updated pod
Yuki Kimoto authored on 2011-06-21
2511
    use MyModel -base;
update pod
Yuki Kimoto authored on 2011-03-13
2512
    
2513
    1;
2514
    
updated pod
Yuki Kimoto authored on 2011-06-21
2515
MyModel::book and MyModel::company is included by C<include_model>.
removed experimental base_ta...
Yuki Kimoto authored on 2011-02-15
2516

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

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

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

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

            
2526
    my $map_param = $dbi->map_param(
2527
        {id => 1, authro => 'Ken', price => 1900},
2528
        'id' => 'book.id',
2529
        'author' => ['book.author' => sub { '%' . $_[0] . '%' }],
2530
        'price' => [
2531
            'book.price', {if => sub { length $_[0] }}
2532
        ]
2533
    );
2534

            
2535
Map paramters to other key and value. First argument is original
2536
parameter. this is hash reference. Rest argument is mapping.
2537
By default, Mapping is done if the value length is not zero.
2538

            
2539
=over 4
2540

            
2541
=item Key mapping
2542

            
2543
    'id' => 'book.id'
2544

            
2545
This is only key mapping. Value is same as original one.
2546

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

            
2549
=item Key and value mapping
2550

            
2551
    'author' => ['book.author' => sub { '%' . $_[0] . '%' }]
2552

            
2553
This is key and value mapping. Frist element of array reference
2554
is mapped key name, second element is code reference to map the value.
2555

            
2556
    (author => 'Ken') is mapped to ('book.author' => '%Ken%')
2557
      if value length is not zero.
2558

            
2559
=item Condition
2560

            
2561
    'price' => ['book.price', {if => 'exists'}]
2562
    'price' => ['book.price', sub { '%' . $_[0] . '%' }, {if => 'exists'}]
2563
    'price' => ['book.price', {if => sub { defined shift }}]
2564

            
2565
If you need condition, you can sepecify it. this is code reference
2566
or 'exists'. By default, condition is the following one.
2567

            
2568
    sub { defined $_[0] && length $_[0] }
2569

            
2570
=back
2571

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

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

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

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

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

            
2582
    $dbi->method(
2583
        update_or_insert => sub {
2584
            my $self = shift;
update pod
Yuki Kimoto authored on 2011-03-13
2585
            
2586
            # Process
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
2587
        },
2588
        find_or_create   => sub {
2589
            my $self = shift;
update pod
Yuki Kimoto authored on 2011-03-13
2590
            
2591
            # Process
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
2592
        }
2593
    );
2594

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

            
2597
    $dbi->update_or_insert;
2598
    $dbi->find_or_create;
2599

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

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

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

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

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

            
2610
Create column clause for myself. The follwoing column clause is created.
2611

            
2612
    book.author as author,
2613
    book.title as title
2614

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

            
update pod
Yuki Kimoto authored on 2011-03-13
2617
    my $dbi = DBIx::Custom->new(
data_source is DEPRECATED! I...
Yuki Kimoto authored on 2011-06-06
2618
        dsn => "dbi:mysql:database=dbname",
update pod
Yuki Kimoto authored on 2011-03-13
2619
        user => 'ken',
2620
        password => '!LFKD%$&',
2621
        dbi_option => {mysql_enable_utf8 => 1}
2622
    );
added experimental not_exist...
Yuki Kimoto authored on 2011-01-26
2623

            
2624
Create a new L<DBIx::Custom> object.
2625

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

            
2628
    my $not_exists = $dbi->not_exists;
2629

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

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

            
2635
    my $order = $dbi->order;
2636

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

            
cleanup
yuki-kimoto authored on 2010-10-17
2639
=head2 C<register_filter>
2640

            
update pod
Yuki Kimoto authored on 2011-03-13
2641
    $dbi->register_filter(
2642
        # Time::Piece object to database DATE format
2643
        tp_to_date => sub {
2644
            my $tp = shift;
2645
            return $tp->strftime('%Y-%m-%d');
2646
        },
2647
        # database DATE format to Time::Piece object
2648
        date_to_tp => sub {
2649
           my $date = shift;
2650
           return Time::Piece->strptime($date, '%Y-%m-%d');
2651
        }
2652
    );
cleanup
yuki-kimoto authored on 2010-10-17
2653
    
update pod
Yuki Kimoto authored on 2011-03-13
2654
Register filters, used by C<filter> option of many methods.
cleanup
yuki-kimoto authored on 2010-10-17
2655

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

            
2658
    $dbi->type_rule(
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2659
        into1 => {
separate DBIx::Custom type_r...
Yuki Kimoto authored on 2011-06-15
2660
            date => sub { ... },
2661
            datetime => sub { ... }
added type_rule into logic
Yuki Kimoto authored on 2011-06-09
2662
        },
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2663
        into2 => {
2664
            date => sub { ... },
2665
            datetime => sub { ... }
2666
        },
2667
        from1 => {
2668
            # DATE
2669
            9 => sub { ... },
2670
            # DATETIME or TIMESTAMP
2671
            11 => sub { ... },
2672
        }
2673
        from2 => {
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2674
            # DATE
2675
            9 => sub { ... },
2676
            # DATETIME or TIMESTAMP
2677
            11 => sub { ... },
added type_rule into logic
Yuki Kimoto authored on 2011-06-09
2678
        }
2679
    );
2680

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

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

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

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

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

            
cleanup
Yuki Kimoto authored on 2011-06-13
2696
=over 4
2697

            
2698
=item 1. column name
2699

            
2700
    issue_date
2701
    issue_datetime
2702

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

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

            
2707
    book.issue_date
2708
    book.issue_datetime
2709

            
2710
=back
2711

            
added EXPERIMENTAL DBIx::Cus...
Yuki Kimoto authored on 2011-08-09
2712
You get all type name used in database by C<available_typename>.
update pod
Yuki Kimoto authored on 2011-06-15
2713

            
added EXPERIMENTAL DBIx::Cus...
Yuki Kimoto authored on 2011-08-09
2714
    print $dbi->available_typename;
update pod
Yuki Kimoto authored on 2011-06-15
2715

            
updated pod
Yuki Kimoto authored on 2011-06-21
2716
In C<from1> and C<from2> you specify data type, not type name.
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2717
C<from2> is executed after C<from1>.
added EXPERIMENTAL DBIx::Cus...
Yuki Kimoto authored on 2011-08-09
2718
You get all data type by C<available_datatype>.
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2719

            
added EXPERIMENTAL DBIx::Cus...
Yuki Kimoto authored on 2011-08-09
2720
    print $dbi->available_datatype;
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2721

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

            
2724
    $dbi->type_rule(
EXPERIMENTAL type_rule argum...
Yuki Kimoto authored on 2011-06-17
2725
        into1 => [
changed type_rule arguments ...
Yuki Kimoto authored on 2011-06-12
2726
            [qw/DATE DATETIME/] => sub { ... },
2727
        ],
2728
    );
added type_rule into logic
Yuki Kimoto authored on 2011-06-09
2729

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

            
select method column option ...
Yuki Kimoto authored on 2011-02-22
2732
    my $result = $dbi->select(
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2733
        table  => 'book',
2734
        column => ['author', 'title'],
2735
        where  => {author => 'Ken'},
select method column option ...
Yuki Kimoto authored on 2011-02-22
2736
    );
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2737
    
updated document
Yuki Kimoto authored on 2011-06-09
2738
Execute select statement.
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2739

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

            
2742
=over 4
2743

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

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

            
updated document
Yuki Kimoto authored on 2011-06-09
2748
Append statement to last of SQL.
2749
    
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2750
=item C<column>
2751
    
updated document
Yuki Kimoto authored on 2011-06-09
2752
    column => 'author'
2753
    column => ['author', 'title']
2754

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

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

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

            
updated document
Yuki Kimoto authored on 2011-06-09
2763
    column => [
updated pod
Yuki Kimoto authored on 2011-06-07
2764
        {book => [qw/author title/]},
2765
        {person => [qw/name age/]}
updated document
Yuki Kimoto authored on 2011-06-09
2766
    ]
updated pod
Yuki Kimoto authored on 2011-06-07
2767

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

            
2770
    book.author as "book.author",
2771
    book.title as "book.title",
2772
    person.name as "person.name",
2773
    person.age as "person.age"
2774

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

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

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

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

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

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

            
2790
=item C<id>
2791

            
2792
    id => 4
2793
    id => [4, 5]
2794

            
2795
ID corresponding to C<primary_key>.
2796
You can select rows by C<id> and C<primary_key>.
2797

            
2798
    $dbi->select(
2799
        parimary_key => ['id1', 'id2'],
2800
        id => [4, 5],
2801
        table => 'book'
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2802
    );
2803

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

            
updated pod
Yuki Kimoto authored on 2011-04-25
2806
    $dbi->select(
updated document
Yuki Kimoto authored on 2011-06-09
2807
        where => {id1 => 4, id2 => 5},
2808
        table => 'book'
where can recieve array refr...
Yuki Kimoto authored on 2011-03-24
2809
    );
2810
    
updated document
Yuki Kimoto authored on 2011-06-09
2811
=item C<param> EXPERIMETNAL
added select() all_column op...
Yuki Kimoto authored on 2011-03-12
2812

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

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

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

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

            
2825
    prefix => 'SQL_CALC_FOUND_ROWS'
2826

            
2827
Prefix of column cluase
2828

            
2829
    select SQL_CALC_FOUND_ROWS title, author from book;
2830

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

            
2833
    join => [
2834
        'left outer join company on book.company_id = company_id',
2835
        'left outer join location on company.location_id = location.id'
2836
    ]
2837
        
2838
Join clause. If column cluase or where clause contain table name like "company.name",
2839
join clausees needed when SQL is created is used automatically.
update pod
Yuki Kimoto authored on 2011-03-12
2840

            
2841
    $dbi->select(
2842
        table => 'book',
cleanup
Yuki Kimoto authored on 2011-06-13
2843
        column => ['company.location_id as location_id'],
update pod
Yuki Kimoto authored on 2011-03-12
2844
        where => {'company.name' => 'Orange'},
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

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

            
cleanup
Yuki Kimoto authored on 2011-06-13
2854
    select company.location_id as location_id
update pod
Yuki Kimoto authored on 2011-03-12
2855
    from book
2856
      left outer join company on book.company_id = company.id
cleanup
Yuki Kimoto authored on 2011-06-13
2857
    where company.name = ?;
update pod
Yuki Kimoto authored on 2011-03-12
2858

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

            
2862
    $dbi->select(
2863
        table => 'book',
2864
        column => ['company.location_id as location_id'],
2865
        where => {'company.name' => 'Orange'},
2866
        join => [
2867
            {
2868
                clause => 'left outer join location on company.location_id = location.id',
2869
                table => ['company', 'location']
2870
            }
2871
        ]
2872
    );
2873

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

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

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

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

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

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

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

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

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

            
updated document
Yuki Kimoto authored on 2011-06-09
2893
Table name.
updated pod
Yuki Kimoto authored on 2011-06-08
2894

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

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

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

            
2901
    type_rule1_off => 1
2902

            
2903
Same as C<execute> method's C<type_rule1_off> option.
2904

            
2905
=item C<type_rule2_off> EXPERIMENTAL
2906

            
2907
    type_rule2_off => 1
2908

            
2909
Same as C<execute> method's C<type_rule2_off> option.
2910

            
updated document
Yuki Kimoto authored on 2011-06-09
2911
=item C<where>
2912
    
2913
    # Hash refrence
2914
    where => {author => 'Ken', 'title' => 'Perl'}
2915
    
2916
    # DBIx::Custom::Where object
2917
    where => $dbi->where(
2918
        clause => ['and', 'author = :author', 'title like :title'],
2919
        param  => {author => 'Ken', title => '%Perl%'}
2920
    );
updated pod
Yuki Kimoto authored on 2011-06-21
2921
    
2922
    # Array reference 1 (array reference, hash referenc). same as above
2923
    where => [
2924
        ['and', 'author = :author', 'title like :title'],
2925
        {author => 'Ken', title => '%Perl%'}
2926
    ];    
2927
    
2928
    # Array reference 2 (String, hash reference)
2929
    where => [
2930
        'title like :title',
2931
        {title => '%Perl%'}
2932
    ]
2933
    
2934
    # String
2935
    where => 'title is null'
update pod
Yuki Kimoto authored on 2011-03-12
2936

            
updated document
Yuki Kimoto authored on 2011-06-09
2937
Where clause.
2938
    
improved pod
Yuki Kimoto authored on 2011-04-19
2939
=item C<wrap> EXPERIMENTAL
2940

            
2941
Wrap statement. This is array reference.
2942

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

            
2945
This option is for Oracle and SQL Server paging process.
2946

            
update pod
Yuki Kimoto authored on 2011-03-12
2947
=back
cleanup
Yuki Kimoto authored on 2011-03-08
2948

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

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

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

            
2955
If you want to set constant value to row data, use scalar reference
2956
as parameter value.
2957

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

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

            
update pod
Yuki Kimoto authored on 2011-03-13
2962
=over 4
2963

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

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

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

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

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

            
updated document
Yuki Kimoto authored on 2011-06-09
2974
    id => 4
2975
    id => [4, 5]
- insert, insert_at, update,...
Yuki Kimoto authored on 2011-06-08
2976

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

            
DEPRECATED select() param op...
Yuki Kimoto authored on 2011-04-25
2980
    $dbi->update(
updated document
Yuki Kimoto authored on 2011-06-09
2981
        {title => 'Perl', author => 'Ken'}
2982
        parimary_key => ['id1', 'id2'],
2983
        id => [4, 5],
2984
        table => 'book'
where can recieve array refr...
Yuki Kimoto authored on 2011-03-24
2985
    );
update pod
Yuki Kimoto authored on 2011-03-13
2986

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

            
updated document
Yuki Kimoto authored on 2011-06-09
2989
    $dbi->update(
2990
        {title => 'Perl', author => 'Ken'}
2991
        where => {id1 => 4, id2 => 5},
2992
        table => 'book'
2993
    );
update pod
Yuki Kimoto authored on 2011-03-13
2994

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

            
2997
    prefix => 'or replace'
2998

            
2999
prefix before table name section
3000

            
3001
    update or replace book
3002

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

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

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

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

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

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

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

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

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

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

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

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

            
3028
=item C<type_rule_off> EXPERIMENTAL
3029

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

            
3032
=item C<type_rule1_off> EXPERIMENTAL
3033

            
3034
    type_rule1_off => 1
3035

            
3036
Same as C<execute> method's C<type_rule1_off> option.
3037

            
3038
=item C<type_rule2_off> EXPERIMENTAL
3039

            
3040
    type_rule2_off => 1
3041

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

            
updated pod
Yuki Kimoto authored on 2011-06-08
3044
=back
update pod
Yuki Kimoto authored on 2011-03-13
3045

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

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

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

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

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

            
3057
Create update parameter tag.
3058

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

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

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

            
3068
Create a new L<DBIx::Custom::Where> object.
3069

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

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

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

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

            
3079
=head2 C<DBIX_CUSTOM_DEBUG>
3080

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

            
3084
=head2 C<DBIX_CUSTOM_DEBUG_ENCODING>
3085

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

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

            
3090
L<DBIx::Custom>
3091

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

            
3125
L<DBIx::Custom::Model>
3126

            
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
3127
    # Attribute methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3128
    filter # will be removed at 2017/1/1
3129
    name # will be removed at 2017/1/1
3130
    type # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3131

            
3132
L<DBIx::Custom::Query>
3133
    
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
3134
    # Attribute methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3135
    default_filter # will be removed at 2017/1/1
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
3136
    table # will be removed at 2017/1/1
3137
    filters # will be removed at 2017/1/1
3138
    
3139
    # Methods
3140
    filter # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3141

            
3142
L<DBIx::Custom::QueryBuilder>
3143
    
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
3144
    # Attribute methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3145
    tags # will be removed at 2017/1/1
3146
    tag_processors # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3147
    
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
3148
    # Methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3149
    register_tag # will be removed at 2017/1/1
3150
    register_tag_processor # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3151
    
3152
    # Others
3153
    build_query("select * from {= title}"); # tag parsing functionality
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3154
                                            # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3155

            
3156
L<DBIx::Custom::Result>
3157
    
DBIx::Custom::Query filters ...
Yuki Kimoto authored on 2011-07-30
3158
    # Attribute methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3159
    filter_check # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3160
    
3161
    # Methods
added EXPERIMENTAL each_tabl...
Yuki Kimoto authored on 2011-07-11
3162
    end_filter # will be removed at 2017/1/1
3163
    remove_end_filter # will be removed at 2017/1/1
3164
    remove_filter # will be removed at 2017/1/1
3165
    default_filter # will be removed at 2017/1/1
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3166

            
3167
L<DBIx::Custom::Tag>
3168

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

            
3171
=head1 BACKWORD COMPATIBLE POLICY
3172

            
3173
If a functionality is DEPRECATED, you can know it by DEPRECATED warnings
3174
except for attribute method.
3175
You can check all DEPRECATED functionalities by document.
3176
DEPRECATED functionality is removed after five years,
3177
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
3178
I extend one year each time he tell me it.
- added EXPERIMENTAL order m...
Yuki Kimoto authored on 2011-06-28
3179

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

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

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

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

            
3188
C<< <kimoto.yuki at gmail.com> >>
3189

            
3190
L<http://github.com/yuki-kimoto/DBIx-Custom>
3191

            
removed reconnect method
yuki-kimoto authored on 2010-05-28
3192
=head1 AUTHOR
3193

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

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

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

            
3200
This program is free software; you can redistribute it and/or modify it
3201
under the same terms as Perl itself.
3202

            
3203
=cut