← Back to branch summary

~mdcallag/+junk/5.1-map

« back to all changes in this revision

Viewing changes to storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp

  • Committer: msvensson at pilot
  • Date: 2007-04-24 09:11:45 UTC
  • mfrom: (2469.1.106)
  • Revision ID: sp1r-msvensson@pilot.blaudden-20070424091145-10463
Merge pilot.blaudden:/home/msvensson/mysql/my51-m-mysql_upgrade
into  pilot.blaudden:/home/msvensson/mysql/mysql-5.1-maint

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
#define DBTUP_C
 
17
#define DBTUP_INDEX_CPP
17
18
#include "Dbtup.hpp"
18
19
#include <RefConvert.hpp>
19
20
#include <ndb_limits.h>
23
24
#include <AttributeHeader.hpp>
24
25
#include <signaldata/TuxMaint.hpp>
25
26
 
26
 
#define ljam() { jamLine(28000 + __LINE__); }
27
 
#define ljamEntry() { jamEntryLine(28000 + __LINE__); }
28
 
 
29
27
// methods used by ordered index
30
28
 
31
29
void
34
32
                     Uint32 pageIndex,
35
33
                     Uint32& tupAddr)
36
34
{
37
 
  ljamEntry();
 
35
  jamEntry();
38
36
  PagePtr pagePtr;
39
37
  c_page_pool.getPtr(pagePtr, pageId);
40
38
  Uint32 fragPageId= pagePtr.p->frag_page_id;
48
46
                    Uint32& pageOffset,
49
47
                    Uint32*& node)
50
48
{
51
 
  ljamEntry();
 
49
  jamEntry();
52
50
  FragrecordPtr fragPtr;
53
51
  fragPtr.i= fragPtrI;
54
52
  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
61
59
  Uint32* ptr, frag_page_id;
62
60
  if ((ptr= alloc_fix_rec(fragPtr.p, tablePtr.p, &key, &frag_page_id)) == 0)
63
61
  {
64
 
    ljam();
 
62
    jam();
65
63
    terrorCode = ZMEM_NOMEM_ERROR; // caller sets error
66
64
    return terrorCode;
67
65
  }
82
80
                   Uint32 pageOffset,
83
81
                   Uint32* node)
84
82
{
85
 
  ljamEntry();
 
83
  jamEntry();
86
84
  FragrecordPtr fragPtr;
87
85
  fragPtr.i= fragPtrI;
88
86
  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
105
103
                  Uint32 pageOffset,
106
104
                  Uint32*& node)
107
105
{
108
 
  ljamEntry();
 
106
  jamEntry();
109
107
  FragrecordPtr fragPtr;
110
108
  fragPtr.i= fragPtrI;
111
109
  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
130
128
                    Uint32 numAttrs,
131
129
                    Uint32* dataOut)
