← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/row/row0mysql.cc

  • Committer: Lee Bieber
  • Date: 2011-03-29 22:31:41 UTC
  • mfrom: (2257.1.3 build)
  • Revision ID: kalebral@gmail.com-20110329223141-yxc22h3l2he58sk0
Merge Andrew - 743842: Build failure using GCC 4.6
Merge Stewart - 738022: CachedDirectory silently fails to add entries if stat() fails
Merge Olaf - Common fwd: add copyright, add more declaration

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/row/row0mysql.cc
486
486
                                        row is used, as row may contain
487
487
                                        pointers to this record! */
488
488
{
489
 
        mysql_row_templ_t*      templ;
 
489
        const mysql_row_templ_t*templ;
490
490
        dfield_t*               dfield;
491
491
        ulint                   i;
492
492
 
659
659
 
660
660
        heap = mem_heap_create(sizeof *prebuilt + 128);
661
661
 
662
 
        prebuilt = mem_heap_zalloc(heap, sizeof *prebuilt);
 
662
        prebuilt = static_cast<row_prebuilt_t *>(mem_heap_zalloc(heap, sizeof *prebuilt));
663
663
 
664
664
        prebuilt->magic_n = ROW_PREBUILT_ALLOCATED;
665
665
        prebuilt->magic_n2 = ROW_PREBUILT_ALLOCATED;
869
869
                prebuilt->ins_node = node;
870
870
 
871
871
                if (prebuilt->ins_upd_rec_buff == NULL) {
872
 
                        prebuilt->ins_upd_rec_buff = mem_heap_alloc(
873
 
                                prebuilt->heap, prebuilt->mysql_row_len);
 
872
                        prebuilt->ins_upd_rec_buff = static_cast<byte *>(mem_heap_alloc(
 
873
                                prebuilt->heap, prebuilt->mysql_row_len));
874
874
                }
875
875
 
876
876
                row = dtuple_create(prebuilt->heap,
880
880
 
881
881
                ins_node_set_new_row(node, row);
882
882
 
883
 
                prebuilt->ins_graph = que_node_get_parent(
 
883
                prebuilt->ins_graph = static_cast<que_fork_t *>(que_node_get_parent(
884
884
                        pars_complete_graph_for_exec(node,
885
885
                                                     prebuilt->trx,
886
 
                                                     prebuilt->heap));
 
886
                                                     prebuilt->heap)));
887
887
                prebuilt->ins_graph->state = QUE_FORK_ACTIVE;
888
888
        }
889
889
 
914
914
        if (counter > 2000000000
915
915
            || ((ib_int64_t)counter > 16 + table->stat_n_rows / 16)) {
916
916
 
917
 
                dict_update_statistics(table);
 
917
                dict_update_statistics(table, FALSE /* update even if stats
 
918
                                                    are initialized */);
918
919
        }
919
920
}
920
921
 
1065
1066
        trx_start_if_not_started(trx);
1066
1067
 
1067
1068
        if (table) {
1068
 
                err = lock_table(0, table, mode, thr);
 
1069
                err = lock_table(0, table, static_cast<lock_mode>(mode), thr);
1069
1070
        } else {
1070
1071
                err = lock_table(0, prebuilt->table,
1071
 
                                 prebuilt->select_lock_type, thr);
 
1072
                                 static_cast<lock_mode>(prebuilt->select_lock_type), thr);
1072
1073
        }
1073
1074
 
1074
1075
        trx->error_state = err;
1243
1244
 
1244
1245
                node = sel_node_create(prebuilt->heap);
1245
1246
 
1246
 
                prebuilt->sel_graph = que_node_get_parent(
 
1247
                prebuilt->sel_graph = static_cast<que_fork_t *>(que_node_get_parent(
1247
1248
                        pars_complete_graph_for_exec(node,
1248
1249
                                                     prebuilt->trx,
1249
 
                                                     prebuilt->heap));
 
1250
                                                     prebuilt->heap)));
1250
1251
 
1251
1252
                prebuilt->sel_graph->state = QUE_FORK_ACTIVE;
1252
1253
        }
1314
1315
 
1315
1316
                prebuilt->upd_node = node;
1316
1317
 
