view release on metacpan or  search on metacpan

lib/DBIx/Skinny/Row.pm  view on Meta::CPAN

    unless ( $col ) {
        Carp::croak('please specify $col for first argument');
    }

    my $data = exists $self->{row_data}->{$col} ? $self->{row_data}->{$col} : Carp::croak("$col no selected column. SQL: " . ($self->{sql}||'unknown'));

    return $self->{skinny}->schema->utf8_on($col, $data);
}

sub get_columns {
    my $self = shift;

    my %data;
    for my $col ( @{$self->{select_columns}} ) {
        $data{$col} = $self->get_column($col);
    }
    return \%data;
}

sub set_column {
    my ($self, $col, $val) = @_;

    if (ref($val) eq 'SCALAR') {
        $self->{_untrusted_row_data}->{$col} = 1;
    } else {
        $self->{row_data}->{$col} = $self->{skinny}->schema->call_deflate($col, $val);
        $self->{_get_column_cached}->{$col} = $val;
        $self->{_dirty_columns}->{$col} = 1;
    }
}

sub set_columns {
    my ($self, $args) = @_;

    for my $col (keys %$args) {
        $self->set_column($col, $args->{$col});
    }
}

sub set {
    my $self = shift;
    Carp::carp( "set method has been deprecated. Please use set_columns or set_column method instead" );
    $self->set_columns(@_);
}

sub get_dirty_columns {
    my $self = shift;

    my %rows = map {$_ => $self->{_get_column_cached}->{$_}}
               keys %{$self->{_dirty_columns}};

    return \%rows;
}

sub insert {
    my $self = shift;

    $self->{skinny}->find_or_create($self->{opt_table_info}, $self->get_columns);
}

sub update {
    my ($self, $args, $table) = @_;

    $table ||= $self->{opt_table_info};
    my $upd = $self->get_dirty_columns;
    map {$upd->{$_} = $args->{$_}} keys %$args;

    return 0 unless %$upd;

    my $result = $self->{skinny}->update($table, $upd, $self->_where_cond($table));
    $self->set_columns($upd);
    $self->{_dirty_columns} = {};

    return $result;
}

sub delete {
    my ($self, $table) = @_;

    $table ||= $self->{opt_table_info};
    $self->{skinny}->delete($table, $self->_where_cond($table));
}

sub refetch {
    my ($self, $table) = @_;
    $table ||= $self->{opt_table_info};
    $self->{skinny}->single($table, $self->_where_cond($table));
}

sub _where_cond {
    my ($self, $table) = @_;

    unless ($table) {
        Carp::croak "no table info";
    }

    my $schema_info = $self->{skinny}->schema->schema_info;
    unless ( $schema_info->{$table} ) {
        Carp::croak "unknown table: $table";
    }

    # get target table pk
    my $pk = $schema_info->{$table}->{pk};
    unless ($pk) {
        Carp::croak "$table have no pk.";
    }

    # multi primary keys
    if ( ref $pk eq 'ARRAY' ) {
        my %pks = map { $_ => 1 } @$pk;

        unless ( ( grep { exists $pks{ $_ } } @{$self->{select_columns}} ) == @$pk ) {
            Carp::croak "can't get primary columns in your query.";
        }

        return +{ map { $_ => $self->$_() } @$pk };
    } else {
        unless (grep { $pk eq $_ } @{$self->{select_columns}}) {
            Carp::croak "can't get primary column in your query.";
        }