@@ -1,6 +1,9 @@

+0.1644

+  added experimental build_where method

 0.1633

   fixed test

 0.1632

+  added experimental where method

   added experimental DBIx::Custom::Where.

   removed DBIx::Custom::Or

 0.1631

@@ -1,6 +1,6 @@

 package DBIx::Custom;

-our $VERSION = '0.1633';

+our $VERSION = '0.1634';

 use 5.008001;

 use strict;

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

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

-sub where { DBIx::Custom::Where->new }

+sub where { DBIx::Custom::Where->new(sql_builder => shift->sql_builder) }

 sub _build_binds {

     my ($self, $params, $columns, $filter) = @_;

@@ -1411,6 +1411,10 @@ B<Example:>

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

+=head2 C<experimental) build_where>

+

+

+

 =head2 C<(deprecated) default_bind_filter>

     my $default_bind_filter = $dbi->default_bind_filter;

@@ -10,85 +10,89 @@ use overload '""' => sub { shift->to_string }, fallback => 1;

 use Carp 'croak';

+__PACKAGE__->attr(clause => sub { [] });

 __PACKAGE__->attr(param => sub { {} });

+__PACKAGE__->attr(sql_builder => sub { {} });

-sub clause {

-    my $self = shift;

+sub to_string {

+    my ($self, $param, $clause) = @_;

-    if (@_) {

-        $self->{clause} = ref $_[0] eq 'HASH' ? $_[0] : {@_};

-        

-        return $self;

-    }

-    return $self->{clause} ||= {};

-}

-

-sub or_clause {

-    my $self = shift;

+    local $self->{_where}    = '';

+    local $self->{_count}    = {};

+    local $self->{_op_stack} = [];

+    local $self->{_param}    = $param;

-    if (@_) {

-        $self->{or_clause} = ref $_[0] eq 'HASH' ? $_[0] : {@_};

-        

-        return $self;

-    }

+    $clause = ['and', $clause] unless ref $clause eq 'ARRAY';

+    

+    $self->_forward($clause);

-    return $self->{or_clause} ||= {};

+    return $self->{_where};

 }

-sub to_string {

-    my $self = shift;

-    

-    my $param      = $self->param;

-    my $clauses    = $self->clause;

-    my $or_clauses = $self->or_clause;

-    

-    # Clause check

-    my $wexists = keys %$param;

+our %VALID_OPERATIONS = map { $_ => 1 } qw/and or or_repeat/;

+

+sub _forward {

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

-    # Where

-    my $where = '';

-    if ($wexists) {

-        $where .= 'where (';

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

+        $self->{_where} .= '( ';

+        

+        my $op = $clause->[0] || '';

+        

+        croak qq{"$op" is invalid operation}

+          unless $VALID_OPERATIONS{$op};

+          

+        push @{$self->{_op_stack}}, $op;

+        

+        for (my $i = 1; $i < @$clause; $i++) {

+            $self->_forword($clause->[$i]);

+        }

-        foreach my $column (keys %$param) {

-

-            croak qq{"$column" is not found in "clause" or "or_clause"}

-              if exists $clauses->{$column}

-                  && exists $or_clauses->{$column};

-            

-            if (exists $clauses->{$column}) {

-                if (ref $clauses->{$column} eq 'ARRAY') {

-                    foreach my $clause (@{$clauses->{$column}}) {

-                        $where .= $clause . ' and ';

-                    }

+        pop @{$self->{_op_stack}};

+

+        if ($self->{_where} =~ /\( $/) {

+            $self->{_where} =~ s/\( $//;

+            $self->{_where} .= ' ';

+        }

+        $self->{_where} =~ s/ $op $//;

+        $self->{_where} .= ' ) ';

+    }

+    else {

+        my $op = $self->{_op_stack}->[-1];

+        

+        my $columns = $self->sql_builder->build_query($clause)->columns;

+        

+        croak qq{each tag contains one column name: tag "$clause"}

+          unless @$columns == 1;

+        

+        my $column = $columns->[0];

+        

+        my $ccount = ++$self->{_count}->{$column};

+        

+        my $param = $self->{_param};

+        

+        if (exists $param->{$column}) {

+            if ($op eq 'and' || $op eq 'or') {

+                if (ref $param->{$column} eq 'ARRAY') {

+                    $self->{_where} .= $clause . " $op "

+                      if exists $param->{$column}->[$ccount];

                 }

                 else {

-                    $where .= $clauses->{$column} . ' and ';

+                    $self->{_where} .= $clause . " $op "

+                      if $ccount == 1;

                 }

-                            }

-            elsif (exists $or_clauses->{$column}) {

-                my $clause = $or_clauses->{$column};

-                

+            }

+            elsif ($op eq 'or_repeat') {

                 if (ref $param->{$column} eq 'ARRAY') {

-                    my $count = @{$param->{$column}};

-                    if ($count) {

-                        $where .= '( ';

-                        $where .= $clause . ' or ' for (1 .. $count);

-                        $where =~ s/ or $//;

-                        $where .= ' ) and ';

-                    }

+                    $self->{_where} .= $clause . " or "

+                      for (1 .. @{$param->{$column}});

                 }

                 else {

-                    $where .= $clause . ' and ';

+                    $self->{_where} .= $clause;

                 }

             }

         }

-

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

-        $where .= ' )';

     }

-    

-    return $where;

 }

 1;

@@ -120,12 +124,6 @@ DBIx::Custom::Where - Where clause

 Where clause. These clauses is joined by ' and ' at C<to_string()>

 if corresponding parameter name is exists in C<param>.

-=head2 C<or_clause>

-

-    $where->or_clause(name => '{= name}');

-

-clause which has these parameter name is joined by ' or '.

-

 =head2 C<to_string>

     $where->to_string;

@@ -814,7 +814,7 @@ is(ref $query, 'DBIx::Custom::Query');

 $query = $dbi->select(table => 'table1', where => {key1 => 1, key2 => 2}, query => 1);

 is(ref $query, 'DBIx::Custom::Query');

-1;

+__END__

 test 'DBIx::Custom::Where';

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