lib/A3C/SQL.pm

package A3C::SQL;

use strict;
use warnings;

use base qw(Jifty::Object Class::Accessor::Fast);
__PACKAGE__->mk_accessors( qw(query arguments dbh) );

use Data::Dump qw/dump/;

=head1 NAME

A3C::SQL

=head1 DESCRIPTION

Issue SQL queries

=head1 METHODS

=head2 new

  my $sql = A3C::SQL->new({ query => 'select now()' });

As a alternative, if you don't want to use Jifty's database handle,
specify it like this:

  my $sql = A3C::SQL->new({
        query => 'select now()',
        dbh => $my_dbh,
  });

=head2 sth

Execute query and return statement handle. Ususally you don't have to call this manually.

=cut

sub sth {
        my $self = shift;
        if ( ! $self->{_sth} ) {
                my $dbh = $self->dbh || Jifty->handle->dbh;
                my $sth = $dbh->prepare( $self->query ) or $dbh->errstr;
                if ( $self->arguments ) {
                        Jifty->log->debug( $self->sql . ' arguments: ' . dump( $self->arguments ) );
                        $sth->execute( $self->arguments ) or $dbh->errstr;
                } else {
                        $sth->execute or $dbh->errstr;
                }
                $self->{_sth} = $sth;
        }

        return $self->{_sth};
}

=head2 next

  while ( my $row = $sql->next ) {
        print $row->now;
  }

=cut

sub next {
        my $self = shift;
        my $row = $self->sth->fetchrow_hashref;
        return unless defined $row;
        return A3C::SQL::row->new( $row );
}

=head2 count

  print $sql->count;

=cut

sub count {
        my $self = shift;
        return $self->sth->rows;
}

package A3C::SQL::row;

use Encode qw/decode/;
use Data::Dump qw/dump/;

our $AUTOLOAD;

sub new {
        my $that  = shift;
        my $class = ref($that) || $that;
        my $self = shift;
        bless $self, $class;
        return $self;
}  

sub AUTOLOAD {
        my $self = shift;
        my $type = ref($self) or die "$self is not an object";
        my $name = $AUTOLOAD;
        $name =~ s/.*://;
#       warn "SQL: $name doesn't exist" unless defined($self->{$name});
        return decode('UTF-8', $self->{$name});
}

sub DESTROY {}

1;
1	dpavlin	78	package A3C::SQL;
2
3			use strict;
4			use warnings;
5
6	dpavlin	145	use base qw(Jifty::Object Class::Accessor::Fast);
7			__PACKAGE__->mk_accessors( qw(query arguments dbh) );
8
9			use Data::Dump qw/dump/;
10
11	dpavlin	78	=head1 NAME
12
13			A3C::SQL
14
15			=head1 DESCRIPTION
16
17			Issue SQL queries
18
19			=head1 METHODS
20
21			=head2 new
22
23			my $sql = A3C::SQL->new({ query => 'select now()' });
24
25	dpavlin	145	As a alternative, if you don't want to use Jifty's database handle,
26			specify it like this:
27	dpavlin	78
28	dpavlin	145	my $sql = A3C::SQL->new({
29			query => 'select now()',
30			dbh => $my_dbh,
31			});
32	dpavlin	78
33			=head2 sth
34
35			Execute query and return statement handle. Ususally you don't have to call this manually.
36
37			=cut
38
39			sub sth {
40			my $self = shift;
41			if ( ! $self->{_sth} ) {
42	dpavlin	145	my $dbh = $self->dbh \|\| Jifty->handle->dbh;
43	dpavlin	78	my $sth = $dbh->prepare( $self->query ) or $dbh->errstr;
44			if ( $self->arguments ) {
45			Jifty->log->debug( $self->sql . ' arguments: ' . dump( $self->arguments ) );
46			$sth->execute( $self->arguments ) or $dbh->errstr;
47			} else {
48			$sth->execute or $dbh->errstr;
49			}
50			$self->{_sth} = $sth;
51			}
52
53			return $self->{_sth};
54			}
55
56			=head2 next
57
58			while ( my $row = $sql->next ) {
59			print $row->now;
60			}
61
62			=cut
63
64			sub next {
65			my $self = shift;
66			my $row = $self->sth->fetchrow_hashref;
67			return unless defined $row;
68			return A3C::SQL::row->new( $row );
69			}
70
71			=head2 count
72
73			print $sql->count;
74
75			=cut
76
77			sub count {
78			my $self = shift;
79			return $self->sth->rows;
80			}
81
82			package A3C::SQL::row;
83
84			use Encode qw/decode/;
85			use Data::Dump qw/dump/;
86
87			our $AUTOLOAD;
88
89			sub new {
90			my $that = shift;
91			my $class = ref($that) \|\| $that;
92			my $self = shift;
93			bless $self, $class;
94			return $self;
95			}
96
97			sub AUTOLOAD {
98			my $self = shift;
99			my $type = ref($self) or die "$self is not an object";
100			my $name = $AUTOLOAD;
101			$name =~ s/.*://;
102	dpavlin	82	# warn "SQL: $name doesn't exist" unless defined($self->{$name});
103	dpavlin	78	return decode('UTF-8', $self->{$name});
104			}
105
106	dpavlin	82	sub DESTROY {}
107
108	dpavlin	78	1;