← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/que/que0que.cc

  • Committer: Lee Bieber
  • Date: 2010-12-28 17:42:52 UTC
  • mfrom: (2023.3.32 innodb-cxx)
  • Revision ID: kalebral@gmail.com-20101228174252-fy2isiqdaphf2gl3
Merge Monty, move innobase from C to C++

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/que/que0que.cc
166
166
 
167
167
        ut_ad(heap);
168
168
 
169
 
        fork = mem_heap_alloc(heap, sizeof(que_fork_t));
 
169
        fork = static_cast<que_fork_t *>(mem_heap_alloc(heap, sizeof(que_fork_t)));
170
170
 
171
171
        fork->common.type = QUE_NODE_FORK;
172
172
        fork->n_active_thrs = 0;
208
208
 
209
209
        ut_ad(parent && heap);
210
210
 
211
 
        thr = mem_heap_alloc(heap, sizeof(que_thr_t));
 
211
        thr = static_cast<que_thr_t *>(mem_heap_alloc(heap, sizeof(que_thr_t)));
212
212
 
213
213
        thr->common.type = QUE_NODE_THR;
214
214
        thr->common.parent = parent;
425
425
void
426
426
que_fork_error_handle(
427
427
/*==================*/
428
 
        trx_t*  trx __attribute__((unused)),    /*!< in: trx */
 
428
        trx_t*  /*trx __attribute__((unused))*/,        /*!< in: trx */
429
429
        que_t*  fork)   /*!< in: query graph which was run before signal
430
430
                        handling started, NULL not allowed */
431
431
{
527
527
        switch (que_node_get_type(node)) {
528
528
 
529
529
        case QUE_NODE_FORK:
530
 
                fork = node;
 
530
                fork = static_cast<que_fork_t *>(node);
531
531
 
532
532
                thr = UT_LIST_GET_FIRST(fork->thrs);
533
533
 
540
540
                break;
541
541
        case QUE_NODE_THR:
542
542
 
543
 
                thr = node;
 
543
                thr = static_cast<que_thr_t *>(node);
544
544
 
545
545
                if (thr->magic_n != QUE_THR_MAGIC_N) {
546
546
                        fprintf(stderr,
558
558
                break;
559
559
        case QUE_NODE_UNDO:
560
560
 
561
 
                undo = node;
 
561
                undo = static_cast<undo_node_t *>(node);
562
562
 
563
563
                mem_heap_free(undo->heap);
564
564
 
565
565
                break;
566
566
        case QUE_NODE_SELECT:
567
567
 
568
 
                sel = node;
 
568
                sel = static_cast<sel_node_t *>(node);
569
569
 
570
570
                sel_node_free_private(sel);
571
571
 
572
572
                break;
573
573
        case QUE_NODE_INSERT:
574
574
 
575
 
                ins = node;
 
575
                ins = static_cast<ins_node_t *>(node);
576
576
 
577
577
                que_graph_free_recursive(ins->select);
578
578
 
580
580
 
581
581
                break;
582
582
        case QUE_NODE_PURGE:
583
 
                purge = node;
 
583
                purge = static_cast<purge_node_t *>(node);
584
584
 
585
585
                mem_heap_free(purge->heap);
586
586
 
588
588
 
589
589
        case QUE_NODE_UPDATE:
590
590
 
591
 
                upd = node;
 
591
                upd = static_cast<upd_node_t *>(node);
592
592
 
593
593
                if (upd->in_mysql_interface) {
594
594
 
607
607
 
608
608
                break;
609
609
        case QUE_NODE_CREATE_TABLE:
610
 
                cre_tab = node;
 
610
                cre_tab = static_cast<tab_node_t *>(node);
611
611
 
612
612
                que_graph_free_recursive(cre_tab->tab_def);
613
613
                que_graph_free_recursive(cre_tab->col_def);
617
617
 
618
618
                break;
619
619
        case QUE_NODE_CREATE_INDEX:
620
 
                cre_ind = node;
 
620
                cre_ind = static_cast<ind_node_t *>(node);
621
621
 
622
622
                que_graph_free_recursive(cre_ind->ind_def);
623
623
                que_graph_free_recursive(cre_ind->field_def);
799
799
        ulint           fork_type;
800
800
        ibool           stopped;
801
801
 
802
 
        fork = thr->common.parent;
 
802
        fork = static_cast<que_fork_t *>(thr->common.parent);
803
803
        trx = thr_get_trx(thr);
804
804
 
805
805
        mutex_enter(&kernel_mutex);