PDO: determining if a transaction is active

[Gordon]

I am currently working on some code for my CMS that creates a site
folder, then creates all the necessary child folders inside it. The
method that creates folders needs to insert into 2 tables so it wraps
the operation in a transaction. (psuedocode below)

public function createItem ($parent)
{
$this -database -beginTransaction ();
$this -database -query ('INSERT INTO items (param1,
param2 ... ) values (val1, val2 ... )');
$newId = myMethodForGettingInsertId ();
$this -database -query ('INSERT INTO folders (id, param3 ... )
values ($newId, val3 ... )');
$this -database -commit ();
return ($newId);
}

(the real code is obviously a lot more sophisticated and has all the
error checking and rollbacks and what have you but the mock up code
below is clearer regarding the intent of the method)

In my site creating class I have something along the lines of

public function createItem ($parent)
{
$this -database -beginTransaction ();
$newId = parent::createItem ($parent);
parent::createItem ($newId, 'images');
parent::createItem ($newId, 'css');
parent::createItem ($newId, 'other_stuff');
$this -database -commit ();
}

This obviously causes an exception. I can take the transaction code
out of my folder class but the creation of a folder should be atomic.
I could leave it out of the site creation class, but I really do need
site creation to be atomic as well.

Is there a way of determining that I am inside a transaction before
attempting to start one?

[Tim Hunt]

On Dec 18, 5:31 pm, Gordon <[e-mail]:

I am currently working on some code for my CMS that creates a site
folder, then creates all the necessary child folders inside it. The
method that creates folders needs to insert into 2 tables so it wraps
the operation in a transaction. (psuedocode below)

public function createItem ($parent)
{
$this -database -beginTransaction ();
$this -database -query ('INSERT INTO items (param1,
param2 ... ) values (val1, val2 ... )');
$newId = myMethodForGettingInsertId ();
$this -database -query ('INSERT INTO folders (id, param3 ... )
values ($newId, val3 ... )');
$this -database -commit ();
return ($newId);

}

(the real code is obviously a lot more sophisticated and has all the
error checking and rollbacks and what have you but the mock up code
below is clearer regarding the intent of the method)

In my site creating class I have something along the lines of

public function createItem ($parent)
{
$this -database -beginTransaction ();
$newId = parent::createItem ($parent);
parent::createItem ($newId, 'images');
parent::createItem ($newId, 'css');
parent::createItem ($newId, 'other_stuff');
$this -database -commit ();

}

This obviously causes an exception. I can take the transaction code
out of my folder class but the creation of a folder should be atomic.
I could leave it out of the site creation class, but I really do need
site creation to be atomic as well.

Is there a way of determining that I am inside a transaction before
attempting to start one?

Only if you keep track of it yourself, write your own
beginTransaction() and commit() methods and use a transaction count
variable.

All calls to your own beginTransaction() and commit() methods
increment/decrement the transaction counter respectively. Only the
first call to beginTransaction calls $this->database->beginTransaction
and $this->database->commit() is only called when the transaction
counter reaches 0 again.

[Gordon]

On Dec 19, 12:33 pm, Tim Hunt <[e-mail]:

On Dec 18, 5:31 pm, Gordon <[e-mail]:

I am currently working on some code for my CMS that creates a site
folder, then creates all the necessary child folders inside it. The
method that creates folders needs to insert into 2 tables so it wraps
the operation in a transaction. (psuedocode below)

public function createItem ($parent)
{
$this -database -beginTransaction ();
$this -database -query ('INSERT INTO items (param1,
param2 ... ) values (val1, val2 ... )');
$newId = myMethodForGettingInsertId ();
$this -database -query ('INSERT INTO folders (id, param3 ... )
values ($newId, val3 ... )');
$this -database -commit ();
return ($newId);

}

(the real code is obviously a lot more sophisticated and has all the
error checking and rollbacks and what have you but the mock up code
below is clearer regarding the intent of the method)

In my site creating class I have something along the lines of

public function createItem ($parent)
{
$this -database -beginTransaction ();
$newId = parent::createItem ($parent);
parent::createItem ($newId, 'images');
parent::createItem ($newId, 'css');
parent::createItem ($newId, 'other_stuff');
$this -database -commit ();

}

This obviously causes an exception. I can take the transaction code
out of my folder class but the creation of a folder should be atomic.
I could leave it out of the site creation class, but I really do need
site creation to be atomic as well.

Is there a way of determining that I am inside a transaction before
attempting to start one?

Only if you keep track of it yourself, write your own
beginTransaction() and commit() methods and use a transaction count
variable.

All calls to your own beginTransaction() and commit() methods
increment/decrement the transaction counter respectively. Only the
first call to beginTransaction calls $this->database->beginTransaction
and $this->database->commit() is only called when the transaction
counter reaches 0 again.

Yes, that sounds like a cunning plan. I can add that into my PDO
wrapper easily enough I think. Thanks for the help.

[Steve]

"Gordon" <go**********@ntlworld.comwrote in message
news:94**********************************@t1g2000p ra.googlegroups.com...

On Dec 19, 12:33 pm, Tim Hunt <[e-mail]:

>On Dec 18, 5:31 pm, Gordon <[e-mail]:

I am currently working on some code for my CMS that creates a site
folder, then creates all the necessary child folders inside it. The
method that creates folders needs to insert into 2 tables so it wraps
the operation in a transaction. (psuedocode below)

public function createItem ($parent)
{
$this -database -beginTransaction ();
$this -database -query ('INSERT INTO items (param1,
param2 ... ) values (val1, val2 ... )');
$newId = myMethodForGettingInsertId ();
$this -database -query ('INSERT INTO folders (id, param3 ... )
values ($newId, val3 ... )');
$this -database -commit ();
return ($newId);

}

(the real code is obviously a lot more sophisticated and has all the
error checking and rollbacks and what have you but the mock up code
below is clearer regarding the intent of the method)

In my site creating class I have something along the lines of

public function createItem ($parent)
{
$this -database -beginTransaction ();
$newId = parent::createItem ($parent);
parent::createItem ($newId, 'images');
parent::createItem ($newId, 'css');
parent::createItem ($newId, 'other_stuff');
$this -database -commit ();

}

This obviously causes an exception. I can take the transaction code
out of my folder class but the creation of a folder should be atomic.
I could leave it out of the site creation class, but I really do need
site creation to be atomic as well.

Is there a way of determining that I am inside a transaction before
attempting to start one?

Only if you keep track of it yourself, write your own
beginTransaction() and commit() methods and use a transaction count
variable.

All calls to your own beginTransaction() and commit() methods
increment/decrement the transaction counter respectively. Only the
first call to beginTransaction calls $this->database->beginTransaction
and $this->database->commit() is only called when the transaction
counter reaches 0 again.

Yes, that sounds like a cunning plan. I can add that into my PDO
wrapper easily enough I think. Thanks for the help.

being careful to note that you can rollback an entire set of transactional
statments on a per-connection basis as well as rolling back individual
statements.