Database insert isn't executed in nested transaction - php

Question

I want to check whether the user has changed the Document image in the edit form. If the user changed the image, I have to delete the old one from database and filesystem, then I have to add the new one (in both db and filesystem).
Problem: if I edit a Document which has already got an image on the DB (so if $oldImage = $this->getImageByDocumentId($docId) actually returns $oldImage), everything works. But if the Document hasn't got any $oldImage, something goes wrong and it doesn't insert the new Image on DB (but It saves it on filesystem!)
This is part of my MySQLDocumentService:
public function editDocument($document) {
try {
$conn = $this->getAdapter();
$conn->beginTransaction();
$sql = "UPDATE Documents d
SET d.name=:name, d.description=:description, d.content_id=:contentId, d.category_id=:categoryId, d.sharer_id=:sharerId, d.rating_id=:ratingId, d.price=:price
WHERE d.document_id=:id";
$prepStatement = $conn->prepare($sql);
$prepStatement->execute(array(':id' => $document->getId(),
':name' => $document->getName(),
':description' => $document->getDescription(),
':contentId' => rand(1,2000),
':categoryId' => $document->getCategory()->getId(),
':sharerId' => 1,
':ratingId' => 1,
':price' => $document->getPrice()));
// If image has been changed, take the old image name
if (!is_null($document->getImage())) {
$image = $document->getImage();
$docId = $document->getId();
$oldImage = $this->getImageByDocumentId($docId); // Here's the problem: if it doesn't find the oldImage, it doesn't insert the new one
if (!is_null($oldImage)) {
// If previous method succeeded, delete oldImage from DB and filesystem
$oldImageName = $oldImage->getName();
$this->deleteImageByName($oldImageName);
}
// Save new image (chosen on form) on db and filesystem
if (file_exists("uploads/img/" . $image->getName())) {
echo $image->getName() . " already exists. ";
return false;
} else {
move_uploaded_file($image->getTempName(), "uploads/img/" . $image->getName());
}
// Saves image path on DB
// If I edit a Document which has already got an image on the DB, everything works. But if the Document hasn't got any oldImage, something goes wrong and it doesn't insert the new Image on DB (but It saves it on filesystem!)
$sqlImage = 'INSERT INTO Images (name, alt_name, position, description, type, size, document_id)
VALUES ("name", "altName", 2, "description", "type", "size", 2)';
$prepStatementImg = $conn->prepare($sqlImage);
$prepStatementImg->execute();
}
$conn->commit();
return true;
} catch (Exception $e) {
$conn->rollBack();
echo "Failed: " . $e->getMessage();
}
}
public function getImageByDocumentId($docId) {
try {
$conn = $this->getAdapter();
$conn->beginTransaction();
$sql = 'SELECT i.image_id, i.document_id, i.name, i.alt_name, i.position, i.description, i.type, i.size
FROM Images i
WHERE i.document_id=:id';
$prepStatement = $conn->prepare($sql);
$prepStatement->execute(array(':id' => $docId));
$result = $prepStatement->fetch();
if ($result) {
$image = new Image();
$image->setName($result['name']);
$image->setId($result['image_id']);
$image->setAltName($result['alt_name']);
$image->setDescription($result['description']);
$image->setPosition($result['position']);
$image->setType($result['type']);
$image->setSize($result['size']);
// Manca la costruzione del relativo documento, ma non penso serva
$conn->commit();
return $image;
} else {
return null;
}
} catch (Exception $e) {
$conn->rollBack();
echo "Failed: " . $e->getMessage();
}
}
public function deleteImageByName($imgName) {
try {
$imgName = str_replace( array( '..', '/', '\\', ':' ), '', $imgName );
unlink( "uploads/img/" . $imgName );
} catch (Exception $fsEx) {
echo "Failed: " . $fsEx->getMessage();
}
try {
$conn = $this->getAdapter();
$conn->beginTransaction();
$sql = 'DELETE FROM Images
WHERE name=:name';
$prepStatement = $conn->prepare($sql);
$prepStatement->execute(array(':name' => $imgName));
$conn->commit();
return true;
} catch (Exception $e) {
$conn->rollBack();
echo "Failed: " . $e->getMessage();
}
}
If I comment $oldImage = $this->getImageByDocumentId($docId) it commits the INSERT of the new Image on DB and everything works.
I thought it could have been an issue with nested transactions, but it's strange since everything works when $oldImage is correctly found on db. (I also created a class that extends PDO class, as written on this guide).
What can I do?
EDIT: In one of the kind answers below (by Soyale), arose doubts about nested methods and multiple transitions. I thereby paste my MyPDO class, which should avoid multiple transitions (I hope so, at least). It's taken by bitluni's comment on PDO::beginTransaction manual page.
class MyPDO extends PDO {
protected $transactionCounter = 0;
function beginTransaction()
{
if(!$this->transactionCounter++)
return parent::beginTransaction();
return $this->transactionCounter >= 0;
}
function commit()
{
if(!--$this->transactionCounter)
return parent::commit();
return $this->transactionCounter >= 0;
}
function rollback()
{
if($this->transactionCounter >= 0)
{
$this->transactionCounter = 0;
return parent::rollback();
}
$this->transactionCounter = 0;
return false;
}
}
As Soyale stated,
parent::openTransaction [I think it's a typo for beginTransaction()] isn't good idea too. Or maybe if you have some flag that one of transaction was opened already it could pass the exam.
I think that transactionCounter could be the flag you're talking about. In my mind, this will let me commit and rollback properly. Am I wrong?

Answer 1

in my opinion You have mistake in this method: getImageByDocumentId.
You don't commit transaction in this fragmenty:
if ($result) {
$image = new Image();
$image->setName($result['name']);
$image->setId($result['image_id']);
$image->setAltName($result['alt_name']);
$image->setDescription($result['description']);
$image->setPosition($result['position']);
$image->setType($result['type']);
$image->setSize($result['size']);
// Manca la costruzione del relativo documento, ma non penso serva
$conn->commit();
return $image;
} else {
$conn->commit(); //Add this line :)
return null;
}
I'm wondering why are so many transactions there? It should be in one transaction so if one query fails then you can rollback all of them.
Some more words about transactions:
Lets look at your code:
public function editDocument($document) {
$conn = $this->getAdapter();
$conn->beginTransaction(); // 1-st open transaction
$this->getImageByDocumentId(...); // 2-nd opened transaction
$this->deleteImageByName(...); // And the third one
}
public function getImageByDocumentId($docId) {
$conn = $this->getAdapter();
$conn->beginTransaction();
//This method mainly select some data from DB so do you need transaction here ?
//Query in this method does not affect any data
//Data remains unchanged
//So you can use sth like this
$conn = $this->getAdapter();
//$conn->beginTransaction(); //-> tyhis line is useless
$sql = 'SELECT i.image_id, i.document_id, i.name, i.alt_name, i.position,
i.description, i.type, i.size
FROM Images i
WHERE i.document_id=:id';
$prepStatement = $conn->prepare($sql);
$prepStatement->execute(array(':id' => $docId));
$result = $prepStatement->fetch();
//(...) rest of code
}
public function deleteImageByName($imgName) {
$conn = $this->getAdapter();
$conn->beginTransaction();
}
as You can see every of yours method contains beginTransaction() It's a bit messy and lead to nested transactions and commits. I'm working mainly with Firebird DB and there if new transaction opened is the old one is moved down (we receive new resource handler).
Most interesting is deleteImageByName() method. As you can see there is already open one transaction (from editDocument()). Now You are opening the second one. Now you have delete your image deleteImageByName() has return true and commit transaction.
public function deleteImageByName($imgName) {
//In my opinion this fragment should go after successfully deleted from database
//and insert new image (prevent data loss)
try {
$imgName = str_replace( array( '..', '/', '\\', ':' ), '', $imgName );
unlink( "uploads/img/" . $imgName );
} catch (Exception $fsEx) {
echo "Failed: " . $fsEx->getMessage();
}
//here you are deleting db record
try {
$conn = $this->getAdapter();
$conn->beginTransaction();
$sql = 'DELETE FROM Images
WHERE name=:name';
$prepStatement = $conn->prepare($sql);
$prepStatement->execute(array(':name' => $imgName));
//And you are commiting this (bad idea if there is more than only delete task)
$conn->commit();
return true;
} catch (Exception $e) {
$conn->rollBack();
echo "Failed: " . $e->getMessage();
}
}
Now if from some reason the insert fails, then you don't have new image nor the old one.
If there will be only one transaction (in main method editDocument()) you can rollback transaction and don't delete old image.
parent::openTransaction isn't good idea too. Or maybe if you have some flag that one of transaction was opened allready it could pass the exam.
Generally you should open transaction for one task. Lets suppose that your task is: editDocument. editDocument isn't simple action. It consist of bunch of other actions so the transaction (only one transaction from master method) should include all of these actions. (in your case delete old image and insert new one). Stomething like this:
public function editDocument() {
$conn = $this->getAdapter();
$conn->beginTransaction();
//1. $this->deleteOldImage();
//2. $this->insertNewOne();
//3. $this->deleteFileWithOldImage();
//Of every method should consist fail statement: $conn->rollback(); and throw exception
$conn->commit();
}
Sorry for my english :)
Edit: -> Why your class isn't so good
#KurtBourbaki This extension looks nice but it isn't. Please note that if you forgot to commit opened transaction then you continued with mess. In your question there was one mistake. Missing line. Please try to use your class with that bug. How it works ? Lets analize it:
class MyPDO extends PDO {
protected $transactionCounter = 0;
//1. Increment counter regardless of whether it was set
//2. PDO::beginTransaction() only if counter was 0
function beginTransaction()
{
if(!$this->transactionCounter++)
return parent::beginTransaction();
return $this->transactionCounter >= 0;
}
//This is interesting
//1. decrement counter
//2. PDO::commit() but only when decrement counter == 0
//So there is a core place because even with that class your primary bug will occur
//because You have omitted exactly this one command.
function commit()
{
if(!--$this->transactionCounter)
return parent::commit();
return $this->transactionCounter >= 0;
}
//rollback transaction looks good
}
I don't know why this answer was voted so high on php.net.
I saw there better solution than that. There is solution with simply private boolean flag posted by drm at melp dot nl on http://pl1.php.net/manual/en/pdo.begintransaction.php.
I prefer this one because it really doesn't allow to open multiple transaction.
EDIT:
As Kurt pointed out my choice isn't good either.
So as I have written in my last comment. My preferred solution is to never open nested transaction. There are some informations about transactions in documentation for DBMS. Most popular DB MySQL

Answer 2

try replacing, inside getImageByDocumentId function,
if($result)
by
if($prepStatement->rowCount()>0)
I think you're entering into the if when $prepStatement is executed, whether it has results or not, so your image is being empty, causing your script to break

Answer 3

If you insert data directly in your query you must have a $pdo->query not $pdo->prepare, well that's what I think
I believe your query should be
// Saves image path on DB
// If I edit a Document which has already got an image on the DB, everything works. But if the Document hasn't got any oldImage, something goes wrong and it doesn't insert the new Image on DB (but It saves it on filesystem!)
$sqlImage = 'INSERT INTO Images (name, alt_name, position, description, type, size, document_id)
VALUES (:name, :altName, :position, :description, :type, :size, :id)';
$prepStatementImg = $conn->prepare($sqlImage);