lib/DBIx/Class/CDBICompat/LazyLoading.pm

   1 package # hide from PAUSE
   2     DBIx::Class::CDBICompat::LazyLoading;
   3
   4 use strict;
   5 use warnings;
   6
   7 use base 'DBIx::Class';
   8
   9 sub resultset_instance {
  10   my $self = shift;
  11   $self->next::method(@_)
  12         ->search_rs(undef, { columns => [ $self->columns('Essential') ] });
  13 }
  14
  15
  16 # Emulate that CDBI throws out all changed columns and reloads them on
  17 # request in case the database modifies the new value (say, via a trigger)
  18 sub update {
  19     my $self = shift;
  20
  21     my @dirty_columns = keys %{$self->{_dirty_columns}};
  22
  23     my $ret = $self->next::method(@_);
  24     $self->_clear_column_data(@dirty_columns);
  25
  26     return $ret;
  27 }
  28
  29
  30 # And again for create
  31 sub create {
  32     my $class = shift;
  33     my($data) = @_;
  34
  35     my @columns = keys %$data;
  36
  37     my $obj = $class->next::method(@_);
  38     return $obj unless defined $obj;
  39
  40     my %primary_cols = map { $_ => 1 } $class->primary_columns;
  41     my @data_cols = grep !$primary_cols{$_}, @columns;
  42     $obj->_clear_column_data(@data_cols);
  43
  44     return $obj;
  45 }
  46
  47
  48 sub _clear_column_data {
  49     my $self = shift;
  50
  51     delete $self->{_column_data}{$_}     for @_;
  52     delete $self->{_inflated_column}{$_} for @_;
  53 }
  54
  55
  56 sub get_column {
  57   my ($self, $col) = @_;
  58   if ((ref $self) && (!exists $self->{'_column_data'}{$col})
  59     && $self->{'_in_storage'}) {
  60     $self->_flesh(grep { exists $self->_column_groups->{$_}{$col}
  61                            && $_ ne 'All' }
  62                    keys %{ $self->_column_groups || {} });
  63   }
  64   $self->next::method(@_[1..$#_]);
  65 }
  66
  67 # CDBI does not explicitly declare auto increment columns, so
  68 # we just clear out our primary columns before copying.
  69 sub copy {
  70   my($self, $changes) = @_;
  71
  72   for my $col ($self->primary_columns) {
  73     $changes->{$col} = undef unless exists $changes->{$col};
  74   }
  75
  76   return $self->next::method($changes);
  77 }
  78
  79 sub discard_changes {
  80   my($self) = shift;
  81
  82   delete $self->{_column_data}{$_} for $self->is_changed;
  83   delete $self->{_dirty_columns};
  84   delete $self->{_relationship_data};
  85
  86   return $self;
  87 }
  88
  89 sub _ident_cond {
  90   my ($class) = @_;
  91   return join(" AND ", map { "$_ = ?" } $class->primary_columns);
  92 }
  93
  94 sub _flesh {
  95   my ($self, @groups) = @_;
  96   @groups = ('All') unless @groups;
  97   my %want;
  98   $want{$_} = 1 for map { keys %{$self->_column_groups->{$_}} } @groups;
  99   if (my @want = grep { !exists $self->{'_column_data'}{$_} } keys %want) {
 100     my $cursor = $self->result_source->schema->storage->select(
 101                 $self->result_source->name, \@want,
 102                 \$self->_ident_cond, { bind => [ $self->_ident_values ] });
 103     #my $sth = $self->storage->select($self->_table_name, \@want,
 104     #                                   $self->ident_condition);
 105     # Not sure why the first one works and this doesn't :(
 106     my @val = $cursor->next;
 107
 108     return unless @val; # object must have been deleted from the database
 109
 110     foreach my $w (@want) {
 111       $self->{'_column_data'}{$w} = shift @val;
 112     }
 113   }
 114 }
 115
 116 1;