view release on metacpan or  search on metacpan

DBomb/Query/Update.pm  view on Meta::CPAN

    $self->where_obj(new DBomb::Query::Expr());

    for(@_){
        if    ( UNIVERSAL::isa($_,'DBI::db')) { $self->dbh($_); }
        elsif ( UNIVERSAL::isa($_,'ARRAY'))   { $self->_column_names($_); }
        else{
            croak "unrecognized argument to Update->new";
        }
    }
}

## set the table
## table($_table_name)
sub table
{
    my $self = shift;
        assert(UNIVERSAL::isa($self,__PACKAGE__));

    while(my $a = shift){
        if    ( UNIVERSAL::isa($a,'DBI::db')) { $self->dbh($a); }
        else { $self->_table_name($a) }
    }

    return $self;
}

## set({ name => value})
## set( name => value)
sub set
{
    my $self = shift;

    if (@_ == 1){
        my $hash = shift;
            assert(UNIVERSAL::isa($hash,'HASH'), "Update::set requires a hashref (or name value)");
        while (my ($column_name, $value) = each %$hash){
            $self->set($column_name, $value);
        }
    }
    else{
        assert(@_ == 2, "Update::set requires a name and a value (or hashref)");
        my ($column_name, $value) = @_;

        ## for expression objects, extract the bind_value
        if (UNIVERSAL::isa($value,'DBomb::Query::Expr')){

        }


        push @{$self->_column_names}, $column_name;
        push @{$self->_values}, $value;
    }

    return $self;
}

## Same as prepare->execute
## update()
## update(@bind_values)
## update($dbh,@bind_values)
sub update
{
    my $self = shift;
    my @bv;

    for (@_){
        if (UNIVERSAL::isa($_,'DBI::db')){ $self->dbh($_) }
        else { push @bv, $_ }
    }
    assert(defined($self->dbh), 'update requires a dbh');

    if (not $self->sth){ $self->prepare }
    return $self->execute(@bv);
}

## execute()
## execute(@bind_values)
## execute($dbh,@bind_values)
sub execute
{
    my $self = shift;
    my @bv;

    for (@_){
        if (UNIVERSAL::isa($_,'DBI::db')){ $self->dbh($_) }
        else { push @bv, $_ }
    }
    assert(defined($self->dbh), 'update requires a dbh');

    if (not $self->sth){ $self->prepare }
    return $self->sth->execute((@{$self->bind_values},@bv));
}


## prepare()
## prepare($dbh)
sub prepare
{
    my $self = shift;

    for (@_){
        $self->dbh($_) if UNIVERSAL::isa($_, 'DBI::db');
    }
        assert(defined($self->dbh), 'prepare requires a dbh');
        assert($self->_table_name, 'update requires a table_name');
        assert(@{$self->_column_names} > 0, 'update requires at least one column');


    if ($DBomb::Conf::prepare_cached){
        $self->sth($self->dbh->prepare_cached(scalar $self->sql));
    }
    else{
        $self->sth($self->dbh->prepare(scalar $self->sql));
    }
    return $self;
}

## where(EXPR, @bind_values)
sub where
{
    my $self = shift;