view release on metacpan or  search on metacpan

lib/DB/Object.pm  view on Meta::CPAN

    } @found;
    return( wantarray() ? () : undef() ) if( !%$hash );
    return( wantarray() ? %$hash : $hash );
}

sub database
{
    # Read only
    return( shift->{database} );
}

sub databases { return( shift->error( "Method databases() is not implemented by driver." ) ); }

sub datatype_dict
{
    my $self = shift( @_ );
    my $class = ( ref( $self ) || $self );
    no strict 'refs';
    my $sym = $self->_get_symbol( $class => '$DATATYPES_DICT' );
    if( !defined( $sym ) )
    {
        return( $self->pass_error ) if( $self->error );
        return( $self->error( "No global variable \$DATATYPES_DICT defined in class $class" ) );
    }
    my $dict = $$sym;
    return( $self->error( "Symbol found for \$DATATYPES_DICT in class $class did not resolve into an expecxted hash reference." ) ) if( ref( $dict ) ne 'HASH' );
    if( @_ )
    {
        return( $dict->{ lc( shift( @_ ) ) } );
    }
    return( $dict );
}

# See also constant_to_datatype()
sub datatype_to_constant
{
    my $self = shift( @_ );
    my $ref = $self->datatypes || return( $self->pass_error );
    return unless( scalar( @_ ) && defined( $_[0] ) );
    return( $ref->{ lc( shift( @_ ) ) } );
}

# Returns an hash of SQL constant name to its value
sub datatypes
{
    my $self = shift( @_ );
    my $dict = $self->datatype_dict || return( $self->pass_error );
    my $ref = +{ map{ $_ => $dict->{ $_ }->{constant} } keys( %$dict ) };
    return( $ref );
}

sub disconnect($)
{
    my $self = shift( @_ );
    # my( $pack, $file, $line ) = caller();
    # print( STDERR "disconnect() called from package '$pack' in file '$file' at line '$line'.\n" );
    my $rc = $self->{dbh}->disconnect( @_ );
    return( $rc );
}

sub do($;$@)
{
    my $self = shift( @_ );
    # $rc  = $dbh->do( $statement )           || die( $dbh->errstr );
    # $rc  = $dbh->do( $statement, \%attr )   || die( $dbh->errstr );
    # $rv  = $dbh->do( $statement, \%attr, @bind_values ) || ...
    # my( $rows_deleted ) = $dbh->do( 
    # q{
    #     DELETE FROM table WHERE status = ?
    # }, undef(), 'DONE' ) || die( $dbh->errstr );
    my $query     = shift( @_ );
    my $opt_ref   = shift( @_ ) || undef();
    my $param_ref = shift( @_ ) || [];
    my $dbh = $self->can( 'database_object' ) ? $self->database_object : $self;
    $dbh or return( $self->error( "Could not find database handler." ) );
    my $sth = $dbh->prepare( $query, $opt_ref ) || 
        return( $self->error( "Error while preparing do query:\n$query", $dbh->errstr() ) );
    $sth->execute( @$param_ref ) || 
        return( $self->error( "Error while executing do query:\n$query", $sth->errstr() ) );
    # my $rows = $sth->rows();
    # return( ( $rows == 0 ) ? "0E0" : $rows );
    return( $sth );
}

sub driver { return( shift->_set_get( 'driver' ) ); }

sub enhance
{
    my $self = shift( @_ );
    my $prev = $self->{enhance};
    $self->{enhance} = shift( @_ ) if( @_ );
    return( $prev );
}

sub err(@)
{
    my $self = shift( @_ );
    # $rv = $h->err;
    if( defined( $self->{sth} ) )
    {
        return( $self->{sth}->err() );
    }
    elsif( $self->{dbh} )
    {
        return( $self->{dbh}->err() );
    }
    #else
    #{
        # return( $self->{ 'drh' }->err() );
    # return( DBI::err();
    #}
}

sub errno
{
    goto( &err );
}

sub errmesg
{
    goto( &errstr );