eval {
    my $sth = $dbh -> prepare (<<'    --');
               update  new_table 
                  set  newData = ? 
                where  newID   = ?
    --
    while (my ($id, $data) = each %Data) {
        $sth -> execute ($data, $id)
    }
};
if ($@) {
    $dbh -> rollback;
    die $@;
}
else {
    $dbh -> commit;
}
[download]

Abigail

assuming you have transactions turned on (which you really, really want), and RaiseError as well)

I'm going to take issue with the transactions part of this statement. Transactions can be necessary in many cases. However, one of the benefits of MySQL over, say, Oracle is that you can choose whether or not you want transactions or not. In a majority of cases, you don't actually need transactions because your transactions are all one statement long.

The benefit of ACID-compliant transactions is the ability to rollback multi-statement changes. If your one-statement transaction fails, nothing has actually occurred to change the state of the tables involved.

By using a table type that doesn't have transactions (such as the default MyISAM), you can do many activities (like bulk inserts) 5-10x faster. If you don't need transactions, that's a huge benefit.

------
We are the carpenters and bricklayers of the Information Age.

Then there are Damian modules.... *sigh* ... that's not about being less-lazy -- that's about being on some really good drugs -- you know, there is no spoon. - flyingmoose

I shouldn't have to say this, but any code, unless otherwise stated, is untested

If your one-statement transaction fails, nothing has actually occurred to change the state of the tables involved.

It would only be a one-statement transaction if %Data contains less than two elements. It's unlikely that that is the common case.

Transactions are a bit like "use strict" (except they prevent you from real harm). While there are cases you don't need "use strict", it's a good idea to get into the habit of using them, and only in special cases you don't use them.

By using a table type that doesn't have transactions

... you have committed yourself to never be able to use transaction on modifications of that table. Why bother with a database in such a case? Might as well use a bunch of DBM files.

If you don't need transactions

Famous last words, and belongs in the series "we don't need backups", "we don't need redundancy", "we don't need to look around when crossing the street". And indeed, most of the time, you don't need them. You just never know when you do.

Abigail

Hey Abigail,

Please enlighten me on the last bit of your code which I reproduced below:

if ($@) {
    $dbh -> rollback;
    die $@;
}
else {
    $dbh -> commit;
}

# Can we leave out the 'else' and just say:

if ($@) {
    $dbh -> rollback;
    die $@;
}
$dbh -> commit;
[download]

Is there any difference?

Sure, you can leave off the else, but that makes your code less flexible. Suppose you want to replace the die with a warn, then you shouldn't forget introduce the else. Again, if there's just a commit, not much of a problem, if there are a whole bunch of statements, you have to figure out which ones belong logically in the else, and which ones should be run regardless whether the eval block failed. If you start off the else to begin with - or rather, if you use that as a habit, you won't have such problems. Having the else block is more of an engineering issue than a semantic one.

Abigail

sub sql_quote {
  my ($entry) = @_;
  $entry =~ s/'/''/g;
  return "'" . $entry . "'";
}
[download]

$st->execute("%$bar");
[download]

my $insert = $dbh->prepare("insert into table values (?,?,?)");
while (something) {
  $insert->execute($var1,$var2,$var3);
} # end-while
[download]

Is it also possible to do this

Instead of just saying "yes" or "no", I give you a counter question: what happened when you tried?

Abigail

Touche :)

Thankyou. I sometimes need a slap on the wrist to stop myself becoming lazy :~)

Cheers,
Reagen

Better to get in the habit of specifying your column values:

my $insert = $dbh->prepare("insert into table
(column1, column2, column3) values (?,?,?)");
[download]

OT, but the only time I don't do this is outside of Perl where the language lets me declare record variables like a table:

define some_record like some_table.*

insert into some_table some_record.*
[download]

And even this breaks when columns get out of order between the time you compile the program and run it, so column order becomes one more thing to maintain, and it's better to not have to maintain one more thing. :)