view release on metacpan or  search on metacpan

lib/Alzabo/Runtime/RowState/Live.pm  view on Meta::CPAN

    }

    return %data unless @select;

    my $sql = ( $row->schema->sqlmaker->
                select( $row->table->columns(@select) )->
                from( $row->table ) );
    $class->_where($row, $sql);

    $sql->debug(\*STDERR) if Alzabo::Debug::SQL;
    print STDERR Devel::StackTrace->new if Alzabo::Debug::TRACE;

    my %d;
    @d{@select} =
        $row->schema->driver->one_row( sql  => $sql->sql,
                                       bind => $sql->bind )
            or $row->_no_such_row_error;

    while ( my( $k, $v ) = each %d )
    {
        $row->{data}{$k} = $data{$k} = $v;
    }

    return %data;
}

sub id_as_string
{
    my $class = shift;
    my $row = shift;
    my %p = @_;

    return $row->{id_string} if exists $row->{id_string};

    $row->{id_string} = $row->id_as_string_ext( pk    => $row->{pk},
                                                table => $row->table );
    return $row->{id_string};
}

sub select
{
    my $class = shift;
    my $row = shift;

    my @cols = @_ ? @_ : map { $_->name } $row->table->columns;
    my %data = $class->_get_data( $row, @cols );

    return wantarray ? @data{@cols} : $data{ $cols[0] };
}

sub select_hash
{
    my $class = shift;
    my $row = shift;

    my @cols = @_ ? @_ : map { $_->name } $row->table->columns;

    return $class->_get_data( $row, @cols );
}

sub update
{
    my $class = shift;
    my $row = shift;
    my %data = @_;

    my $schema = $row->schema;

    my @fk; # this never gets populated unless referential integrity
            # checking is on
    my @set;

    my $includes_pk = 0;
    foreach my $k ( sort keys %data )
    {
        # This will throw an exception if the column doesn't exist.
        my $c = $row->table->column($k);

        if ( $row->_cached_data_is_same( $k, $data{$k} ) )
        {
            delete $data{$k};
            next;
        }

        $includes_pk = 1 if $c->is_primary_key;

        Alzabo::Exception::NotNullable->throw
            ( error => $c->name . " column in " . $row->table->name . " table cannot be null.",
              column_name => $c->name,
              table_name  => $c->table->name,
              schema_name => $schema->name,
            )
                unless defined $data{$k} || $c->nullable || defined $c->default;

        push @fk, $row->table->foreign_keys_by_column($c)
            if $schema->referential_integrity;

        push @set, $c => $data{$k};
    }

    return 0 unless keys %data;

    my $sql = ( $schema->sqlmaker->update( $row->table ) );

    $sql->set(@set);

    $class->_where( $row, $sql );

    # If we have foreign keys we'd like all the fiddling to be atomic.
    $schema->begin_work if @fk;

    eval
    {
        foreach my $fk (@fk)
        {
            $fk->register_update( map { $_->name => $data{ $_->name } } $fk->columns_from );
        }

        $sql->debug(\*STDERR) if Alzabo::Debug::SQL;
        print STDERR Devel::StackTrace->new if Alzabo::Debug::TRACE;