use DBIx::Class::Exception;
use Scalar::Util 'blessed';
+use List::Util 'first';
use Try::Tiny;
###
warn "MC $self inserting (".join(', ', $self->get_columns).")\n";
};
+ # perform the insert - the storage will return everything it is asked to
+ # (autoinc primary columns and any retrieve_on_insert columns)
my %current_rowdata = $self->get_columns;
-
- # perform the insert - the storage may return some stuff for us right there
- #
my $returned_cols = $storage->insert(
$source,
- \%current_rowdata,
+ { %current_rowdata }, # what to insert, copy because the storage *will* change it
);
for (keys %$returned_cols) {
- $self->store_column(
- $_,
- ( $current_rowdata{$_} = $returned_cols->{$_} )
- );
+ $self->store_column($_, $returned_cols->{$_})
+ # this ensures we fire store_column only once
+ # (some asshats like overriding it)
+ if (
+ (!exists $current_rowdata{$_})
+ or
+ (defined $current_rowdata{$_} xor defined $returned_cols->{$_})
+ or
+ (defined $current_rowdata{$_} and $current_rowdata{$_} ne $returned_cols->{$_})
+ );
}
- # see if any of the pcols still need filling (or re-querying in case of scalarrefs)
- my @missing_pri = grep
- { ! defined $current_rowdata{$_} or ref $current_rowdata{$_} eq 'SCALAR' }
- $self->primary_columns
- ;
-
- if (@missing_pri) {
- MULTICREATE_DEBUG and warn "MC $self fetching missing PKs ".join(', ', @missing_pri )."\n";
-
- $self->throw_exception( "Missing primary key but Storage doesn't support last_insert_id" )
- unless $storage->can('last_insert_id');
-
- my @pri_values = $storage->last_insert_id($self->result_source, @missing_pri);
-
- $self->throw_exception( "Can't get last insert id" )
- unless (@pri_values == @missing_pri);
-
- $self->store_column($missing_pri[$_] => $pri_values[$_]) for 0 .. $#missing_pri;
- }
+ delete $self->{_column_data_in_storage};
+ $self->in_storage(1);
$self->{_dirty_columns} = {};
$self->{related_resultsets} = {};
}
}
- $self->in_storage(1);
- delete $self->{_orig_ident};
- delete $self->{_orig_ident_failreason};
delete $self->{_ignore_at_insert};
+
$rollback_guard->commit if $rollback_guard;
return $self;
If the values passed or any of the column values set on the object
contain scalar references, e.g.:
- $row->last_modified(\'NOW()');
+ $row->last_modified(\'NOW()')->update();
# OR
$row->update({ last_modified => \'NOW()' });
my %to_update = $self->get_dirty_columns
or return $self;
- my $ident_cond = $self->{_orig_ident} || $self->ident_condition;
$self->throw_exception( "Not in database" ) unless $self->in_storage;
- $self->throw_exception($self->{_orig_ident_failreason})
- if ! keys %$ident_cond;
-
my $rows = $self->result_source->storage->update(
- $self->result_source, \%to_update, $ident_cond
+ $self->result_source, \%to_update, $self->_storage_ident_condition
);
if ($rows == 0) {
$self->throw_exception( "Can't update ${self}: row not found" );
}
$self->{_dirty_columns} = {};
$self->{related_resultsets} = {};
- delete $self->{_orig_ident};
+ delete $self->{_column_data_in_storage};
return $self;
}
if (ref $self) {
$self->throw_exception( "Not in database" ) unless $self->in_storage;
- my $ident_cond = $self->{_orig_ident} || $self->ident_condition;
- $self->throw_exception($self->{_orig_ident_failreason})
- if ! keys %$ident_cond;
-
$self->result_source->storage->delete(
- $self->result_source, $ident_cond
+ $self->result_source, $self->_storage_ident_condition
);
- delete $self->{_orig_ident}; # no longer identifiable
+ delete $self->{_column_data_in_storage};
$self->in_storage(undef);
}
else {
=back
Throws an exception if the column name given doesn't exist according
-to L</has_column>.
+to L<has_column|DBIx::Class::ResultSource/has_column>.
Returns a raw column value from the row object, if it has already
been fetched from the database or set by an accessor.
sub set_column {
my ($self, $column, $new_value) = @_;
- # if we can't get an ident condition on first try - mark the object as unidentifiable
- # (by using an empty hashref) and store the error for further diag
- unless ($self->{_orig_ident}) {
- try {
- $self->{_orig_ident} = $self->ident_condition
- }
- catch {
- $self->{_orig_ident_failreason} = $_;
- $self->{_orig_ident} = {};
- };
- }
+ my $had_value = $self->has_column_loaded($column);
+ my ($old_value, $in_storage) = ($self->get_column($column), $self->in_storage)
+ if $had_value;
- my $old_value = $self->get_column($column);
$new_value = $self->store_column($column, $new_value);
my $dirty =
$self->{_dirty_columns}{$column}
||
- $self->in_storage # no point tracking dirtyness on uninserted data
+ $in_storage # no point tracking dirtyness on uninserted data
? ! $self->_eq_column_values ($column, $old_value, $new_value)
: 1
;
delete $self->{_inflated_column}{$rel};
}
}
+
+ if (
+ # value change from something (even if NULL)
+ $had_value
+ and
+ # no storage - no storage-value
+ $in_storage
+ and
+ # no value already stored (multiple changes before commit to storage)
+ ! exists $self->{_column_data_in_storage}{$column}
+ and
+ $self->_track_storage_value($column)
+ ) {
+ $self->{_column_data_in_storage}{$column} = $old_value;
+ }
}
return $new_value;
}
}
+# returns a boolean indicating if the passed column should have its original
+# value tracked between column changes and commitment to storage
+sub _track_storage_value {
+ my ($self, $col) = @_;
+ return defined first { $col eq $_ } ($self->primary_columns);
+}
+
=head2 set_columns
$row->set_columns({ $col => $val, ... });
next unless $rel_info->{attrs}{cascade_copy};
my $resolved = $self->result_source->_resolve_condition(
- $rel_info->{cond}, $rel, $new
+ $rel_info->{cond}, $rel, $new, $rel
);
my $copied = $rels_copied->{ $rel_info->{source} } ||= {};
foreach my $pre (keys %{$prefetch||{}}) {
- my $pre_source = $source->related_source($pre)
- or $class->throw_exception("Can't prefetch non-existent relationship ${pre}");
-
- my $accessor = $source->relationship_info($pre)->{attrs}{accessor}
- or $class->throw_exception("No accessor for prefetched $pre");
-
my @pre_vals;
- if (ref $prefetch->{$pre}[0] eq 'ARRAY') {
- @pre_vals = @{$prefetch->{$pre}};
+ if (! @{$prefetch->{$pre}}) {
+ # nothing, empty @pre_vals is put in the caches
}
- elsif ($accessor eq 'multi') {
- $class->throw_exception("Implicit prefetch (via select/columns) not supported with accessor 'multi'");
+ elsif (ref $prefetch->{$pre}[0] eq 'ARRAY') {
+ @pre_vals = @{$prefetch->{$pre}};
}
else {
@pre_vals = $prefetch->{$pre};
}
+ my $pre_source = $source->related_source($pre);
+
+ my $accessor = $source->relationship_info($pre)->{attrs}{accessor}
+ or $class->throw_exception("No accessor type declared for prefetched relationship '$pre'");
+
my @pre_objects;
for my $me_pref (@pre_vals) {
- # FIXME - this should not be necessary
- # the collapser currently *could* return bogus elements with all
- # columns set to undef
- my $has_def;
- for (values %{$me_pref->[0]}) {
- if (defined $_) {
- $has_def++;
- last;
- }
- }
- next unless $has_def;
+ # FIXME SUBOPTIMAL - the new row parsers can very well optimize
+ # this away entirely, and *never* return such empty rows.
+ # For now we maintain inflate_result API backcompat
+ next unless first { defined $_ } values %{$me_pref->[0]};
- push @pre_objects, $pre_source->result_class->inflate_result(
- $pre_source, @$me_pref
- );
+ push @pre_objects, $pre_source->result_class->inflate_result(
+ $pre_source, @$me_pref
+ );
}
if ($accessor eq 'single') {
$resultset = $resultset->search(undef, $attrs);
}
- my $ident_cond = $self->{_orig_ident} || $self->ident_condition;
-
- $self->throw_exception($self->{_orig_ident_failreason})
- if ! keys %$ident_cond;
-
- return $resultset->find($ident_cond);
+ return $resultset->find($self->_storage_ident_condition);
}
=head2 discard_changes ($attrs?)
}
}
-
=head2 throw_exception
See L<DBIx::Class::Schema/throw_exception>.
Returns the primary key(s) for a row. Can't be called as a class method.
Actually implemented in L<DBIx::Class::PK>
-1;
-
=head1 AUTHORS
Matt S. Trout <mst@shadowcatsystems.co.uk>
projects / dbsrgits/DBIx-Class.git / blobdiff