1317
 
                prebuilt->upd_graph = que_node_get_parent(
 
1318
                prebuilt->upd_graph = static_cast<que_fork_t *>(que_node_get_parent(
1318
1319
                        pars_complete_graph_for_exec(node,
1319
1320
                                                     prebuilt->trx,
1320
 
                                                     prebuilt->heap));
 
1321
                                                     prebuilt->heap)));
1321
1322
                prebuilt->upd_graph->state = QUE_FORK_ACTIVE;
1322
1323
        }
1323
1324
 
1604
1605
                        index = btr_pcur_get_btr_cur(pcur)->index;
1605
1606
 
1606
1607
                        lock_rec_unlock(trx, btr_pcur_get_block(pcur),
1607
 
                                        rec, prebuilt->select_lock_type);
 
1608
                                        rec, static_cast<lock_mode>(prebuilt->select_lock_type));
1608
1609
 
1609
1610
                        if (prebuilt->new_rec_locks >= 2) {
1610
1611
                                rec = btr_pcur_get_rec(clust_pcur);
1613
1614
                                lock_rec_unlock(trx,
1614
1615
                                                btr_pcur_get_block(clust_pcur),
1615
1616
                                                rec,
1616
 
                                                prebuilt->select_lock_type);
 
1617
                                                static_cast<lock_mode>(prebuilt->select_lock_type));
1617
1618
                        }
1618
1619
                }
1619
1620
no_unlock:
1911
1912
 
1912
1913
        thr = pars_complete_graph_for_exec(node, trx, heap);
1913
1914
 
1914
 
        ut_a(thr == que_fork_start_command(que_node_get_parent(thr)));
 
1915
        ut_a(thr == que_fork_start_command(static_cast<que_fork_t *>(que_node_get_parent(thr))));
1915
1916
        que_run_threads(thr);
1916
1917
 
1917
1918
        err = trx->error_state;
1918
1919
 
1919
 
        if (UNIV_UNLIKELY(err != DB_SUCCESS)) {
 
1920
        switch (err) {
 
1921
        case DB_SUCCESS:
 
1922
                break;
 
1923
        case DB_OUT_OF_FILE_SPACE:
1920
1924
                trx->error_state = DB_SUCCESS;
1921
1925
                trx_general_rollback_for_mysql(trx, NULL);
1922
 
                /* TO DO: free table?  The code below will dereference
1923
 
                table->name, though. */
1924
 
        }
1925
1926
 
1926
 
        switch (err) {
1927
 
        case DB_OUT_OF_FILE_SPACE:
1928
1927
                ut_print_timestamp(stderr);
1929
1928
                fputs("  InnoDB: Warning: cannot create table ",
1930
1929
                      stderr);
1939
1938
                break;
1940
1939
 
1941
1940
        case DB_DUPLICATE_KEY:
 
1941
        default:
1942
1942
                /* We may also get err == DB_ERROR if the .ibd file for the
1943
1943
                table already exists */
1944
1944
 
 
1945
                trx->error_state = DB_SUCCESS;
 
1946
                trx_general_rollback_for_mysql(trx, NULL);
 
1947
                dict_mem_table_free(table);
1945
1948
                break;
1946
1949
        }
1947
1950
 
2050
2053
 
2051
2054
        thr = pars_complete_graph_for_exec(node, trx, heap);
2052
2055
 
2053
 
        ut_a(thr == que_fork_start_command(que_node_get_parent(thr)));
 
2056
        ut_a(thr == que_fork_start_command(static_cast<que_fork_t *>(que_node_get_parent(thr))));
2054
2057
        que_run_threads(thr);
2055
2058
 
2056
2059
        err = trx->error_state;
2323
2326
                drop = UT_LIST_GET_NEXT(row_mysql_drop_list, drop);
2324
2327
        }
2325
2328
 
2326
 
        drop = mem_alloc(sizeof(row_mysql_drop_t));
 
2329
        drop = static_cast<row_mysql_drop_t *>(mem_alloc(sizeof(row_mysql_drop_t)));
2327
2330
 
2328
2331
        drop->table_name = mem_strdup(name);
2329
2332
 
2817
2820
 
2818
2821
        trx->table_id = table->id;
2819
2822
 
2820
 
        /* Lock all index trees for this table, as we will
2821
 
        truncate the table/index and possibly change their metadata.
2822
 
        All DML/DDL are blocked by table level lock, with
2823
 
        a few exceptions such as queries into information schema
2824
 
        about the table, MySQL could try to access index stats
2825
 
        for this kind of query, we need to use index locks to
2826
 
        sync up */
