Re: Stolen Ideas

[prev] [thread] [next] [Date index for 2004/08/24]

On Tue, Aug 10, 2004 at 07:42:29PM -0400, Perrin Harkins wrote:
> On Tue, 2004-08-10 at 19:16, Tony Bowden wrote:
> > > I realized that my sample case, where search is fast but fetching
> > > objects is slow, was an anomaly.  For most people, search is the slow
> > > part.
> > 
> > How would the results be cached?
> 
> The same as objects would be cached, using a caching module.  My current
> plan is to create some new modules that glue faster storage methods
> (BerkeleyDB, Cache::FastMmap, memcached) under the Cache::Cache API. 
> The current Cache::Cache implementations are too slow to be useful for
> much of anything.
> 
> > Perhaps a Class::DBI::Plugin::FastDelete that you can explicitly use
> > when you know what you're doing is safe?
> 
> Yes, that would work.  Or it could just check to see if there are any
> triggers.

See appended working code.

I'd be happy for someone to turn this into a plugin (though 'fast'
is true it's not the best name, especially with auto-fallback to
per-row behaviour if triggers are present).

Tim.



sub update_rows { # Class->update_rows(where => { ... }, set => { ... });
    my ($class, %args) = @_;
    $class->_carp("$class->update_rows isn't an instance method")
	if ref $class;
    my $where  = delete $args{where} || {};
    my $bypass = delete $args{bypass_update_triggers};
    my $set    = delete $args{set}
	or $class->_croak("$class->update_rows called with no set clause");
    keys %args == 0
	or $class->_croak("$class->update_rows called with unknown parameters: @{[ %args ]}");

    unless ($bypass) {
	# in future if $bypass isn't true then we'll check if any
	# update triggers exist and if they do then we'll automatically
	# switch to a per-row mode
	$class->_croak("$class->update_rows currently requires bypass_update_triggers=>1");
    }

    require SQL::Abstract;
    $sql_abs ||= SQL::Abstract->new;

    my ($where_sql, @bind) = ($where eq "ALL") ? ("") : $sql_abs->where($where);
    $class->_croak("$class->update_rows called with no where clause (use 'ALL' to update all rows)")
	if !$where_sql and $where ne "ALL";
    
    $set = { %$set };	# copy so we can edit safely
    my @set_sql;	# fragments of SET sql

    for my $column (sort keys %$set) {
	$class->_croak("Column $column doesn't exist in $class")
	    unless $class->find_column($column);

	# process any \"literal sql" values first
	# (should not be used for simple values as it bypasses
	# normalize_column_values and validate_column_values)
	next unless ref $set->{$column};

	my $value = delete $set->{$column}; # note delete()
	push @set_sql, "$column=$$value";
    }

    # normalize and validate the new column values
    # (we're calling these as class methods, the implementation of
    # the methods is expected to cope with that)
    $class->normalize_column_values($set);
    # calls before_set_$column triggers created by add_constraint()
    $class->validate_column_values($set);

    for my $column (sort keys %$set) {
	my $value = $set->{$column};
	# unshift so @bind values in sync with placeholders for SET
	unshift @set_sql, "$column=?";
	unshift @bind, $value;
    }

    my $dbh = $class->db_Main;
    my $sth = $dbh->prepare_cached(sprintf "UPDATE %s SET %s %s",
	$class->table, join(", ", @set_sql), $where_sql);
    return $sth->execute(@bind);
}

sub delete_rows { # Class->delete_rows(where => { ... }, set => { ... });
    my ($class, %args) = @_;
    $class->_carp("$class->delete_rows isn't an instance method")
	if ref $class;
    my $where = delete $args{where} || {};
    my $bypass = delete $args{bypass_delete_triggers};
    keys %args == 0
	or $class->_croak("$class->delete_rows called with unknown parameters: @{[ %args ]}");

    unless ($bypass) {
	# in future if $bypass isn't true then we'll check if any
	# delete triggers exist and if they do then we'll automatically
	# switch to a per-row mode
	$class->_croak("$class->delete_rows currently requires bypass_delete_triggers=>1");
    }

    require SQL::Abstract;
    $sql_abs ||= SQL::Abstract->new;

    my ($where_sql, @bind) = ($where eq "ALL") ? ("") : $sql_abs->where($where);
    $class->_croak("$class->delete_rows called with no where clause (use 'ALL' to delete all rows)")
	if !$where_sql and $where ne "ALL";
    
    my $dbh = $class->db_Main;
    my $sth = $dbh->prepare_cached(sprintf "DELETE FROM %s %s",
	$class->table, $where_sql);
    return $sth->execute(@bind);
}