view release on metacpan or  search on metacpan

lib/Ambrosia/EntityDataModel.pm  view on Meta::CPAN

    elsif ( $self->need_update )
    {
        $self->update;
    }
    else
    {
        assert {0} 'Unknown state="' . $self->_state . '"';
        return new Ambrosia::core::Nil;
    }

    $self->SET_SAVED;
    $self->after_save(@_);
    return $self;
}

#catalog -- schema(db name) -- table
sub insert
{
    my $self = shift;

    my $driver = storage->driver($self->driver_type, $self->source_name);
    assert {$driver} 'Unknown source for insert data: ' . ($self->source_name || 'undefined source');
    return new Ambrosia::core::Nil unless $driver;

    $driver->reset()
        ->source( $self->source_path() )
        ->insert()
        ->what( $self->fields_mapping() )
        ->execute( $self->value($self->fields) );

    if ( (my $pk = $self->primary_key()) && $self->IS_NEW )
    {
        $self->$pk = $driver->last_insert_id($self->source_path(), $pk);
        $driver->cache->set($self->get_cache_code(), $self);
    }
}

sub delete
{
    my $self = shift;

    my $driver = storage->driver($self->driver_type, $self->source_name);
    assert {$driver} 'Unknown source for delete data: ' . ($self->source_name || 'undefined source');
    return new Ambrosia::core::Nil unless $driver;

    my %cond = @_;
    my $q = $driver->reset()
        ->source( $self->source_path() )
        ->delete();
    foreach ( keys %cond )
    {
        $q->predicate($_, '=', $cond{$_});
    }
    $q->execute(0);
    if ( ref $self )
    {
        $driver->cache->delete($self->get_cache_code());
    }
}

sub update
{
    my $self = shift;

    my $driver = storage->driver($self->driver_type, $self->source_name);
    assert {$driver} 'Unknown source for update data: ' . ($self->source_name || 'undefined source');
    return new Ambrosia::core::Nil unless $driver;

    my $q = $driver->reset()
        ->source( $self->source_path() )
        ->update()
        ->what( $self->fields_mapping() );

    foreach ( pare_list($self->key, $self->key_value) )
    {
        $q->predicate($_->[0], '=', $_->[1]);
    }
    $q->execute($self->value($self->edit_fields));
}

sub find
{
    my $proto = shift;
    my $class = ref($proto) || $proto;
    my $var = shift || my $entity;

    my $driver = storage->driver($class->driver_type, $class->source_name);
    assert {$driver} 'Unknown source for find data: ' . ($class->source_name || 'undefined source');
    return new Ambrosia::core::Nil unless $driver;

    my $source_path = join '_', grep defined $_, $class->source_path();

    return Ambrosia::EntityDataModel::_find->new(
                edm => $class,
                var => \$var,
                query => Ambrosia::QL
                    ->from([$class->source_path()], \$var)
                    ->in($driver)
                    ->what($class->fields_mapping)
                    ->select(sub {
                            my %h = map { my $v = $var->{$_}; s/^${source_path}_//; $_ => $v } keys %$var;
                            %$var = %h;
                            if ( my $old = $driver->cache->get($class->get_cache_code($class->id_value_from_hash(\%h))) )
                            {
                                return $old;
                            }
                            my $e = $class->new(%h);
                            $driver->cache->set($e->get_cache_code, $e);
                            $e->after_load;
                            return $e;
                        })
                );

}

sub link_one2one
{
    no strict 'refs';
    my $proto = shift;
    my %params = @_;
    my $type = $params{type};