2827
 
        dict_table_x_lock_indexes(table);
2828
 
 
2829
2823
        if (table->space && !table->dir_path_of_temp_table) {
2830
2824
                /* Discard and create the single-table tablespace. */
2831
2825
                ulint   space   = table->space;
2838
2832
 
2839
2833
                        dict_hdr_get_new_id(NULL, NULL, &space);
2840
2834
 
 
2835
                        /* Lock all index trees for this table. We must
 
2836
                        do so after dict_hdr_get_new_id() to preserve
 
2837
                        the latch order */
 
2838
                        dict_table_x_lock_indexes(table);
 
2839
 
2841
2840
                        if (space == ULINT_UNDEFINED
2842
2841
                            || fil_create_new_single_table_tablespace(
2843
2842
                                    space, table->name, FALSE, flags,
2871
2870
                                        FIL_IBD_FILE_INITIAL_SIZE, &mtr);
2872
2871
                        mtr_commit(&mtr);
2873
2872
                }
 
2873
        } else {
 
2874
                /* Lock all index trees for this table, as we will
 
2875
                truncate the table/index and possibly change their metadata.
 
2876
                All DML/DDL are blocked by table level lock, with
 
2877
                a few exceptions such as queries into information schema
 
2878
                about the table, MySQL could try to access index stats
 
2879
                for this kind of query, we need to use index locks to
 
2880
                sync up */
 
2881
                dict_table_x_lock_indexes(table);
2874
2882
        }
2875
2883
 
2876
2884
        /* scan SYS_INDEXES for all indexes of the table */
2879
2887
        tuple = dtuple_create(heap, 1);
2880
2888
        dfield = dtuple_get_nth_field(tuple, 0);
2881
2889
 
2882
 
        buf = mem_heap_alloc(heap, 8);
 
2890
        buf = static_cast<byte *>(mem_heap_alloc(heap, 8));
2883
2891
        mach_write_to_8(buf, table->id);
2884
2892
 
2885
2893
        dfield_set_data(dfield, buf, 8);
2996
3004
        dict_table_autoinc_lock(table);
2997
3005
        dict_table_autoinc_initialize(table, 1);
2998
3006
        dict_table_autoinc_unlock(table);
2999
 
        dict_update_statistics(table);
 
3007
        dict_update_statistics(table, FALSE /* update even if stats are
 
3008
                                            initialized */);
3000
3009
 
3001
3010
        trx_commit_for_mysql(trx);
3002
3011
 
3204
3213
 
3205
3214
        if (table->n_foreign_key_checks_running > 0) {
3206
3215
 
3207
 
                const char*     table_name = table->name;
 
3216
                const char*     i_table_name = table->name;
3208
3217
                ibool           added;
3209
3218
 
3210
 
                added = row_add_table_to_background_drop_list(table_name);
 
3219
                added = row_add_table_to_background_drop_list(i_table_name);
3211
3220
 
3212
3221
                if (added) {
3213
3222
                        ut_print_timestamp(stderr);
3214
3223
                        fputs("  InnoDB: You are trying to drop table ",
3215
3224
                              stderr);
3216
 
                        ut_print_name(stderr, trx, TRUE, table_name);
 
3225
                        ut_print_name(stderr, trx, TRUE, i_table_name);
3217
3226
                        fputs("\n"
3218
3227
                              "InnoDB: though there is a"
3219
3228
                              " foreign key check running on it.\n"
4086
4095
 
4087
4096
        *n_rows = 0;
4088
4097
 
4089
 
        buf = mem_alloc(UNIV_PAGE_SIZE);
 
4098
        buf = static_cast<byte *>(mem_alloc(UNIV_PAGE_SIZE));
4090
4099
        heap = mem_heap_create(100);
4091
4100
 
4092
4101
        cnt = 1000;
4187
4196
                                * sizeof *offsets;
4188
4197
 
4189
4198
                        tmp_heap = mem_heap_create(size);
4190
 
                        offsets = mem_heap_dup(tmp_heap, offsets, size);
 
4199
                        offsets = static_cast<ulint *>(mem_heap_dup(tmp_heap, offsets, size));
4191
4200
                }
4192
4201
 
4193
4202
                mem_heap_empty(heap);