132
130
{
133
 
  ljamEntry();
 
131
  jamEntry();
134
132
  // use own variables instead of globals
135
133
  FragrecordPtr fragPtr;
136
134
  fragPtr.i= fragPtrI;
150
148
  Tuple_header *tuple_ptr= req_struct.m_tuple_ptr;
151
149
  if (tuple_ptr->get_tuple_version() != tupVersion)
152
150
  {
153
 
    ljam();
 
151
    jam();
154
152
    OperationrecPtr opPtr;
155
153
    opPtr.i= tuple_ptr->m_operation_ptr_i;
156
154
    Uint32 loopGuard= 0;
157
155
    while (opPtr.i != RNIL) {
158
156
      c_operation_pool.getPtr(opPtr);
159
157
      if (opPtr.p->tupVersion == tupVersion) {
160
 
        ljam();
 
158
        jam();
161
159
        if (!opPtr.p->m_copy_tuple_location.isNull()) {
162
160
          req_struct.m_tuple_ptr= (Tuple_header*)
163
161
            c_undo_buffer.get_ptr(&opPtr.p->m_copy_tuple_location);
164
162
        }
165
163
        break;
166
164
      }
167
 
      ljam();
 
165
      jam();
168
166
      opPtr.i= opPtr.p->prevActiveOp;
169
167
      ndbrequire(++loopGuard < (1 << ZTUP_VERSION_BITS));
170
168
    }
202
200
int
203
201
Dbtup::tuxReadPk(Uint32 fragPtrI, Uint32 pageId, Uint32 pageIndex, Uint32* dataOut, bool xfrmFlag)
204
202
{
205
 
  ljamEntry();
 
203
  jamEntry();
206
204
  // use own variables instead of globals
207
205
  FragrecordPtr fragPtr;
208
206
  fragPtr.i= fragPtrI;
305
303
int
306
304
Dbtup::accReadPk(Uint32 tableId, Uint32 fragId, Uint32 fragPageId, Uint32 pageIndex, Uint32* dataOut, bool xfrmFlag)
307
305
{
308
 
  ljamEntry();
 
306
  jamEntry();
309
307
  // get table
310
308
  TablerecPtr tablePtr;
311
309
  tablePtr.i = tableId;
329
327
                  Uint32 transId2,
330
328
                  Uint32 savePointId)
331
329
{
332
 
  ljamEntry();
 
330
  jamEntry();
333
331
  FragrecordPtr fragPtr;
334
332
  fragPtr.i= fragPtrI;
335
333
  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
358
356
     * for this transaction and savepoint id.  If its tuple version
359
357
     * equals the requested then we have a visible tuple otherwise not.
360
358
     */
361
 
    ljam();
 
359
    jam();
362
360
    if (req_struct.m_tuple_ptr->get_tuple_version() == tupVersion) {
363
 
      ljam();
 
361
      jam();
364
362
      return true;
365
363
    }
366
364
  }
378
376
void
379
377
Dbtup::execBUILDINDXREQ(Signal* signal)
380
378
{
381
 
  ljamEntry();
 
379
  jamEntry();
382
380
#ifdef TIME_MEASUREMENT
383
381
  time_events= 0;
384
382
  tot_time_passed= 0;
387
385
  // get new operation
388
386
  BuildIndexPtr buildPtr;
389
387
  if (! c_buildIndexList.seize(buildPtr)) {
390
 
    ljam();
 
388
    jam();
391
389
    BuildIndexRec buildRec;
392
390
    memcpy(buildRec.m_request, signal->theData, sizeof(buildRec.m_request));
393
391
    buildRec.m_errorCode= BuildIndxRef::Busy;
402
400
  do {
403
401
    const BuildIndxReq* buildReq= (const BuildIndxReq*)buildPtr.p->m_request;
404
402
    if (buildReq->getTableId() >= cnoOfTablerec) {
405
 
      ljam();
 
403
      jam();
406
404
      buildPtr.p->m_errorCode= BuildIndxRef::InvalidPrimaryTable;
407
405
      break;
408
406
    }
410
408
    tablePtr.i= buildReq->getTableId();
411
409
    ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
412
410
    if (tablePtr.p->tableStatus != DEFINED) {
413
 
      ljam();
 
411
      jam();
414
412
      buildPtr.p->m_errorCode= BuildIndxRef::InvalidPrimaryTable;
415
413
      break;
416
414
    }
418
416
    buildPtr.p->m_build_vs =
419
417
      tablePtr.p->m_attributes[MM].m_no_of_varsize > 0;
420
418
    if (DictTabInfo::isOrderedIndex(buildReq->getIndexType())) {
421
 
      ljam();
 
419
      jam();
422
420
      const DLList<TupTriggerData>& triggerList = 
423
421
        tablePtr.p->tuxCustomTriggers;
424
422
 
426
424
      triggerList.first(triggerPtr);
427
425
      while (triggerPtr.i != RNIL) {
428
426
        if (triggerPtr.p->indexId == buildReq->getIndexId()) {
429
 
          ljam();
 
427
          jam();
430
428
          break;
431
429
        }
432
430
        triggerList.next(triggerPtr);
433
431
      }
434
432
      if (triggerPtr.i == RNIL) {
435
 
        ljam();
 
433
        jam();
436
434
        // trigger was not created
437
435
        buildPtr.p->m_errorCode = BuildIndxRef::InternalError;
438
436
        break;
440
438
      buildPtr.p->m_indexId = buildReq->getIndexId();
441
439
      buildPtr.p->m_buildRef = DBTUX;
442
440
    } else if(buildReq->getIndexId() == RNIL) {
443
 
      ljam();
 
441
      jam();
444
442
      // REBUILD of acc
445
443
      buildPtr.p->m_indexId = RNIL;
446
444
      buildPtr.p->m_buildRef = DBACC;
447
445
    } else {
448
 
      ljam();
 
446
      jam();
449
447
      buildPtr.p->m_errorCode = BuildIndxRef::InvalidIndexType;
450
448
      break;
451
449
    }
479
477
 
480
478
  const Uint32 firstTupleNo = 0;
481
479
  const Uint32 tupheadsize = tablePtr.p->m_offsets[MM].m_fix_header_size +
482
 
    (buildPtr.p->m_build_vs ? Tuple_header::HeaderSize + 1: 0);
 
480
    (buildPtr.p->m_build_vs? Tuple_header::HeaderSize + Var_part_ref::SZ32: 0);
483
481
 
484
482
#ifdef TIME_MEASUREMENT
485
483
  MicroSecondTimer start;
490
488
    // get fragment
491
489
    FragrecordPtr fragPtr;
492
490
    if (buildPtr.p->m_fragNo == MAX_FRAG_PER_NODE) {
493
 
      ljam();
 
491
      jam();
494
492
      // build ready
495
493
      buildIndexReply(signal, buildPtr.p);
496
494
      c_buildIndexList.release(buildPtr);
499
497
    ndbrequire(buildPtr.p->m_fragNo < MAX_FRAG_PER_NODE);
500
498
    fragPtr.i= tablePtr.p->fragrec[buildPtr.p->m_fragNo];
501
499
    if (fragPtr.i == RNIL) {
502
 
      ljam();
 
500
      jam();
503
501
      buildPtr.p->m_fragNo++;
504
502
      buildPtr.p->m_pageId= 0;
505
503
      buildPtr.p->m_tupleNo= firstTupleNo;
509
507
    // get page
510
508
    PagePtr pagePtr;
511
509
    if (buildPtr.p->m_pageId >= fragPtr.p->noOfPages) {
512
 
      ljam();
 
510
      jam();
513
511
      buildPtr.p->m_fragNo++;
514
512
      buildPtr.p->m_pageId= 0;
515
513
      buildPtr.p->m_tupleNo= firstTupleNo;
520
518
    Uint32 pageState= pagePtr.p->page_state;
521
519
    // skip empty page
522
520
    if (pageState == ZEMPTY_MM) {
523
 
      ljam();
 
521
      jam();
524
522
      buildPtr.p->m_pageId++;
525
523
      buildPtr.p->m_tupleNo= firstTupleNo;
526
524
      break;
530
528
    const Tuple_header* tuple_ptr = 0;
531
529
    pageIndex = buildPtr.p->m_tupleNo * tupheadsize;
532
530
    if (pageIndex + tupheadsize > Fix_page::DATA_WORDS) {
533
 
      ljam();
 
531
      jam();
534
532
      buildPtr.p->m_pageId++;
535
533
      buildPtr.p->m_tupleNo= firstTupleNo;
536
534
      break;
538
536
    tuple_ptr = (Tuple_header*)&pagePtr.p->m_data[pageIndex];
539
537
    // skip over free tuple
540
538
    if (tuple_ptr->m_header_bits & Tuple_header::FREE) {
541
 
      ljam();
 
539
      jam();
542
540
      buildPtr.p->m_tupleNo++;
543
541
      break;
544
542
    }
581
579
      tuple as a copy tuple. The original tuple is stable and is thus
582
580
      preferrable to store in TUX.
583
581
      */
584
 
      ljam();
 
582
      jam();
585
583
 
586
584
      /**
587
585
       * Since copy tuples now can't be found on real pages.
610
608
      } while(req->errorCode == 0 && pageOperPtr.i != RNIL);
611
609
    } 
612
610
    
613
 
    ljamEntry();
 
611
    jamEntry();
614
612
    if (req->errorCode != 0) {
615
613
      switch (req->errorCode) {
616
614
      case TuxMaintReq::NoMemError:
617
 
        ljam();
 
615
        jam();
618
616
        buildPtr.p->m_errorCode= BuildIndxRef::AllocationFailure;
619
617
        break;
620
618
      default:
666
664
  rep->setIndexId(buildReq->getIndexId());
667
665
  // conf
668
666
  if (buildPtrP->m_errorCode == BuildIndxRef::NoError) {
669
 
    ljam();
 
667
    jam();
670
668
    sendSignal(rep->getUserRef(), GSN_BUILDINDXCONF,
671
669
        signal, BuildIndxConf::SignalLength, JBB);
672
670
    return;