]> git.stg.codes - stg.git/blob - stglibs/ibpp.lib/transaction.cpp
Ticket 37. The changePolicyTimeout field added in SELECT FROM
[stg.git] / stglibs / ibpp.lib / transaction.cpp
1 ///////////////////////////////////////////////////////////////////////////////\r
2 //\r
3 //      File    : $Id: transaction.cpp,v 1.1 2007/05/05 17:00:43 faust Exp $\r
4 //      Subject : IBPP, Database class implementation\r
5 //\r
6 ///////////////////////////////////////////////////////////////////////////////\r
7 //\r
8 //      (C) Copyright 2000-2006 T.I.P. Group S.A. and the IBPP Team (www.ibpp.org)\r
9 //\r
10 //      The contents of this file are subject to the IBPP License (the "License");\r
11 //      you may not use this file except in compliance with the License.  You may\r
12 //      obtain a copy of the License at http://www.ibpp.org or in the 'license.txt'\r
13 //      file which must have been distributed along with this file.\r
14 //\r
15 //      This software, distributed under the License, is distributed on an "AS IS"\r
16 //      basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See the\r
17 //      License for the specific language governing rights and limitations\r
18 //      under the License.\r
19 //\r
20 ///////////////////////////////////////////////////////////////////////////////\r
21 //\r
22 //      COMMENTS\r
23 //      * Tabulations should be set every four characters when editing this file.\r
24 //\r
25 ///////////////////////////////////////////////////////////////////////////////\r
26 \r
27 #ifdef _MSC_VER\r
28 #pragma warning(disable: 4786 4996)\r
29 #ifndef _DEBUG\r
30 #pragma warning(disable: 4702)\r
31 #endif\r
32 #endif\r
33 \r
34 #include "_ibpp.h"\r
35 \r
36 #ifdef HAS_HDRSTOP\r
37 #pragma hdrstop\r
38 #endif\r
39 \r
40 #include <algorithm>\r
41 \r
42 using namespace ibpp_internals;\r
43 \r
44 //      (((((((( OBJECT INTERFACE IMPLEMENTATION ))))))))\r
45 \r
46 void TransactionImpl::AttachDatabase(IBPP::Database db,\r
47         IBPP::TAM am, IBPP::TIL il, IBPP::TLR lr, IBPP::TFF flags)\r
48 {\r
49         if (db.intf() == 0)\r
50                 throw LogicExceptionImpl("Transaction::AttachDatabase",\r
51                                 _("Can't attach an unbound Database."));\r
52 \r
53         AttachDatabaseImpl(dynamic_cast<DatabaseImpl*>(db.intf()), am, il, lr, flags);\r
54 }\r
55 \r
56 void TransactionImpl::DetachDatabase(IBPP::Database db)\r
57 {\r
58         if (db.intf() == 0)\r
59                 throw LogicExceptionImpl("Transaction::DetachDatabase",\r
60                                 _("Can't detach an unbound Database."));\r
61 \r
62         DetachDatabaseImpl(dynamic_cast<DatabaseImpl*>(db.intf()));\r
63 }\r
64 \r
65 void TransactionImpl::AddReservation(IBPP::Database db,\r
66         const std::string& table, IBPP::TTR tr)\r
67 {\r
68         if (mHandle != 0)\r
69                 throw LogicExceptionImpl("Transaction::AddReservation",\r
70                                 _("Can't add table reservation if Transaction started."));\r
71         if (db.intf() == 0)\r
72                 throw LogicExceptionImpl("Transaction::AddReservation",\r
73                                 _("Can't add table reservation on an unbound Database."));\r
74 \r
75         // Find the TPB associated with this database\r
76         std::vector<DatabaseImpl*>::iterator pos =\r
77                 std::find(mDatabases.begin(), mDatabases.end(), dynamic_cast<DatabaseImpl*>(db.intf()));\r
78         if (pos != mDatabases.end())\r
79         {\r
80                 size_t index = pos - mDatabases.begin();\r
81                 TPB* tpb = mTPBs[index];\r
82                 \r
83                 // Now add the reservations to the TPB\r
84                 switch (tr)\r
85                 {\r
86                         case IBPP::trSharedWrite :\r
87                                         tpb->Insert(isc_tpb_lock_write);\r
88                                         tpb->Insert(table);\r
89                                         tpb->Insert(isc_tpb_shared);\r
90                                         break;\r
91                         case IBPP::trSharedRead :\r
92                                         tpb->Insert(isc_tpb_lock_read);\r
93                                         tpb->Insert(table);\r
94                                         tpb->Insert(isc_tpb_shared);\r
95                                         break;\r
96                         case IBPP::trProtectedWrite :\r
97                                         tpb->Insert(isc_tpb_lock_write);\r
98                                         tpb->Insert(table);\r
99                                         tpb->Insert(isc_tpb_protected);\r
100                                         break;\r
101                         case IBPP::trProtectedRead :\r
102                                         tpb->Insert(isc_tpb_lock_read);\r
103                                         tpb->Insert(table);\r
104                                         tpb->Insert(isc_tpb_protected);\r
105                                         break;\r
106                         /*default :\r
107                                         throw LogicExceptionImpl("Transaction::AddReservation",\r
108                                                 _("Illegal TTR value detected."));*/\r
109                 }\r
110         }\r
111         else throw LogicExceptionImpl("Transaction::AddReservation",\r
112                         _("The database connection you specified is not attached to this transaction."));\r
113 }\r
114 \r
115 void TransactionImpl::Start()\r
116 {\r
117         if (mHandle != 0) return;       // Already started anyway\r
118 \r
119         if (mDatabases.empty())\r
120                 throw LogicExceptionImpl("Transaction::Start", _("No Database is attached."));\r
121 \r
122         struct ISC_TEB\r
123         {\r
124                 ISC_LONG* db_ptr;\r
125                 ISC_LONG tpb_len;\r
126                 char* tpb_ptr;\r
127         } * teb = new ISC_TEB[mDatabases.size()];\r
128 \r
129         unsigned i;\r
130         for (i = 0; i < mDatabases.size(); i++)\r
131         {\r
132                 if (mDatabases[i]->GetHandle() == 0)\r
133                 {\r
134                         // All Databases must be connected to Start the transaction !\r
135                         delete [] teb;\r
136                         throw LogicExceptionImpl("Transaction::Start",\r
137                                         _("All attached Database should have been connected."));\r
138                 }\r
139                 teb[i].db_ptr = (ISC_LONG*) mDatabases[i]->GetHandlePtr();\r
140                 teb[i].tpb_len = mTPBs[i]->Size();\r
141                 teb[i].tpb_ptr = mTPBs[i]->Self();\r
142         }\r
143 \r
144         IBS status;\r
145         (*gds.Call()->m_start_multiple)(status.Self(), &mHandle, (short)mDatabases.size(), teb);\r
146         delete [] teb;\r
147         if (status.Errors())\r
148         {\r
149                 mHandle = 0;    // Should be, but better be sure...\r
150                 throw SQLExceptionImpl(status, "Transaction::Start");\r
151         }\r
152 }\r
153 \r
154 void TransactionImpl::Commit()\r
155 {\r
156         if (mHandle == 0)\r
157                 throw LogicExceptionImpl("Transaction::Commit", _("Transaction is not started."));\r
158                 \r
159         IBS status;\r
160 \r
161         (*gds.Call()->m_commit_transaction)(status.Self(), &mHandle);\r
162         if (status.Errors())\r
163                 throw SQLExceptionImpl(status, "Transaction::Commit");\r
164         mHandle = 0;    // Should be, better be sure\r
165 }\r
166 \r
167 void TransactionImpl::CommitRetain()\r
168 {\r
169         if (mHandle == 0)\r
170                 throw LogicExceptionImpl("Transaction::CommitRetain", _("Transaction is not started."));\r
171 \r
172         IBS status;\r
173 \r
174         (*gds.Call()->m_commit_retaining)(status.Self(), &mHandle);\r
175         if (status.Errors())\r
176                 throw SQLExceptionImpl(status, "Transaction::CommitRetain");\r
177 }\r
178 \r
179 void TransactionImpl::Rollback()\r
180 {\r
181         if (mHandle == 0) return;       // Transaction not started anyway\r
182 \r
183         IBS status;\r
184 \r
185         (*gds.Call()->m_rollback_transaction)(status.Self(), &mHandle);\r
186         if (status.Errors())\r
187                 throw SQLExceptionImpl(status, "Transaction::Rollback");\r
188         mHandle = 0;    // Should be, better be sure\r
189 }\r
190 \r
191 void TransactionImpl::RollbackRetain()\r
192 {\r
193         if (mHandle == 0)\r
194                 throw LogicExceptionImpl("Transaction::RollbackRetain", _("Transaction is not started."));\r
195 \r
196         IBS status;\r
197 \r
198         (*gds.Call()->m_rollback_retaining)(status.Self(), &mHandle);\r
199         if (status.Errors())\r
200                 throw SQLExceptionImpl(status, "Transaction::RollbackRetain");\r
201 }\r
202 \r
203 IBPP::ITransaction* TransactionImpl::AddRef()\r
204 {\r
205         ASSERTION(mRefCount >= 0);\r
206         ++mRefCount;\r
207         return this;\r
208 }\r
209 \r
210 void TransactionImpl::Release()\r
211 {\r
212         // Release cannot throw, except in DEBUG builds on assertion\r
213         ASSERTION(mRefCount >= 0);\r
214         --mRefCount;\r
215         try { if (mRefCount <= 0) delete this; }\r
216                 catch (...) { }\r
217 }\r
218 \r
219 //      (((((((( OBJECT INTERNAL METHODS ))))))))\r
220 \r
221 void TransactionImpl::Init()\r
222 {\r
223         mHandle = 0;\r
224         mDatabases.clear();\r
225         mTPBs.clear();\r
226         mStatements.clear();\r
227         mBlobs.clear();\r
228         mArrays.clear();\r
229 }\r
230 \r
231 void TransactionImpl::AttachStatementImpl(StatementImpl* st)\r
232 {\r
233         if (st == 0)\r
234                 throw LogicExceptionImpl("Transaction::AttachStatement",\r
235                                         _("Can't attach a 0 Statement object."));\r
236 \r
237         mStatements.push_back(st);\r
238 }\r
239 \r
240 void TransactionImpl::DetachStatementImpl(StatementImpl* st)\r
241 {\r
242         if (st == 0)\r
243                 throw LogicExceptionImpl("Transaction::DetachStatement",\r
244                                 _("Can't detach a 0 Statement object."));\r
245 \r
246         mStatements.erase(std::find(mStatements.begin(), mStatements.end(), st));\r
247 }\r
248 \r
249 void TransactionImpl::AttachBlobImpl(BlobImpl* bb)\r
250 {\r
251         if (bb == 0)\r
252                 throw LogicExceptionImpl("Transaction::AttachBlob",\r
253                                         _("Can't attach a 0 BlobImpl object."));\r
254 \r
255         mBlobs.push_back(bb);\r
256 }\r
257 \r
258 void TransactionImpl::DetachBlobImpl(BlobImpl* bb)\r
259 {\r
260         if (bb == 0)\r
261                 throw LogicExceptionImpl("Transaction::DetachBlob",\r
262                                 _("Can't detach a 0 BlobImpl object."));\r
263 \r
264         mBlobs.erase(std::find(mBlobs.begin(), mBlobs.end(), bb));\r
265 }\r
266 \r
267 void TransactionImpl::AttachArrayImpl(ArrayImpl* ar)\r
268 {\r
269         if (ar == 0)\r
270                 throw LogicExceptionImpl("Transaction::AttachArray",\r
271                                         _("Can't attach a 0 ArrayImpl object."));\r
272 \r
273         mArrays.push_back(ar);\r
274 }\r
275 \r
276 void TransactionImpl::DetachArrayImpl(ArrayImpl* ar)\r
277 {\r
278         if (ar == 0)\r
279                 throw LogicExceptionImpl("Transaction::DetachArray",\r
280                                 _("Can't detach a 0 ArrayImpl object."));\r
281 \r
282         mArrays.erase(std::find(mArrays.begin(), mArrays.end(), ar));\r
283 }\r
284 \r
285 void TransactionImpl::AttachDatabaseImpl(DatabaseImpl* dbi,\r
286         IBPP::TAM am, IBPP::TIL il, IBPP::TLR lr, IBPP::TFF flags)\r
287 {\r
288         if (mHandle != 0)\r
289                 throw LogicExceptionImpl("Transaction::AttachDatabase",\r
290                                 _("Can't attach a Database if Transaction started."));\r
291         if (dbi == 0)\r
292                 throw LogicExceptionImpl("Transaction::AttachDatabase",\r
293                                 _("Can't attach a null Database."));\r
294 \r
295         mDatabases.push_back(dbi);\r
296 \r
297         // Prepare a new TPB\r
298         TPB* tpb = new TPB;\r
299     if (am == IBPP::amRead) tpb->Insert(isc_tpb_read);\r
300     else tpb->Insert(isc_tpb_write);\r
301 \r
302         switch (il)\r
303         {\r
304                 case IBPP::ilConsistency :              tpb->Insert(isc_tpb_consistency); break;\r
305                 case IBPP::ilReadDirty :                tpb->Insert(isc_tpb_read_committed);\r
306                                                                 tpb->Insert(isc_tpb_rec_version); break;\r
307                 case IBPP::ilReadCommitted :    tpb->Insert(isc_tpb_read_committed);\r
308                                                                                 tpb->Insert(isc_tpb_no_rec_version); break;\r
309                 case IBPP::ilConcurrency :                                              tpb->Insert(isc_tpb_concurrency); break;\r
310         }\r
311 \r
312     if (lr == IBPP::lrNoWait) tpb->Insert(isc_tpb_nowait);\r
313     else tpb->Insert(isc_tpb_wait);\r
314 \r
315         if (flags & IBPP::tfIgnoreLimbo)        tpb->Insert(isc_tpb_ignore_limbo);\r
316         if (flags & IBPP::tfAutoCommit)         tpb->Insert(isc_tpb_autocommit);\r
317         if (flags & IBPP::tfNoAutoUndo)         tpb->Insert(isc_tpb_no_auto_undo);\r
318 \r
319         mTPBs.push_back(tpb);\r
320 \r
321         // Signals the Database object that it has been attached to the Transaction\r
322         dbi->AttachTransactionImpl(this);\r
323 }\r
324 \r
325 void TransactionImpl::DetachDatabaseImpl(DatabaseImpl* dbi)\r
326 {\r
327         if (mHandle != 0)\r
328                 throw LogicExceptionImpl("Transaction::DetachDatabase",\r
329                                 _("Can't detach a Database if Transaction started."));\r
330         if (dbi == 0)\r
331                 throw LogicExceptionImpl("Transaction::DetachDatabase",\r
332                                 _("Can't detach a null Database."));\r
333 \r
334         std::vector<DatabaseImpl*>::iterator pos =\r
335                 std::find(mDatabases.begin(), mDatabases.end(), dbi);\r
336         if (pos != mDatabases.end())\r
337         {\r
338                 size_t index = pos - mDatabases.begin();\r
339                 TPB* tpb = mTPBs[index];\r
340                 mDatabases.erase(pos);\r
341                 mTPBs.erase(mTPBs.begin()+index);\r
342                 delete tpb;\r
343         }\r
344 \r
345         // Signals the Database object that it has been detached from the Transaction\r
346         dbi->DetachTransactionImpl(this);\r
347 }\r
348 \r
349 TransactionImpl::TransactionImpl(DatabaseImpl* db,\r
350         IBPP::TAM am, IBPP::TIL il, IBPP::TLR lr, IBPP::TFF flags)\r
351         : mRefCount(0)\r
352 {\r
353         Init();\r
354         AttachDatabaseImpl(db, am, il, lr, flags);\r
355 }\r
356 \r
357 TransactionImpl::~TransactionImpl()\r
358 {\r
359         // Rollback the transaction if it was Started\r
360         try { if (Started()) Rollback(); }\r
361                 catch (...) { }\r
362 \r
363         // Let's detach cleanly all Blobs from this Transaction.\r
364         // No Blob object can still maintain pointers to this\r
365         // Transaction which is disappearing.\r
366         //\r
367         // We use a reverse traversal of the array to avoid loops.\r
368         // The array shrinks on each loop (mBbCount decreases).\r
369         // And during the deletion, there is a packing of the array through a\r
370         // copy of elements from the end to the beginning of the array.\r
371         try {\r
372                 while (mBlobs.size() > 0)\r
373                         mBlobs.back()->DetachTransactionImpl();\r
374         } catch (...) { }\r
375 \r
376         // Let's detach cleanly all Arrays from this Transaction.\r
377         // No Array object can still maintain pointers to this\r
378         // Transaction which is disappearing.\r
379         try {\r
380                 while (mArrays.size() > 0)\r
381                         mArrays.back()->DetachTransactionImpl();\r
382         } catch (...) { }\r
383 \r
384         // Let's detach cleanly all Statements from this Transaction.\r
385         // No Statement object can still maintain pointers to this\r
386         // Transaction which is disappearing.\r
387         try {\r
388                 while (mStatements.size() > 0)\r
389                         mStatements.back()->DetachTransactionImpl();\r
390         } catch (...) { }\r
391 \r
392         // Very important : let's detach cleanly all Databases from this\r
393         // Transaction. No Database object can still maintain pointers to this\r
394         // Transaction which is disappearing.\r
395         try {\r
396                 while (mDatabases.size() > 0)\r
397                 {\r
398                         size_t i = mDatabases.size()-1;\r
399                         DetachDatabaseImpl(mDatabases[i]);      // <-- remove link to database from mTPBs\r
400                                                                                         // array and destroy TPB object\r
401                                                                                         // Fixed : Maxim Abrashkin on 12 Jun 2002\r
402                         //mDatabases.back()->DetachTransaction(this);\r
403                 }\r
404         } catch (...) { }\r
405 }\r
406 \r
407 //\r
408 //      EOF\r
409 //\r