eaiovnaovbqoebvqoeavibavo Simple.pm000064400000073614147634435310006360 0ustar00use 5.006; use strict; use DBI; use Carp (); $DBIx::Simple::VERSION = '1.35'; $Carp::Internal{$_} = 1 for qw(DBIx::Simple DBIx::Simple::Result DBIx::Simple::DeadObject); my $no_raiseerror = $ENV{PERL_DBIX_SIMPLE_NO_RAISEERROR}; my $quoted = qr/(?:'[^']*'|"[^"]*")*/; # 'foo''bar' simply matches the (?:) twice my $quoted_mysql = qr/(?:(?:[^\\']*(?:\\.[^\\']*)*)'|"(?:[^\\"]*(?:\\.[^\\"]*)*)")*/; my %statements; # "$db" => { "$st" => $st, ... } my %old_statements; # "$db" => [ [ $query, $st ], ... ] my %keep_statements; # "$db" => $int my $err_message = '%s no longer usable (because of %%s)'; my $err_cause = '%s at %s line %d'; package DBIx::Simple; ### private helper subs sub _dummy { bless \my $dummy, 'DBIx::Simple::Dummy' } sub _swap { my ($hash1, $hash2) = @_; my $tempref = ref $hash1; my $temphash = { %$hash1 }; %$hash1 = %$hash2; bless $hash1, ref $hash2; %$hash2 = %$temphash; bless $hash2, $tempref; } ### constructor sub connect { my ($class, @arguments) = @_; my $self = { lc_columns => 1, result_class => 'DBIx::Simple::Result' }; if (defined $arguments[0] and UNIVERSAL::isa($arguments[0], 'DBI::db')) { $self->{dont_disconnect} = 1; $self->{dbh} = shift @arguments; Carp::carp("Additional arguments for $class->connect are ignored") if @arguments; } else { $arguments[3]->{PrintError} = 0 unless defined $arguments[3] and exists $arguments[3]{PrintError}; $arguments[3]->{RaiseError} = 1 unless $no_raiseerror or defined $arguments[3] and exists $arguments[3]{RaiseError}; $self->{dbh} = DBI->connect(@arguments); } return undef unless $self->{dbh}; $self->{dbd} = $self->{dbh}->{Driver}->{Name}; bless $self, $class; $statements{$self} = {}; $old_statements{$self} = []; $keep_statements{$self} = 16; return $self; } sub new { my ($class) = shift; $class->connect(@_); } ### properties sub keep_statements : lvalue { $keep_statements{ $_[0] } } sub lc_columns : lvalue { $_[0]->{lc_columns} } sub result_class : lvalue { $_[0]->{result_class} } sub abstract : lvalue { require SQL::Abstract; $_[0]->{abstract} ||= SQL::Abstract->new; } sub error { my ($self) = @_; return 'DBI error: ' . (ref $self ? $self->{dbh}->errstr : $DBI::errstr); } sub dbh { $_[0]->{dbh} } ### private methods # Replace (??) with (?, ?, ?, ...) sub _replace_omniholder { my ($self, $query, $binds) = @_; return if $$query !~ /\(\?\?\)/; my $omniholders = 0; my $q = $self->{dbd} =~ /mysql/ ? $quoted_mysql : $quoted; $$query =~ s[($q|\(\?\?\))] { $1 eq '(??)' ? do { Carp::croak('There can be only one omniholder') if $omniholders++; '(' . join(', ', ('?') x @$binds) . ')' } : $1 }eg; } # Invalidate and clean up sub _die { my ($self, $cause) = @_; defined and $_->_die($cause, 0) for values %{ $statements{$self} }, map $$_[1], @{ $old_statements{$self} }; delete $statements{$self}; delete $old_statements{$self}; delete $keep_statements{$self}; unless ($self->{dont_disconnect}) { # Conditional, because destruction order is not guaranteed # during global destruction. $self->{dbh}->disconnect() if defined $self->{dbh}; } _swap( $self, bless { what => 'Database object', cause => $cause }, 'DBIx::Simple::DeadObject' ) unless $cause =~ /DESTROY/; # Let's not cause infinite loops :) } ### public methods sub query { my ($self, $query, @binds) = @_; $self->{success} = 0; $self->_replace_omniholder(\$query, \@binds); my $st; my $sth; my $old = $old_statements{$self}; if (defined( my $i = (grep $old->[$_][0] eq $query, 0..$#$old)[0] )) { $st = splice(@$old, $i, 1)->[1]; $sth = $st->{sth}; } else { eval { $sth = $self->{dbh}->prepare($query) } or do { if ($@) { $@ =~ s/ at \S+ line \d+\.\n\z//; Carp::croak($@); } $self->{reason} = "Prepare failed ($DBI::errstr)"; return _dummy; }; # $self is quoted on purpose, to pass along the stringified version, # and avoid increasing reference count. $st = bless { db => "$self", sth => $sth, query => $query }, 'DBIx::Simple::Statement'; $statements{$self}{$st} = $st; } eval { $sth->execute(@binds) } or do { if ($@) { $@ =~ s/ at \S+ line \d+\.\n\z//; Carp::croak($@); } $self->{reason} = "Execute failed ($DBI::errstr)"; return _dummy; }; $self->{success} = 1; return bless { st => $st, lc_columns => $self->{lc_columns} }, $self->{result_class}; } sub begin_work { $_[0]->{dbh}->begin_work } sub begin { $_[0]->begin_work } sub commit { $_[0]->{dbh}->commit } sub rollback { $_[0]->{dbh}->rollback } sub func { shift->{dbh}->func(@_) } sub last_insert_id { my ($self) = @_; ($self->{dbi_version} ||= DBI->VERSION) >= 1.38 or Carp::croak( "DBI v1.38 required for last_insert_id" . "--this is only $self->{dbi_version}, stopped" ); return shift->{dbh}->last_insert_id(@_); } sub disconnect { my ($self) = @_; $self->_die(sprintf($err_cause, "$self->disconnect", (caller)[1, 2])); return 1; } sub DESTROY { my ($self) = @_; $self->_die(sprintf($err_cause, "$self->DESTROY", (caller)[1, 2])); } ### public methods wrapping SQL::Abstract for my $method (qw/select insert update delete/) { no strict 'refs'; *$method = sub { my $self = shift; return $self->query($self->abstract->$method(@_)); } } ### public method wrapping SQL::Interp sub iquery { require SQL::Interp; my $self = shift; return $self->query( SQL::Interp::sql_interp(@_) ); } package DBIx::Simple::Dummy; use overload '""' => sub { shift }, bool => sub { 0 }; sub new { bless \my $dummy, shift } sub AUTOLOAD { return } package DBIx::Simple::DeadObject; sub _die { my ($self) = @_; Carp::croak( sprintf( "(This should NEVER happen!) " . sprintf($err_message, $self->{what}), $self->{cause} ) ); } sub AUTOLOAD { my ($self) = @_; Carp::croak( sprintf( sprintf($err_message, $self->{what}), $self->{cause} ) ); } sub DESTROY { } package DBIx::Simple::Statement; sub _die { my ($self, $cause, $save) = @_; $self->{sth}->finish() if defined $self->{sth}; $self->{dead} = 1; my $stringy_db = "$self->{db}"; my $stringy_self = "$self"; my $foo = bless { what => 'Statement object', cause => $cause }, 'DBIx::Simple::DeadObject'; DBIx::Simple::_swap($self, $foo); my $old = $old_statements{ $foo->{db} }; my $keep = $keep_statements{ $foo->{db} }; if ($save and $keep) { $foo->{dead} = 0; shift @$old until @$old + 1 <= $keep; push @$old, [ $foo->{query}, $foo ]; } delete $statements{ $stringy_db }{ $stringy_self }; } sub DESTROY { # This better only happen during global destruction... return if $_[0]->{dead}; $_[0]->_die('Ehm', 0); } package DBIx::Simple::Result; sub _die { my ($self, $cause) = @_; if ($cause) { $self->{st}->_die($cause, 1); DBIx::Simple::_swap( $self, bless { what => 'Result object', cause => $cause, }, 'DBIx::Simple::DeadObject' ); } else { $cause = $self->{st}->{cause}; DBIx::Simple::_swap( $self, bless { what => 'Result object', cause => $cause }, 'DBIx::Simple::DeadObject' ); Carp::croak( sprintf( sprintf($err_message, $self->{what}), $cause ) ); } } sub func { shift->{st}->{sth}->func(@_) } sub attr { my $dummy = $_[0]->{st}->{sth}->{$_[1]} } sub columns { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my $c = $_[0]->{st}->{sth}->{ $_[0]->{lc_columns} ? 'NAME_lc' : 'NAME' }; return wantarray ? @$c : $c; } sub bind { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; $_[0]->{st}->{sth}->bind_columns(\@_[1..$#_]); } ### Single sub fetch { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; return $_[0]->{st}->{sth}->fetch; } sub into { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my $sth = $_[0]->{st}->{sth}; $sth->bind_columns(\@_[1..$#_]) if @_ > 1; return $sth->fetch; } sub list { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; return $_[0]->{st}->{sth}->fetchrow_array if wantarray; return($_[0]->{st}->{sth}->fetchrow_array)[-1]; } sub array { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my $row = $_[0]->{st}->{sth}->fetchrow_arrayref or return; return [ @$row ]; } sub hash { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; return $_[0]->{st}->{sth}->fetchrow_hashref( $_[0]->{lc_columns} ? 'NAME_lc' : 'NAME' ); } sub kv_list { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my @keys = $_[0]->columns; my $values = $_[0]->array or return; Carp::croak("Different numbers of column names and values") if @keys != @$values; return map { $keys[$_], $values->[$_] } 0 .. $#keys if wantarray; return [ map { $keys[$_], $values->[$_] } 0 .. $#keys ]; } sub kv_array { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; scalar shift->kv_list(@_); } sub object { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my $self = shift; my $class = shift || ':RowObject'; if ($class =~ /^:/) { $class = "DBIx::Simple::Result:$class"; (my $package = "$class.pm") =~ s[::][/]g; require $package; } if ($class->can('new_from_dbix_simple')) { return scalar $class->new_from_dbix_simple($self, @_); } if ($class->can('new')) { return $class->new( $self->kv_list ); } Carp::croak( qq(Can't locate object method "new_from_dbix_simple" or "new" ) . qq(via package "$class" (perhaps you forgot to load "$class"?)) ); } ### Slurp sub flat { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; return map @$_, $_[0]->arrays if wantarray; return [ map @$_, $_[0]->arrays ]; } sub arrays { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; return @{ $_[0]->{st}->{sth}->fetchall_arrayref } if wantarray; return $_[0]->{st}->{sth}->fetchall_arrayref; } sub hashes { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my @return; my $dummy; push @return, $dummy while $dummy = $_[0]->hash; return wantarray ? @return : \@return; } sub kv_flat { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; return map @$_, $_[0]->kv_arrays if wantarray; return [ map @$_, $_[0]->kv_arrays ]; } sub kv_arrays { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my @return; my $dummy; push @return, $dummy while $dummy = $_[0]->kv_array; return wantarray ? @return : \@return; } sub objects { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my $self = shift; my $class = shift || ':RowObject'; if ($class =~ /^:/) { $class = "DBIx::Simple::Result:$class"; (my $package = "$class.pm") =~ s[::][/]g; require $package; } if ($class->can('new_from_dbix_simple')) { return $class->new_from_dbix_simple($self, @_) if wantarray; return [ $class->new_from_dbix_simple($self, @_) ]; } if ($class->can('new')) { return map { $class->new( @$_ ) } $self->kv_arrays if wantarray; return [ map { $class->new( @$_ ) } $self->kv_arrays ]; } Carp::croak( qq(Can't locate object method "new_from_dbix_simple" or "new" ) . qq(via package "$class" (perhaps you forgot to load "$class"?)) ); } sub map_hashes { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my ($self, $keyname) = @_; Carp::croak('Key column name not optional') if not defined $keyname; my @rows = $self->hashes; my @keys; push @keys, delete $_->{$keyname} for @rows; my %return; @return{@keys} = @rows; return wantarray ? %return : \%return; } sub map_arrays { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my ($self, $keyindex) = @_; $keyindex += 0; my @rows = $self->arrays; my @keys; push @keys, splice @$_, $keyindex, 1 for @rows; my %return; @return{@keys} = @rows; return wantarray ? %return : \%return; } sub map { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; return map @$_, @{ $_[0]->{st}->{sth}->fetchall_arrayref } if wantarray; return { map @$_, @{ $_[0]->{st}->{sth}->fetchall_arrayref } }; } sub rows { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; $_[0]->{st}->{sth}->rows; } sub xto { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; require DBIx::XHTML_Table; my $self = shift; my $attr = ref $_[0] ? $_[0] : { @_ }; # Old DBD::SQLite (.29) spits out garbage if done *after* fetching. my $columns = $self->{st}->{sth}->{NAME}; return DBIx::XHTML_Table->new( scalar $self->arrays, $columns, $attr ); } sub html { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my $self = shift; my $attr = ref $_[0] ? $_[0] : { @_ }; return $self->xto($attr)->output($attr); } sub text { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my ($self, $type) = @_; my $text_table = defined $type && length $type ? 0 : eval { require Text::Table; $type = 'table'; 1 }; $type ||= 'neat'; if ($type eq 'box' or $type eq 'table') { my $box = $type eq 'box'; $text_table or require Text::Table; my @columns = map +{ title => $_, align_title => 'center' }, @{ $self->{st}->{sth}->{NAME} }; my $c = 0; splice @columns, $_ + $c++, 0, \' | ' for 1 .. $#columns; my $table = Text::Table->new( ($box ? \'| ' : ()), @columns, ($box ? \' |' : ()) ); $table->load($self->arrays); my $rule = $table->rule(qw/- +/); return join '', ($box ? $rule : ()), $table->title, $rule, $table->body, ($box ? $rule : ()); } Carp::carp("Unknown type '$type'; using 'neat'") if $type ne 'neat'; return join '', map DBI::neat_list($_) . "\n", $self->arrays; } sub finish { $_[0]->_die if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my ($self) = @_; $self->_die( sprintf($err_cause, "$self->finish", (caller)[1, 2]) ); } sub DESTROY { return if ref $_[0]->{st} eq 'DBIx::Simple::DeadObject'; my ($self) = @_; $self->_die( sprintf($err_cause, "$self->DESTROY", (caller)[1, 2]) ); } 1; __END__ =head1 NAME DBIx::Simple - Very complete easy-to-use OO interface to DBI =head1 SYNOPSIS =head2 DBIx::Simple $db = DBIx::Simple->connect(...) # or ->new $db->keep_statements = 16 $db->lc_columns = 1 $db->result_class = 'DBIx::Simple::Result'; $db->begin_work $db->commit $db->rollback $db->disconnect $db->func(...) $db->last_insert_id $result = $db->query(...) =head2 DBIx::SImple + SQL::Interp $result = $db->iquery(...) =head2 DBIx::Simple + SQL::Abstract $db->abstract = SQL::Abstract->new(...) $result = $db->select(...) $result = $db->insert(...) $result = $db->update(...) $result = $db->delete(...) =head2 DBIx::Simple::Result @columns = $result->columns $result->into($foo, $bar, $baz) $row = $result->fetch @row = $result->list @rows = $result->flat $row = $result->array @rows = $result->arrays $row = $result->hash @rows = $result->hashes @row = $result->kv_list @rows = $result->kv_flat $row = $result->kv_array @rows = $result->kv_arrays $obj = $result->object @objs = $result->objects %map = $result->map_arrays(...) %map = $result->map_hashes(...) %map = $result->map $rows = $result->rows $dump = $result->text $result->finish =head2 DBIx::Simple::Result + DBIx::XHTML_Table $html = $result->html(...) $table_object = $result->xto(...) =head2 Examples Please read L for code examples. =head1 DESCRIPTION DBIx::Simple provides a simplified interface to DBI, Perl's powerful database module. This module is aimed at rapid development and easy maintenance. Query preparation and execution are combined in a single method, the result object (which is a wrapper around the statement handle) provides easy row-by-row and slurping methods. The C method returns either a result object, or a dummy object. The dummy object returns undef (or an empty list) for all methods and when used in boolean context, is false. The dummy object lets you postpone (or skip) error checking, but it also makes immediate error checking simply C<< $db->query(...) or die $db->error >>. =head2 DBIx::Simple methods =head3 Class methods =over 14 =item C, C =item C, C The C or C class method takes either an existing DBI object ($dbh), or a list of arguments to pass to C<< DBI->connect >>. See L for a detailed description. You cannot use this method to clone a DBIx::Simple object: the $dbh passed should be a DBI::db object, not a DBIx::Simple object. For new connections, PrintError is disabled by default. If you enable it, beware that it will report line numbers in DBIx/Simple.pm. For new connections, B unless the environment variable C is set to a non-empty non-0 value. This method is the constructor and returns a DBIx::Simple object on success. On failure, it returns undef. =back =head3 Object methods =over 14 =item C Prepares and executes the query and returns a result object. If the string C<(??)> is present in the query, it is replaced with a list of as many question marks as @values. The database drivers substitute placeholders (question marks that do not appear in quoted literals) in the query with the given @values, after them escaping them. You should always use placeholders, and never use raw user input in database queries. On success, returns a DBIx::Simple::Result object. On failure, returns a DBIx::Simple::Dummy object. =item C Uses SQL::Interp to interpolate values into a query, and uses the resulting generated query and bind arguments with C. See SQL::Interp's documentation for usage information. Requires Mark Storberg's SQL::Interp, which is available from CPAN. SQL::Interp is a fork from David Manura's SQL::Interpolate. =item C, C, C and C methods. On first access, will create one with SQL::Abstract's default options. Requires Nathan Wiger's SQL::Abstract, which is available from CPAN. In theory, you can assign any object to this property, as long as that object has these four methods, and they return a list suitable for use with the C method. =back =head2 DBIx::Simple::Dummy The C method of DBIx::Simple returns a dummy object on failure. Its methods all return an empty list or undef, depending on context. When used in boolean context, a dummy object evaluates to false. =head2 DBIx::Simple::Result methods Methods documented to return "a list" return a reference to an array of the same in scalar context, unless something else is explicitly mentioned. =over 14 =item C Returns a list of column names. Affected by C. =item C Binds the given LIST of variables to the columns. Unlike with DBI's C, passing references is not needed. Bound variables are very efficient. Binding a tied variable doesn't work. =item C Returns a copy of an sth attribute (property). See L for details. =item C This calls the C method on the sth of DBI. See L for details. =item C Returns the number of rows affected by the last row affecting command, or -1 if the number of rows is not known or not available. For SELECT statements, it is generally not possible to know how many rows are returned. MySQL does provide this information. See L for a detailed explanation. =item C Finishes the statement. After finishing a statement, it can no longer be used. When the result object is destroyed, its statement handle is automatically finished and destroyed. There should be no reason to call this method explicitly; just let the result object go out of scope. =back =head3 Fetching a single row at a time =over 14 =item C Returns a reference to the array that holds the values. This is the same array every time. Subsequent fetches (using any method) may change the values in the variables passed and the returned reference's array. =item C Combines C with C. Returns what C returns. =item C Returns a list of values, or (in scalar context), only the last value. =item C Returns a reference to an array. =item C Returns a reference to a hash, keyed by column name. Affected by C. =item C Returns an ordered list of interleaved keys and values. Affected by C. =item C Returns a reference to an array of interleaved column names and values. Like kv, but returns an array reference even in list context. Affected by C. =item C Returns an instance of $class. See "Object construction". Possibly affected by C. =back =head3 Fetching all remaining rows =over 14 =item C Returns a flattened list. =item C Returns a list of references to arrays =item C Returns a list of references to hashes, keyed by column name. Affected by C. =item C Returns an flattened list of interleaved column names and values. Affected by C. =item C Returns a list of references to arrays of interleaved column names and values. Affected by C. =item C Returns a list of instances of $class. See "Object construction". Possibly affected by C. =item C Constructs a hash of array references keyed by the values in the chosen column, and returns a list of interleaved keys and values, or (in scalar context), a reference to a hash. =item C Constructs a hash of hash references keyed by the values in the chosen column, and returns a list of interleaved keys and values, or (in scalar context), a reference to a hash. Affected by C. =item C Constructs a simple hash, using the two columns as key/value pairs. Should only be used with queries that return two columns. Returns a list of interleaved keys and values, or (in scalar context), a reference to a hash. =item C Returns a DBIx::XHTML_Table object, passing the constructor a reference to C<%attr>. Requires Jeffrey Hayes Anderson's DBIx::XHTML_Table, which is available from CPAN. In general, using the C method (described below) is much easier. C is available in case you need more flexibility. Not affected by C. =item C Returns an (X)HTML formatted table, using the DBIx::XHTML_Table module. Passes a reference to C<%attr> to both the constructor and the C method. Requires Jeffrey Hayes Anderson's DBIx::XHTML_Table, which is available from CPAN. This method is a shortcut method. That means that $result->html $result->html( tr => { bgcolor => [ 'silver', 'white' ] }, no_ucfirst => 1 ) do the same as: $result->xto->output $result->xto( tr => { bgcolor => [ 'silver', 'white' ] } )->output( no_ucfirst => 1 ); =item C Returns a string with a simple text representation of the data. C<$type> can be any of: C, C, C. It defaults to C
if Text::Table is installed, to C if it isn't. C
and C require Anno Siegel's Text::Table, which is available from CPAN. =back =head2 Object construction DBIx::Simple has basic support for returning results as objects. The actual construction method has to be provided by the chosen class, making this functionality rather advanced and perhaps unsuited for beginning programmers. When the C or C method is called on the result object returned by one of the query methods, two approaches are tried. In either case, pass the name of a class as the first argument. A prefix of a single colon can be used as an alias for C, e.g. C<":Example"> is short for C<"DBIx::Simple::Result::Example">. When this shortcut is used, the corresponding module is loaded automatically. The default class when no class is given, is C<:RowObject>. It requires Jos Boumans' Object::Accessor, which is available from CPAN. =head3 Simple object construction When C is given a class that provides a C method, but not a C method, C is called with a list of interleaved column names and values, like a flattened hash, but ordered. C causes C to be called multiple times, once for each remaining row. Example: { package DBIx::Simple::Result::ObjectExample; sub new { my ($class, %args) = @_; return bless $class, \%args; } sub foo { ... } sub bar { ... } } $db->query('SELECT foo, bar FROM baz')->object(':ObjectExample')->foo(); =head3 Advanced object construction When C or C is given a class that provides a C method, any C is ignored, and C is called with a list of the DBIx::Simple::Result object and any arguments passed to C or C. C is called in scalar context for C, and in list context for C. In scalar context, it should fetch I, and in list context, it should fetch I. Example: { package DBIx::Simple::Result::ObjectExample; sub new_from_dbix_simple { my ($class, $result, @args) = @_; return map { bless $class, $_ } $result->hashes if wantarray; return bless $class, $result->hash; } sub foo { ... } sub bar { ... } } $db->query('SELECT foo, bar FROM baz')->object(':ObjectExample')->foo(); =head1 MISCELLANEOUS The mapping methods do not check whether the keys are unique. Rows that are fetched later overwrite earlier ones. =head1 LICENSE Pick your favourite OSI approved license :) http://www.opensource.org/licenses/alphabetical =head1 AUTHOR Juerd Waalboer <#####@juerd.nl> =head1 SEE ALSO L, L L, L, L, L =cut Simple/Comparison.pod000064400000006007147634435320010631 0ustar00=head1 NAME DBIx::Simple::Comparison - DBIx::Simple in DBI jargon =head1 DESCRIPTION This is just a simple and B overview of what DBI things the DBIx::Simple things represent, or the other way around. This document can be useful to find the foo equivalent of bar. C means that DBI doesn't have an equivalent or that I couldn't find one. C<=> means that DBIx::Simple provides a direct wrapper to the DBI function. C<~> means that DBIx::Simple's method does more or less the same, but usually in a more high level way: context sensitive, combining things, automatically taking care of something. Note that DBIx::Simple is a wrapper around DBI. It is not "better" than DBI. In fact, DBIx::Simple cannot work without DBI. Using DBI directly is always faster than using DBIx::Simple's equivalents. (For the computer, that is. For you, DBIx::Simple is supposed to be faster.) =head2 Classes, common names use DBI ~ use DBIx::Simple $DBI::errstr = DBIx::Simple->error DBI::db ~ DBIx::Simple $dbh ~ $db $dbh->errstr = $db->error connect ~ connect connect ~ new DBI::st ~ DBIx::Simple::Result ~ DBIx::Simple::Dummy $sth ~ $result =head2 Queries DBI my $sth = $dbh->prepare_cached($query); $sth->execute(@values); ~ DBIx::Simple my $result = $db->query($query, $values); =head2 Results DBI DBIx::Simple bind_columns ~ bind fetchrow_arrayref/fetch = fetch fetchrow_array ~ list *1 ~ flat [@{fetchrow_arrayref}] = array fetchall_arrayref ~ arrays fetchrow_hashref() *2*3 = hash fetchall_arrayref({}) *4 ~ hashes fetchall_hashref *2 = map_hashes ? ? map_arrays fetchall_hashref(1) *2 = map $sth->{NAME_lc/NAME} = $result->columns *1 There's no fetch variant, but you can do C<< { @{ $dbh->selectcol_arrayref('SELECT ...', { Slice => [] }) } } >>. *2 To receive the keys (column names) lowercased, use C<< $db->{FetchHashKeyName} = 'NAME_lc' >>. DBIx::Simple lower cases them by default. *3 Or supply an argument, C<'NAME_lc'>. *4 No, arrayref isn't a typo. When supplied an empty hash reference, DBI's fetchall_arrayref actually returns hashrefs. This DBI method does not support lower casing of keys, DBIx::Simple does. =head2 Direct access DBI DBIx::Simple $dbh = $db->dbh $sth->{$foo} = $result->attr($foo) func = func begin_work = begin_work commit = commit rollback = rollback last_insert_id = last_insert_id rows = rows disconnect ~ disconnect finish ~ finish =head2 DBIx::Simple specific (?) keep_statements lc_columns iquery (via SQL::Interp) select, insert, update, delete (via SQL::Abstract) abstract (via SQL::Abstract) flat hashes map_arrays map =head1 AUTHOR Juerd Waalboer =head1 SEE ALSO L, L =cut Simple/Examples.pod000064400000023274147634435320010302 0ustar00=head1 NAME DBIx::Simple::Examples - Examples of how to use DBIx::Simple =head1 DESCRIPTION DBIx::Simple provides a simplified interface to DBI, Perl's powerful database module. =head1 EXAMPLES =head2 General #!/usr/bin/perl -w use strict; use DBIx::Simple; # Instant database with DBD::SQLite my $db = DBIx::Simple->connect('dbi:SQLite:dbname=file.dat') or die DBIx::Simple->error; # Connecting to a MySQL database my $db = DBIx::Simple->connect( 'DBI:mysql:database=test', # DBI source specification 'test', 'test', # Username and password { RaiseError => 1 } # Additional options ); # Using an existing database handle my $db = DBIx::Simple->connect($dbh); # Abstracted example: $db->query($query, @variables)->what_you_want; $db->commit or die $db->error; =head2 Simple Queries $db->query('DELETE FROM foo WHERE id = ?', $id) or die $db->error; for (1..100) { $db->query( 'INSERT INTO randomvalues VALUES (?, ?)', int rand(10), int rand(10) ) or die $db->error; } $db->query( 'INSERT INTO sometable VALUES (??)', $first, $second, $third, $fourth, $fifth, $sixth ); # (??) is expanded to (?, ?, ?, ?, ?, ?) automatically =head2 Single row queries my ($two) = $db->query('SELECT 1 + 1')->list; my ($three, $four) = $db->query('SELECT 3, 2 + 2')->list; my ($name, $email) = $db->query( 'SELECT name, email FROM people WHERE email = ? LIMIT 1', $mail )->list; Or, more efficiently: $db->query('SELECT 1 + 1')->into(my $two); $db->query('SELECT 3, 2 + 2')->into(my ($three, $four)); $db->query( 'SELECT name, email FROM people WHERE email = ? LIMIT 1', $mail )->into(my ($name, $email)); =head2 Fetching all rows in one go =head3 One big flattened list (primarily for single column queries) my @names = $db->query('SELECT name FROM people WHERE id > 5')->flat; =head3 Rows as array references for my $row ($db->query('SELECT name, email FROM people')->arrays) { print "Name: $row->[0], Email: $row->[1]\n"; } =head3 Rows as hash references for my $row ($db->query('SELECT name, email FROM people')->hashes) { print "Name: $row->{name}, Email: $row->{email}\n"; } =head2 Fetching one row at a time =head3 Rows into separate variables { my $result = $db->query('SELECT name, email FROM people'); $result->bind(my ($name, $email)); while ($result->fetch) { print "Name: $name, Email: $email\n"; } } or: { my $result = $db->query('SELECT name, email FROM people'); while ($result->into(my ($name, $email))) { print "Name: $name, Email: $email\n"; } } =head3 Rows as lists { my $result = $db->query('SELECT name, email FROM people'); while (my @row = $result->list) { print "Name: $row[0], Email: $row[1]\n"; } } =head3 Rows as array references { my $result = $db->query('SELECT name, email FROM people'); while (my $row = $result->array) { print "Name: $row->[0], Email: $row->[1]\n"; } } =head3 Rows as hash references { my $result = $db->query('SELECT name, email FROM people'); while (my $row = $result->hash) { print "Name: $row->{name}, Email: $row->{email}\n"; } } =head2 Building maps (also fetching all rows in one go) =head3 A hash of hashes my $customers = $db -> query('SELECT id, name, location FROM people') -> map_hashes('id'); # $customers = { $id => { name => $name, location => $location } } =head3 A hash of arrays my $customers = $db -> query('SELECT id, name, location FROM people') -> map_arrays(0); # $customers = { $id => [ $name, $location ] } =head3 A hash of values (two-column queries) my $names = $db -> query('SELECT id, name FROM people') -> map; # $names = { $id => $name } =head1 EXAMPLES WITH SQL::Interp If you have SQL::Interp installed, you can use the semi-abstracting method C. This works just like C, but with parts of the query interleaved with the bind arguments, passed as references. You should read L. These examples are not enough to fully understand all the possibilities. The following examples are based on the documentation of SQL::Interp. my $result = $db->iquery('INSERT INTO table', \%item); my $result = $db->iquery('UPDATE table SET', \%item, 'WHERE y <> ', \2); my $result = $db->iquery('DELETE FROM table WHERE y = ', \2); # These two select syntax produce the same result my $result = $db->iquery('SELECT * FROM table WHERE x = ', \$s, 'AND y IN', \@v); my $result = $db->iquery('SELECT * FROM table WHERE', {x => $s, y => \@v}); for ($result->hashes) { ... } Use a syntax highlighting editor for good visual distinction. If you need the helper functions C and C, you can import them with C =head1 EXAMPLES WITH SQL::Abstract If you have SQL::Abstract installed, you can use the abstracting methods C would be: print $db->select('foo', '*')->html; A DBIx::XHTML_Table object can be generated with the C (BHTML_Bable Bbject) method: my $table = $db->query($query)->xto; =head2 Passing attributes DBIx::Simple sends the attributes you pass to C both to the constructor and the output method. This allows you to specify both HTML attributes (like C) and options for XHTML_Table (like C and C) all at once: print $result->html( tr => { bgcolor => [ qw/silver white/ ] }, no_ucfirst => 1 ); =head2 Using an XHTML_Table object Not everything can be controlled by passing attributes. For full flexibility, the XHTML_Table object can be used directly: my $table = $db->query($query)->xto( tr => { bgcolor => [ qw/silver white/ ] } ); $table->set_group('client', 1); $table->calc_totals('credit', '%.2f'); print $table->output({ no_ucfirst => 1 }); # note the {}! =head1 EXAMPLES WITH Text::Table =over 8 =item C<< $result->text("neat") >> Neither neat nor pretty, but useful for debugging. Uses DBI's C method. Doesn't display column names. '1', 'Camel', 'mammal' '2', 'Llama', 'mammal' '3', 'Owl', 'bird' '4', 'Juerd', undef =item C<< $result->text("table") >> Displays a simple table using ASCII lines. id | animal | type ---+--------+------- 1 | Camel | mammal 2 | Llama | mammal 3 | Owl | bird 4 | Juerd | =item C<< $result->text("box") >> Displays a simple table using ASCII lines, with an outside border. +----+--------+--------+ | id | animal | type | +----+--------+--------+ | 1 | Camel | mammal | | 2 | Llama | mammal | | 3 | Owl | bird | | 4 | Juerd | | +----+--------+--------+ =back For C
and C, you need Anno Siegel's Text::Table module installed. =head1 AUTHOR Juerd Waalboer =head1 SEE ALSO L, L =cut Simple/Result/RowObject.pm000064400000003516147634435320011527 0ustar00package DBIx::Simple::Result::RowObject; use base 'Object::Accessor'; sub new { my ($class, %args) = @_; my $self = $class->SUPER::new; $self->mk_accessors(keys %args); $self->$_( $args{$_} ) for keys %args; return $self; } 1; =head1 NAME DBIx::Simple::Result::RowObject - Simple result row object class =head1 DESCRIPTION This class is the default for the C and C result object methods. Mainly, it provides syntactic sugar at the expense of performance. Instead of writing my $r = $db->query('SELECT foo, bar FROM baz')->hash; do_something_with $r->{foo}, $r->{bar}; you may write my $r = $db->query('SELECT foo, bar FROM baz')->object; do_something_with $r->foo, $r->bar; This class is a subclass of Object::Accessor, which provides per-object (rather than per-class) accessors. Your records must not have columns names like these: * can * ls_accessors * ls_allow * mk_accessor * mk_clone * mk_flush * mk_verify * new * register_callback * ___autoload * ___callback * ___debug * ___error * ___get * ___set And of course DESTROY and AUTOLOAD, and anything that new versions of Object::Accessor might add. =head1 DBIx::Simple::OO DBIx::Simple::OO is a third party module by Jos Boumans that provided C and C to DBIx::Simple. Similar functionality is now built in, in part inspired by DBIx::Simple:OO. Using DBIx::Simple 1.33 or newer together with DBIx::Simple::OO 0.01 will result in method name clash. DBIx::Simple::Result::RowObject was written to be compatible with DBIx::Simple::OO::Item, except for the name, so C calls still need to be changed. In practice, DBIx::Simple 1.33 makes DBIx::Simple::OO obsolete. =head1 AUTHOR Juerd Waalboer =head1 SEE ALSO L