← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/hash0hash.ic

Merge Revision revid:svn-v4:16c675df-0fcb-4bc9-8058-dcc011a37293:branches/zip:6790 from MySQL InnoDB

Original revid:svn-v4:16c675df-0fcb-4bc9-8058-dcc011a37293:branches/zip:6790

Original Authors: jyang
Original commit message:
branches/zip: Fix bug #51356: "many valgrind errors in error messages
with concurrent ddl". Null terminate the name string returned
from innobase_convert_identifier() call when reporting DB_DUPLICATE_KEY
error in create_table_def().
rb://266 approved by Marko

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/hash0hash.ic
35
35
        hash_table_t*   table,  /*!< in: hash table */
36
36
        ulint           n)      /*!< in: cell index */
37
37
{
38
 
        ut_ad(table);
39
 
        ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
40
38
        ut_ad(n < table->n_cells);
41
39
 
42
40
        return(table->array + n);
50
48
/*=============*/
51
49
        hash_table_t*   table)  /*!< in/out: hash table */
52
50
{
53
 
        ut_ad(table);
54
 
        ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
55
51
        memset(table->array, 0x0,
56
52
               table->n_cells * sizeof(*table->array));
57
53
}
65
61
/*=============*/
66
62
        hash_table_t*   table)  /*!< in: table */
67
63
{
68
 
        ut_ad(table);
69
 
        ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
70
64
        return(table->n_cells);
71
65
}
72
66
 
80
74
        ulint           fold,   /*!< in: folded value */
81
75
        hash_table_t*   table)  /*!< in: hash table */
82
76
{
83
 
        ut_ad(table);
84
 
        ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
85
77
        return(ut_hash_ulint(fold, table->n_cells));
86
78
}
87
79
 
96
88
        hash_table_t*   table,  /*!< in: hash table */
97
89
        ulint           fold)   /*!< in: fold */
98
90
{
99
 
        ut_ad(table);
100
 
        ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
101
91
        ut_ad(ut_is_2pow(table->n_mutexes));
102
92
        return(ut_2pow_remainder(hash_calc_hash(fold, table),
103
93
                                 table->n_mutexes));
113
103
        hash_table_t*   table,  /*!< in: hash table */
114
104
        ulint           i)      /*!< in: index of the heap */
115
105
{
116
 
        ut_ad(table);
117
 
        ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
118
106
        ut_ad(i < table->n_mutexes);
119
107
 
120
108
        return(table->heaps[i]);
132
120
{
133
121
        ulint   i;
134
122
 
135
 
        ut_ad(table);
136
 
        ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
137
 
 
138
123
        if (table->heap) {
139
124
                return(table->heap);
140
125
        }
154
139
        hash_table_t*   table,  /*!< in: hash table */
155
140
        ulint           i)      /*!< in: index of the mutex */
156
141
{
157
 
        ut_ad(table);
158
 
        ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
159
142
        ut_ad(i < table->n_mutexes);
160
143
 
161
144
        return(table->mutexes + i);
173
156
{
174
157
        ulint   i;
175
158
 
176
 
        ut_ad(table);
177
 
        ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
178
 
 
179
159
        i = hash_get_mutex_no(table, fold);
180
160
 
181
161
        return(hash_get_nth_mutex(table, i));