1 /* Copyright (c) 2003-2007 MySQL AB
2 Use is subject to license terms
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; version 2 of the License.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12
13 You should have received a copy of the GNU General Public License
14 along with this program; if not, write to the Free Software
15 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */
16
17
18 #define DBTUP_C
19 #define DBTUP_GEN_CPP
20 #include "Dbtup.hpp"
21 #include <RefConvert.hpp>
22 #include <ndb_limits.h>
23 #include <pc.hpp>
24 #include <AttributeDescriptor.hpp>
25 #include "AttributeOffset.hpp"
26 #include <AttributeHeader.hpp>
27 #include <Interpreter.hpp>
28 #include <signaldata/FsConf.hpp>
29 #include <signaldata/FsRef.hpp>
30 #include <signaldata/FsRemoveReq.hpp>
31 #include <signaldata/TupCommit.hpp>
32 #include <signaldata/TupKey.hpp>
33
34 #include <signaldata/DropTab.hpp>
35 #include <SLList.hpp>
36
37 #define DEBUG(x) { ndbout << "TUP::" << x << endl; }
38
initData()39 void Dbtup::initData()
40 {
41 cnoOfAttrbufrec = ZNO_OF_ATTRBUFREC;
42 cnoOfFragrec = MAX_FRAG_PER_NODE;
43 cnoOfFragoprec = MAX_FRAG_PER_NODE;
44 cnoOfPageRangeRec = ZNO_OF_PAGE_RANGE_REC;
45 c_maxTriggersPerTable = ZDEFAULT_MAX_NO_TRIGGERS_PER_TABLE;
46 c_noOfBuildIndexRec = 32;
47
48 // Records with constant sizes
49 init_list_sizes();
50 }//Dbtup::initData()
51
Dbtup(Block_context & ctx,Pgman * pgman)52 Dbtup::Dbtup(Block_context& ctx, Pgman* pgman)
53 : SimulatedBlock(DBTUP, ctx),
54 c_lqh(0),
55 m_pgman(this, pgman),
56 c_extent_hash(c_extent_pool),
57 c_storedProcPool(),
58 c_buildIndexList(c_buildIndexPool),
59 c_undo_buffer(this)
60 {
61 BLOCK_CONSTRUCTOR(Dbtup);
62
63 addRecSignal(GSN_DEBUG_SIG, &Dbtup::execDEBUG_SIG);
64 addRecSignal(GSN_CONTINUEB, &Dbtup::execCONTINUEB);
65 addRecSignal(GSN_LCP_FRAG_ORD, &Dbtup::execLCP_FRAG_ORD);
66
67 addRecSignal(GSN_DUMP_STATE_ORD, &Dbtup::execDUMP_STATE_ORD);
68 addRecSignal(GSN_SEND_PACKED, &Dbtup::execSEND_PACKED);
69 addRecSignal(GSN_ATTRINFO, &Dbtup::execATTRINFO);
70 addRecSignal(GSN_STTOR, &Dbtup::execSTTOR);
71 addRecSignal(GSN_MEMCHECKREQ, &Dbtup::execMEMCHECKREQ);
72 addRecSignal(GSN_TUPKEYREQ, &Dbtup::execTUPKEYREQ);
73 addRecSignal(GSN_TUPSEIZEREQ, &Dbtup::execTUPSEIZEREQ);
74 addRecSignal(GSN_TUPRELEASEREQ, &Dbtup::execTUPRELEASEREQ);
75 addRecSignal(GSN_STORED_PROCREQ, &Dbtup::execSTORED_PROCREQ);
76 addRecSignal(GSN_TUPFRAGREQ, &Dbtup::execTUPFRAGREQ);
77 addRecSignal(GSN_TUP_ADD_ATTRREQ, &Dbtup::execTUP_ADD_ATTRREQ);
78 addRecSignal(GSN_TUP_COMMITREQ, &Dbtup::execTUP_COMMITREQ);
79 addRecSignal(GSN_TUP_ABORTREQ, &Dbtup::execTUP_ABORTREQ);
80 addRecSignal(GSN_NDB_STTOR, &Dbtup::execNDB_STTOR);
81 addRecSignal(GSN_READ_CONFIG_REQ, &Dbtup::execREAD_CONFIG_REQ, true);
82
83 // Trigger Signals
84 addRecSignal(GSN_CREATE_TRIG_REQ, &Dbtup::execCREATE_TRIG_REQ);
85 addRecSignal(GSN_DROP_TRIG_REQ, &Dbtup::execDROP_TRIG_REQ);
86
87 addRecSignal(GSN_DROP_TAB_REQ, &Dbtup::execDROP_TAB_REQ);
88
89 addRecSignal(GSN_TUP_DEALLOCREQ, &Dbtup::execTUP_DEALLOCREQ);
90 addRecSignal(GSN_TUP_WRITELOG_REQ, &Dbtup::execTUP_WRITELOG_REQ);
91
92 // Ordered index related
93 addRecSignal(GSN_BUILDINDXREQ, &Dbtup::execBUILDINDXREQ);
94
95 // Tup scan
96 addRecSignal(GSN_ACC_SCANREQ, &Dbtup::execACC_SCANREQ);
97 addRecSignal(GSN_NEXT_SCANREQ, &Dbtup::execNEXT_SCANREQ);
98 addRecSignal(GSN_ACC_CHECK_SCAN, &Dbtup::execACC_CHECK_SCAN);
99 addRecSignal(GSN_ACCKEYCONF, &Dbtup::execACCKEYCONF);
100 addRecSignal(GSN_ACCKEYREF, &Dbtup::execACCKEYREF);
101 addRecSignal(GSN_ACC_ABORTCONF, &Dbtup::execACC_ABORTCONF);
102
103 // Drop table
104 addRecSignal(GSN_FSREMOVEREF, &Dbtup::execFSREMOVEREF, true);
105 addRecSignal(GSN_FSREMOVECONF, &Dbtup::execFSREMOVECONF, true);
106
107 attrbufrec = 0;
108 fragoperrec = 0;
109 fragrecord = 0;
110 hostBuffer = 0;
111 pageRange = 0;
112 tablerec = 0;
113 tableDescriptor = 0;
114 totNoOfPagesAllocated = 0;
115 cnoOfAllocatedPages = 0;
116
117 initData();
118 CLEAR_ERROR_INSERT_VALUE;
119 }//Dbtup::Dbtup()
120
~Dbtup()121 Dbtup::~Dbtup()
122 {
123 // Records with dynamic sizes
124 deallocRecord((void **)&attrbufrec,"Attrbufrec",
125 sizeof(Attrbufrec),
126 cnoOfAttrbufrec);
127
128 deallocRecord((void **)&fragoperrec,"Fragoperrec",
129 sizeof(Fragoperrec),
130 cnoOfFragoprec);
131
132 deallocRecord((void **)&fragrecord,"Fragrecord",
133 sizeof(Fragrecord),
134 cnoOfFragrec);
135
136 deallocRecord((void **)&hostBuffer,"HostBuffer",
137 sizeof(HostBuffer),
138 MAX_NODES);
139
140 deallocRecord((void **)&pageRange,"PageRange",
141 sizeof(PageRange),
142 cnoOfPageRangeRec);
143
144 deallocRecord((void **)&tablerec,"Tablerec",
145 sizeof(Tablerec),
146 cnoOfTablerec);
147
148 deallocRecord((void **)&tableDescriptor, "TableDescriptor",
149 sizeof(TableDescriptor),
150 cnoOfTabDescrRec);
151
152 }//Dbtup::~Dbtup()
153
BLOCK_FUNCTIONS(Dbtup)154 BLOCK_FUNCTIONS(Dbtup)
155
156 void Dbtup::execCONTINUEB(Signal* signal)
157 {
158 jamEntry();
159 Uint32 actionType = signal->theData[0];
160 Uint32 dataPtr = signal->theData[1];
161 switch (actionType) {
162 case ZINITIALISE_RECORDS:
163 jam();
164 initialiseRecordsLab(signal, dataPtr,
165 signal->theData[2], signal->theData[3]);
166 break;
167 case ZREL_FRAG:
168 jam();
169 releaseFragment(signal, dataPtr, signal->theData[2]);
170 break;
171 case ZREPORT_MEMORY_USAGE:{
172 jam();
173 static int c_currentMemUsed = 0;
174 Uint32 cnt = signal->theData[1];
175 Uint32 tmp = c_page_pool.getSize();
176 int now = tmp ? (cnoOfAllocatedPages * 100)/tmp : 0;
177 const int thresholds[] = { 100, 90, 80, 0 };
178
179 Uint32 i = 0;
180 const Uint32 sz = sizeof(thresholds)/sizeof(thresholds[0]);
181 for(i = 0; i<sz; i++){
182 if(now >= thresholds[i]){
183 now = thresholds[i];
184 break;
185 }
186 }
187
188 if(now != c_currentMemUsed ||
189 (c_memusage_report_frequency && cnt + 1 == c_memusage_report_frequency))
190 {
191 reportMemoryUsage(signal,
192 now > c_currentMemUsed ? 1 :
193 now < c_currentMemUsed ? -1 : 0);
194 cnt = 0;
195 c_currentMemUsed = now;
196 }
197 else
198 {
199 cnt++;
200 }
201 signal->theData[0] = ZREPORT_MEMORY_USAGE;
202 signal->theData[1] = cnt;
203 sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1000, 2);
204 return;
205 }
206 case ZBUILD_INDEX:
207 jam();
208 buildIndex(signal, dataPtr);
209 break;
210 case ZTUP_SCAN:
211 jam();
212 {
213 ScanOpPtr scanPtr;
214 c_scanOpPool.getPtr(scanPtr, dataPtr);
215 scanCont(signal, scanPtr);
216 }
217 return;
218 case ZFREE_EXTENT:
219 {
220 jam();
221
222 TablerecPtr tabPtr;
223 tabPtr.i= dataPtr;
224 FragrecordPtr fragPtr;
225 fragPtr.i= signal->theData[2];
226 ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
227 ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
228 drop_fragment_free_extent(signal, tabPtr, fragPtr, signal->theData[3]);
229 return;
230 }
231 case ZUNMAP_PAGES:
232 {
233 jam();
234
235 TablerecPtr tabPtr;
236 tabPtr.i= dataPtr;
237 FragrecordPtr fragPtr;
238 fragPtr.i= signal->theData[2];
239 ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
240 ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
241 drop_fragment_unmap_pages(signal, tabPtr, fragPtr, signal->theData[3]);
242 return;
243 }
244 case ZFREE_VAR_PAGES:
245 {
246 jam();
247 drop_fragment_free_var_pages(signal);
248 return;
249 }
250 default:
251 ndbrequire(false);
252 break;
253 }//switch
254 }//Dbtup::execTUP_CONTINUEB()
255
256 /* **************************************************************** */
257 /* ---------------------------------------------------------------- */
258 /* ------------------- SYSTEM RESTART MODULE ---------------------- */
259 /* ---------------------------------------------------------------- */
260 /* **************************************************************** */
execSTTOR(Signal * signal)261 void Dbtup::execSTTOR(Signal* signal)
262 {
263 jamEntry();
264 Uint32 startPhase = signal->theData[1];
265 Uint32 sigKey = signal->theData[6];
266 switch (startPhase) {
267 case ZSTARTPHASE1:
268 jam();
269 ndbrequire((c_lqh= (Dblqh*)globalData.getBlock(DBLQH)) != 0);
270 ndbrequire((c_tsman= (Tsman*)globalData.getBlock(TSMAN)) != 0);
271 ndbrequire((c_lgman= (Lgman*)globalData.getBlock(LGMAN)) != 0);
272 cownref = calcTupBlockRef(0);
273 break;
274 default:
275 jam();
276 break;
277 }//switch
278 signal->theData[0] = sigKey;
279 signal->theData[1] = 3;
280 signal->theData[2] = 2;
281 signal->theData[3] = ZSTARTPHASE1;
282 signal->theData[4] = 255;
283 sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 5, JBB);
284 return;
285 }//Dbtup::execSTTOR()
286
287 /************************************************************************************************/
288 // SIZE_ALTREP INITIALIZE DATA STRUCTURES, FILES AND DS VARIABLES, GET READY FOR EXTERNAL
289 // CONNECTIONS.
290 /************************************************************************************************/
execREAD_CONFIG_REQ(Signal * signal)291 void Dbtup::execREAD_CONFIG_REQ(Signal* signal)
292 {
293 const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr();
294 Uint32 ref = req->senderRef;
295 Uint32 senderData = req->senderData;
296 ndbrequire(req->noOfParameters == 0);
297
298 jamEntry();
299
300 const ndb_mgm_configuration_iterator * p =
301 m_ctx.m_config.getOwnConfigIterator();
302 ndbrequire(p != 0);
303
304 ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_FRAG, &cnoOfFragrec));
305
306 Uint32 noOfTriggers= 0;
307
308 Uint32 tmp= 0;
309
310 if (ndb_mgm_get_int_parameter(p, CFG_DB_MAX_ALLOCATE, &tmp))
311 tmp = 32 * 1024 * 1024;
312 m_max_allocate_pages = (tmp + GLOBAL_PAGE_SIZE - 1) / GLOBAL_PAGE_SIZE;
313
314 tmp = 0;
315 ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_PAGE_RANGE, &tmp));
316 initPageRangeSize(tmp);
317 ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_TABLE, &cnoOfTablerec));
318 ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_TABLE_DESC,
319 &cnoOfTabDescrRec));
320 Uint32 noOfStoredProc;
321 ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_STORED_PROC,
322 &noOfStoredProc));
323 ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_NO_TRIGGERS,
324 &noOfTriggers));
325
326 cnoOfTabDescrRec = (cnoOfTabDescrRec & 0xFFFFFFF0) + 16;
327
328 initRecords();
329
330 c_storedProcPool.setSize(noOfStoredProc);
331 c_buildIndexPool.setSize(c_noOfBuildIndexRec);
332 c_triggerPool.setSize(noOfTriggers, false, true, true, CFG_DB_NO_TRIGGERS);
333
334 c_extent_hash.setSize(1024); // 4k
335
336 Pool_context pc;
337 pc.m_block = this;
338 c_page_request_pool.wo_pool_init(RT_DBTUP_PAGE_REQUEST, pc);
339 c_extent_pool.init(RT_DBTUP_EXTENT_INFO, pc);
340
341 Uint32 nScanOp; // use TUX config for now
342 ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUX_SCAN_OP, &nScanOp));
343 c_scanOpPool.setSize(nScanOp + 1);
344 Uint32 nScanBatch;
345 ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_BATCH_SIZE, &nScanBatch));
346 c_scanLockPool.setSize(nScanOp * nScanBatch);
347
348
349 /* read ahead for disk scan can not be more that disk page buffer */
350 {
351 Uint64 tmp = 64*1024*1024;
352 ndb_mgm_get_int64_parameter(p, CFG_DB_DISK_PAGE_BUFFER_MEMORY, &tmp);
353 m_max_page_read_ahead = (tmp + GLOBAL_PAGE_SIZE - 1) / GLOBAL_PAGE_SIZE; // in pages
354 // never read ahead more than 32 pages
355 if (m_max_page_read_ahead > 32)
356 m_max_page_read_ahead = 32;
357 }
358
359
360 ScanOpPtr lcp;
361 ndbrequire(c_scanOpPool.seize(lcp));
362 new (lcp.p) ScanOp();
363 c_lcp_scan_op= lcp.i;
364
365 czero = 0;
366 cminusOne = czero - 1;
367 clastBitMask = 1;
368 clastBitMask = clastBitMask << 31;
369
370 c_memusage_report_frequency = 0;
371 ndb_mgm_get_int_parameter(p, CFG_DB_MEMREPORT_FREQUENCY,
372 &c_memusage_report_frequency);
373
374 initialiseRecordsLab(signal, 0, ref, senderData);
375 }//Dbtup::execSIZEALT_REP()
376
initRecords()377 void Dbtup::initRecords()
378 {
379 unsigned i;
380 Uint32 tmp;
381 Uint32 tmp1 = 0;
382 const ndb_mgm_configuration_iterator * p =
383 m_ctx.m_config.getOwnConfigIterator();
384 ndbrequire(p != 0);
385
386 ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_PAGE, &tmp));
387
388 // Records with dynamic sizes
389 Page* ptr =(Page*)allocRecord("Page", sizeof(Page), tmp, false, CFG_DB_DATA_MEM);
390 c_page_pool.set(ptr, tmp);
391
392 attrbufrec = (Attrbufrec*)allocRecord("Attrbufrec",
393 sizeof(Attrbufrec),
394 cnoOfAttrbufrec);
395
396 fragoperrec = (Fragoperrec*)allocRecord("Fragoperrec",
397 sizeof(Fragoperrec),
398 cnoOfFragoprec);
399
400 fragrecord = (Fragrecord*)allocRecord("Fragrecord",
401 sizeof(Fragrecord),
402 cnoOfFragrec);
403
404 hostBuffer = (HostBuffer*)allocRecord("HostBuffer",
405 sizeof(HostBuffer),
406 MAX_NODES);
407
408 tableDescriptor = (TableDescriptor*)allocRecord("TableDescriptor",
409 sizeof(TableDescriptor),
410 cnoOfTabDescrRec);
411
412 ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_OP_RECS, &tmp));
413 ndb_mgm_get_int_parameter(p, CFG_DB_NO_LOCAL_OPS, &tmp1);
414 c_operation_pool.setSize(tmp, false, true, true,
415 tmp1 == 0 ? CFG_DB_NO_OPS : CFG_DB_NO_LOCAL_OPS);
416
417 pageRange = (PageRange*)allocRecord("PageRange",
418 sizeof(PageRange),
419 cnoOfPageRangeRec);
420
421 tablerec = (Tablerec*)allocRecord("Tablerec",
422 sizeof(Tablerec),
423 cnoOfTablerec);
424
425 for (i = 0; i<cnoOfTablerec; i++) {
426 void * p = &tablerec[i];
427 new (p) Tablerec(c_triggerPool);
428 }
429 }//Dbtup::initRecords()
430
initialiseRecordsLab(Signal * signal,Uint32 switchData,Uint32 retRef,Uint32 retData)431 void Dbtup::initialiseRecordsLab(Signal* signal, Uint32 switchData,
432 Uint32 retRef, Uint32 retData)
433 {
434 switch (switchData) {
435 case 0:
436 jam();
437 initializeHostBuffer();
438 break;
439 case 1:
440 jam();
441 initializeOperationrec();
442 break;
443 case 2:
444 jam();
445 initializePage();
446 break;
447 case 3:
448 jam();
449 break;
450 case 4:
451 jam();
452 initializeTablerec();
453 break;
454 case 5:
455 jam();
456 break;
457 case 6:
458 jam();
459 initializeFragrecord();
460 break;
461 case 7:
462 jam();
463 initializeFragoperrec();
464 break;
465 case 8:
466 jam();
467 initializePageRange();
468 break;
469 case 9:
470 jam();
471 initializeTabDescr();
472 break;
473 case 10:
474 jam();
475 break;
476 case 11:
477 jam();
478 break;
479 case 12:
480 jam();
481 initializeAttrbufrec();
482 break;
483 case 13:
484 jam();
485 break;
486 case 14:
487 jam();
488
489 {
490 ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
491 conf->senderRef = reference();
492 conf->senderData = retData;
493 sendSignal(retRef, GSN_READ_CONFIG_CONF, signal,
494 ReadConfigConf::SignalLength, JBB);
495 }
496 return;
497 default:
498 ndbrequire(false);
499 break;
500 }//switch
501 signal->theData[0] = ZINITIALISE_RECORDS;
502 signal->theData[1] = switchData + 1;
503 signal->theData[2] = retRef;
504 signal->theData[3] = retData;
505 sendSignal(reference(), GSN_CONTINUEB, signal, 4, JBB);
506 return;
507 }//Dbtup::initialiseRecordsLab()
508
execNDB_STTOR(Signal * signal)509 void Dbtup::execNDB_STTOR(Signal* signal)
510 {
511 jamEntry();
512 cndbcntrRef = signal->theData[0];
513 Uint32 ownNodeId = signal->theData[1];
514 Uint32 startPhase = signal->theData[2];
515 switch (startPhase) {
516 case ZSTARTPHASE1:
517 jam();
518 cownNodeId = ownNodeId;
519 cownref = calcTupBlockRef(ownNodeId);
520 break;
521 case ZSTARTPHASE2:
522 jam();
523 break;
524 case ZSTARTPHASE3:
525 jam();
526 startphase3Lab(signal, ~0, ~0);
527 break;
528 case ZSTARTPHASE4:
529 jam();
530 break;
531 case ZSTARTPHASE6:
532 jam();
533 /*****************************************/
534 /* NOW SET THE DISK WRITE SPEED TO */
535 /* PAGES PER TICK AFTER SYSTEM */
536 /* RESTART. */
537 /*****************************************/
538 signal->theData[0] = ZREPORT_MEMORY_USAGE;
539 signal->theData[1] = 0;
540 sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1000, 2);
541 break;
542 default:
543 jam();
544 break;
545 }//switch
546 signal->theData[0] = cownref;
547 sendSignal(cndbcntrRef, GSN_NDB_STTORRY, signal, 1, JBB);
548 }//Dbtup::execNDB_STTOR()
549
startphase3Lab(Signal * signal,Uint32 config1,Uint32 config2)550 void Dbtup::startphase3Lab(Signal* signal, Uint32 config1, Uint32 config2)
551 {
552 }//Dbtup::startphase3Lab()
553
initializeAttrbufrec()554 void Dbtup::initializeAttrbufrec()
555 {
556 AttrbufrecPtr attrBufPtr;
557 for (attrBufPtr.i = 0;
558 attrBufPtr.i < cnoOfAttrbufrec; attrBufPtr.i++) {
559 refresh_watch_dog();
560 ptrAss(attrBufPtr, attrbufrec);
561 attrBufPtr.p->attrbuf[ZBUF_NEXT] = attrBufPtr.i + 1;
562 }//for
563 attrBufPtr.i = cnoOfAttrbufrec - 1;
564 ptrAss(attrBufPtr, attrbufrec);
565 attrBufPtr.p->attrbuf[ZBUF_NEXT] = RNIL;
566 cfirstfreeAttrbufrec = 0;
567 cnoFreeAttrbufrec = cnoOfAttrbufrec;
568 }//Dbtup::initializeAttrbufrec()
569
initializeFragoperrec()570 void Dbtup::initializeFragoperrec()
571 {
572 FragoperrecPtr fragoperPtr;
573 for (fragoperPtr.i = 0; fragoperPtr.i < cnoOfFragoprec; fragoperPtr.i++) {
574 ptrAss(fragoperPtr, fragoperrec);
575 fragoperPtr.p->nextFragoprec = fragoperPtr.i + 1;
576 }//for
577 fragoperPtr.i = cnoOfFragoprec - 1;
578 ptrAss(fragoperPtr, fragoperrec);
579 fragoperPtr.p->nextFragoprec = RNIL;
580 cfirstfreeFragopr = 0;
581 }//Dbtup::initializeFragoperrec()
582
initializeFragrecord()583 void Dbtup::initializeFragrecord()
584 {
585 FragrecordPtr regFragPtr;
586 for (regFragPtr.i = 0; regFragPtr.i < cnoOfFragrec; regFragPtr.i++) {
587 refresh_watch_dog();
588 ptrAss(regFragPtr, fragrecord);
589 new (regFragPtr.p) Fragrecord();
590 regFragPtr.p->nextfreefrag = regFragPtr.i + 1;
591 regFragPtr.p->fragStatus = IDLE;
592 }//for
593 regFragPtr.i = cnoOfFragrec - 1;
594 ptrAss(regFragPtr, fragrecord);
595 regFragPtr.p->nextfreefrag = RNIL;
596 cfirstfreefrag = 0;
597 }//Dbtup::initializeFragrecord()
598
initializeHostBuffer()599 void Dbtup::initializeHostBuffer()
600 {
601 Uint32 hostId;
602 cpackedListIndex = 0;
603 for (hostId = 0; hostId < MAX_NODES; hostId++) {
604 hostBuffer[hostId].inPackedList = false;
605 hostBuffer[hostId].noOfPacketsTA = 0;
606 hostBuffer[hostId].packetLenTA = 0;
607 }//for
608 }//Dbtup::initializeHostBuffer()
609
610
initializeOperationrec()611 void Dbtup::initializeOperationrec()
612 {
613 refresh_watch_dog();
614 }//Dbtup::initializeOperationrec()
615
initializeTablerec()616 void Dbtup::initializeTablerec()
617 {
618 TablerecPtr regTabPtr;
619 for (regTabPtr.i = 0; regTabPtr.i < cnoOfTablerec; regTabPtr.i++) {
620 jam();
621 refresh_watch_dog();
622 ptrAss(regTabPtr, tablerec);
623 initTab(regTabPtr.p);
624 }//for
625 }//Dbtup::initializeTablerec()
626
627 void
initTab(Tablerec * const regTabPtr)628 Dbtup::initTab(Tablerec* const regTabPtr)
629 {
630 for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
631 regTabPtr->fragid[i] = RNIL;
632 regTabPtr->fragrec[i] = RNIL;
633 }//for
634 regTabPtr->readFunctionArray = NULL;
635 regTabPtr->updateFunctionArray = NULL;
636 regTabPtr->charsetArray = NULL;
637
638 regTabPtr->tabDescriptor = RNIL;
639 regTabPtr->readKeyArray = RNIL;
640
641 regTabPtr->m_bits = 0;
642
643 regTabPtr->m_no_of_attributes = 0;
644 regTabPtr->noOfKeyAttr = 0;
645
646 regTabPtr->m_dropTable.tabUserPtr = RNIL;
647 regTabPtr->m_dropTable.tabUserRef = 0;
648 regTabPtr->tableStatus = NOT_DEFINED;
649
650 // Clear trigger data
651 if (!regTabPtr->afterInsertTriggers.isEmpty())
652 regTabPtr->afterInsertTriggers.release();
653 if (!regTabPtr->afterDeleteTriggers.isEmpty())
654 regTabPtr->afterDeleteTriggers.release();
655 if (!regTabPtr->afterUpdateTriggers.isEmpty())
656 regTabPtr->afterUpdateTriggers.release();
657 if (!regTabPtr->subscriptionInsertTriggers.isEmpty())
658 regTabPtr->subscriptionInsertTriggers.release();
659 if (!regTabPtr->subscriptionDeleteTriggers.isEmpty())
660 regTabPtr->subscriptionDeleteTriggers.release();
661 if (!regTabPtr->subscriptionUpdateTriggers.isEmpty())
662 regTabPtr->subscriptionUpdateTriggers.release();
663 if (!regTabPtr->constraintUpdateTriggers.isEmpty())
664 regTabPtr->constraintUpdateTriggers.release();
665 if (!regTabPtr->tuxCustomTriggers.isEmpty())
666 regTabPtr->tuxCustomTriggers.release();
667 }//Dbtup::initTab()
668
initializeTabDescr()669 void Dbtup::initializeTabDescr()
670 {
671 TableDescriptorPtr regTabDesPtr;
672 for (Uint32 i = 0; i < 16; i++) {
673 cfreeTdList[i] = RNIL;
674 }//for
675 for (regTabDesPtr.i = 0; regTabDesPtr.i < cnoOfTabDescrRec; regTabDesPtr.i++) {
676 refresh_watch_dog();
677 ptrAss(regTabDesPtr, tableDescriptor);
678 regTabDesPtr.p->tabDescr = RNIL;
679 }//for
680 freeTabDescr(0, cnoOfTabDescrRec);
681 }//Dbtup::initializeTabDescr()
682
683 /* ---------------------------------------------------------------- */
684 /* ---------------------------------------------------------------- */
685 /* --------------- CONNECT/DISCONNECT MODULE ---------------------- */
686 /* ---------------------------------------------------------------- */
687 /* ---------------------------------------------------------------- */
execTUPSEIZEREQ(Signal * signal)688 void Dbtup::execTUPSEIZEREQ(Signal* signal)
689 {
690 OperationrecPtr regOperPtr;
691 jamEntry();
692 Uint32 userPtr = signal->theData[0];
693 BlockReference userRef = signal->theData[1];
694 if (!c_operation_pool.seize(regOperPtr))
695 {
696 jam();
697 signal->theData[0] = userPtr;
698 signal->theData[1] = ZGET_OPREC_ERROR;
699 sendSignal(userRef, GSN_TUPSEIZEREF, signal, 2, JBB);
700 return;
701 }//if
702
703 new (regOperPtr.p) Operationrec();
704 regOperPtr.p->firstAttrinbufrec = RNIL;
705 regOperPtr.p->lastAttrinbufrec = RNIL;
706 regOperPtr.p->m_any_value = 0;
707 regOperPtr.p->op_struct.op_type = ZREAD;
708 regOperPtr.p->op_struct.in_active_list = false;
709 set_trans_state(regOperPtr.p, TRANS_DISCONNECTED);
710 regOperPtr.p->storedProcedureId = ZNIL;
711 regOperPtr.p->prevActiveOp = RNIL;
712 regOperPtr.p->nextActiveOp = RNIL;
713 regOperPtr.p->tupVersion = ZNIL;
714 regOperPtr.p->op_struct.delete_insert_flag = false;
715
716 initOpConnection(regOperPtr.p);
717 regOperPtr.p->userpointer = userPtr;
718 signal->theData[0] = regOperPtr.p->userpointer;
719 signal->theData[1] = regOperPtr.i;
720 sendSignal(userRef, GSN_TUPSEIZECONF, signal, 2, JBB);
721 return;
722 }//Dbtup::execTUPSEIZEREQ()
723
724 #define printFragment(t){ for(Uint32 i = 0; i < MAX_FRAG_PER_NODE;i++){\
725 ndbout_c("table = %d fragid[%d] = %d fragrec[%d] = %d", \
726 t.i, t.p->fragid[i], i, t.p->fragrec[i]); }}
727
execTUPRELEASEREQ(Signal * signal)728 void Dbtup::execTUPRELEASEREQ(Signal* signal)
729 {
730 OperationrecPtr regOperPtr;
731 jamEntry();
732 regOperPtr.i = signal->theData[0];
733 c_operation_pool.getPtr(regOperPtr);
734 set_trans_state(regOperPtr.p, TRANS_DISCONNECTED);
735 c_operation_pool.release(regOperPtr);
736
737 signal->theData[0] = regOperPtr.p->userpointer;
738 sendSignal(DBLQH_REF, GSN_TUPRELEASECONF, signal, 1, JBB);
739 return;
740 }//Dbtup::execTUPRELEASEREQ()
741
releaseFragrec(FragrecordPtr regFragPtr)742 void Dbtup::releaseFragrec(FragrecordPtr regFragPtr)
743 {
744 regFragPtr.p->nextfreefrag = cfirstfreefrag;
745 cfirstfreefrag = regFragPtr.i;
746 }//Dbtup::releaseFragrec()
747
748
749
750