← Back to branch summary

~ubuntu-branches/ubuntu/precise/mysql-5.1/precise

« back to all changes in this revision

Viewing changes to sql/rpl_utility.h

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Tretkowski
  • Date: 2010-03-17 14:56:02 UTC
  • Revision ID: james.westby@ubuntu.com-20100317145602-x7e30l1b2sb5s6w6
Tags: upstream-5.1.45
Import upstream version 5.1.45

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/rpl_utility.h
 
1
/* Copyright (C) 2006 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
15
 
 
16
#ifndef RPL_UTILITY_H
 
17
#define RPL_UTILITY_H
 
18
 
 
19
#ifndef __cplusplus
 
20
#error "Don't include this C++ header file from a non-C++ file!"
 
21
#endif
 
22
 
 
23
#include "mysql_priv.h"
 
24
 
 
25
class Relay_log_info;
 
26
 
 
27
 
 
28
/**
 
29
  A table definition from the master.
 
30
 
 
31
  The responsibilities of this class is:
 
32
  - Extract and decode table definition data from the table map event
 
33
  - Check if table definition in table map is compatible with table
 
34
    definition on slave
 
35
 
 
36
  Currently, the only field type data available is an array of the
 
37
  type operators that are present in the table map event.
 
38
 
 
39
  @todo Add type operands to this structure to allow detection of
 
40
     difference between, e.g., BIT(5) and BIT(10).
 
41
 */
 
42
 
 
43
class table_def
 
44
{
 
45
public:
 
46
  /**
 
47
    Convenience declaration of the type of the field type data in a
 
48
    table map event.
 
49
  */
 
50
  typedef unsigned char field_type;
 
51
 
 
52
  /**
 
53
    Constructor.
 
54
 
 
55
    @param types Array of types
 
56
    @param size  Number of elements in array 'types'
 
57
    @param field_metadata Array of extra information about fields
 
58
    @param metadata_size Size of the field_metadata array
 
59
    @param null_bitmap The bitmap of fields that can be null
 
60
   */
 
61
  table_def(field_type *types, ulong size, uchar *field_metadata, 
 
62
      int metadata_size, uchar *null_bitmap)
 
63
    : m_size(size), m_type(0), m_field_metadata_size(metadata_size),
 
64
      m_field_metadata(0), m_null_bits(0), m_memory(NULL)
 
65
  {
 
66
    m_memory= (uchar *)my_multi_malloc(MYF(MY_WME),
 
67
                                       &m_type, size,
 
68
                                       &m_field_metadata,
 
69
                                       size * sizeof(uint16),
 
70
                                       &m_null_bits, (size + 7) / 8,
 
71
                                       NULL);
 
72
 
 
73
    bzero(m_field_metadata, size * sizeof(uint16));
 
74
 
 
75
    if (m_type)
 
76
      memcpy(m_type, types, size);
 
77
    else
 
78
      m_size= 0;
 
79
    /*
 
80
      Extract the data from the table map into the field metadata array
 
81
      iff there is field metadata. The variable metadata_size will be
 
82
      0 if we are replicating from an older version server since no field
 
83
      metadata was written to the table map. This can also happen if 
 
84
      there were no fields in the master that needed extra metadata.
 
85
    */
 
86
    if (m_size && metadata_size)
 
87
    { 
 
88
      int index= 0;
 
89
      for (unsigned int i= 0; i < m_size; i++)
 
90
      {
 
91
        switch (m_type[i]) {
 
92
        case MYSQL_TYPE_TINY_BLOB:
 
93
        case MYSQL_TYPE_BLOB:
 
94
        case MYSQL_TYPE_MEDIUM_BLOB:
 
95
        case MYSQL_TYPE_LONG_BLOB:
 
96
        case MYSQL_TYPE_DOUBLE:
 
97
        case MYSQL_TYPE_FLOAT:
 
98
        case MYSQL_TYPE_GEOMETRY:
 
99
        {
 
100
          /*
 
101
            These types store a single byte.
 
102
          */
 
103
          m_field_metadata[i]= field_metadata[index];
 
104
          index++;
 
105
          break;
 
106
        }
 
107
        case MYSQL_TYPE_SET:
 
108
        case MYSQL_TYPE_ENUM:
 
109
        case MYSQL_TYPE_STRING:
 
110
        {
 
111
          uint16 x= field_metadata[index++] << 8U; // real_type
 
112
          x+= field_metadata[index++];            // pack or field length
 
113
          m_field_metadata[i]= x;
 
114
          break;
 
115
        }
 
116
        case MYSQL_TYPE_BIT:
 
117
        {
 
118
          uint16 x= field_metadata[index++]; 
 
119
          x = x + (field_metadata[index++] << 8U);
 
120
          m_field_metadata[i]= x;
 
121
          break;
 
122
        }
 
123
        case MYSQL_TYPE_VARCHAR:
 
124
        {
 
125
          /*
 
126
            These types store two bytes.
 
127
          */
 
128
          char *ptr= (char *)&field_metadata[index];
 
129
          m_field_metadata[i]= uint2korr(ptr);
 
130
          index= index + 2;
 
131
          break;
 
132
        }
 
133
        case MYSQL_TYPE_NEWDECIMAL:
 
134
        {
 
135
          uint16 x= field_metadata[index++] << 8U; // precision
 
136
          x+= field_metadata[index++];            // decimals
 
137
          m_field_metadata[i]= x;
 
138
          break;
 
139
        }
 
140
        default:
 
141
          m_field_metadata[i]= 0;
 
142
          break;
 
143
        }
 
144
      }
 
145
    }
 
146
    if (m_size && null_bitmap)
 
147
       memcpy(m_null_bits, null_bitmap, (m_size + 7) / 8);
 
148
  }
 
149
 
 
150
  ~table_def() {
 
151
    my_free(m_memory, MYF(0));
 
152
#ifndef DBUG_OFF
 
153
    m_type= 0;
 
154
    m_size= 0;
 
155
#endif
 
156
  }
 
157
 
 
158
  /**
 
159
    Return the number of fields there is type data for.
 
160
 
 
161
    @return The number of fields that there is type data for.
 
162
   */
 
163
  ulong size() const { return m_size; }
 
164
 
 
165
 
 
166
  /*
 
167
    Return a representation of the type data for one field.
 
168
 
 
169
    @param index Field index to return data for
 
170
 
 
171
    @return Will return a representation of the type data for field
 
172
    <code>index</code>. Currently, only the type identifier is
 
173
    returned.
 
174
   */
 
175
  field_type type(ulong index) const
 
176
  {
 
177
    DBUG_ASSERT(index < m_size);
 
178
    return m_type[index];
 
179
  }
 
180
 
 
181
 
 
182
  /*
 
183
    This function allows callers to get the extra field data from the
 
184
    table map for a given field. If there is no metadata for that field
 
185
    or there is no extra metadata at all, the function returns 0.
 
186
 
 
187
    The function returns the value for the field metadata for column at 
 
188
    position indicated by index. As mentioned, if the field was a type 
 
189
    that stores field metadata, that value is returned else zero (0) is 
 
190
    returned. This method is used in the unpack() methods of the 
 
191
    corresponding fields to properly extract the data from the binary log 
 
192
    in the event that the master's field is smaller than the slave.
 
193
  */
 
194
  uint16 field_metadata(uint index) const
 
195
  {
 
196
    DBUG_ASSERT(index < m_size);
 
197
    if (m_field_metadata_size)
 
198
      return m_field_metadata[index];
 
199
    else
 
200
      return 0;
 
201
  }
 
202
 
 
203
  /*
 
204
    This function returns whether the field on the master can be null.
 
205
    This value is derived from field->maybe_null().
 
206
  */
 
207
  my_bool maybe_null(uint index) const
 
208
  {
 
209
    DBUG_ASSERT(index < m_size);
 
210
    return ((m_null_bits[(index / 8)] & 
 
211
            (1 << (index % 8))) == (1 << (index %8)));
 
212
  }
 
213
 
 
214
  /*
 
215
    This function returns the field size in raw bytes based on the type
 
216
    and the encoded field data from the master's raw data. This method can 
 
217
    be used for situations where the slave needs to skip a column (e.g., 
 
218
    WL#3915) or needs to advance the pointer for the fields in the raw 
 
219
    data from the master to a specific column.
 
220
  */
 
221
  uint32 calc_field_size(uint col, uchar *master_data) const;
 
222
 
 
223
  /**
 
224
    Decide if the table definition is compatible with a table.
 
225
 
 
226
    Compare the definition with a table to see if it is compatible
 
227
    with it.
 
228
 
 
229
    A table definition is compatible with a table if:
 
230
      - the columns types of the table definition is a (not
 
231
        necessarily proper) prefix of the column type of the table, or
 
232
      - the other way around
 
233
 
 
234
    @param rli   Pointer to relay log info
 
235
    @param table Pointer to table to compare with.
 
236
 
 
237
    @retval 1  if the table definition is not compatible with @c table
 
238
    @retval 0  if the table definition is compatible with @c table
 
239
  */
 
240
#ifndef MYSQL_CLIENT
 
241
  int compatible_with(Relay_log_info const *rli, TABLE *table) const;
 
242
#endif
 
243
 
 
244
private:
 
245
  ulong m_size;           // Number of elements in the types array
 
246
  field_type *m_type;                     // Array of type descriptors
 
247
  uint m_field_metadata_size;
 
248
  uint16 *m_field_metadata;
 
249
  uchar *m_null_bits;
 
250
  uchar *m_memory;
 
251
};
 
252
 
 
253
 
 
254
#ifndef MYSQL_CLIENT
 
255
/**
 
256
   Extend the normal table list with a few new fields needed by the
 
257
   slave thread, but nowhere else.
 
258
 */
 
259
struct RPL_TABLE_LIST
 
260
  : public TABLE_LIST
 
261
{
 
262
  bool m_tabledef_valid;
 
263
  table_def m_tabledef;
 
264
};
 
265
 
 
266
 
 
267
/* Anonymous namespace for template functions/classes */
 
268
namespace {
 
269
 
 
270
  /*
 
271
    Smart pointer that will automatically call my_afree (a macro) when
 
272
    the pointer goes out of scope.  This is used so that I do not have
 
273
    to remember to call my_afree() before each return.  There is no
 
274
    overhead associated with this, since all functions are inline.
 
275
 
 
276
    I (Matz) would prefer to use the free function as a template
 
277
    parameter, but that is not possible when the "function" is a
 
278
    macro.
 
279
  */
 
280
  template <class Obj>
 
281
  class auto_afree_ptr
 
282
  {
 
283
    Obj* m_ptr;
 
284
  public:
 
285
    auto_afree_ptr(Obj* ptr) : m_ptr(ptr) { }
 
286
    ~auto_afree_ptr() { if (m_ptr) my_afree(m_ptr); }
 
287
    void assign(Obj* ptr) {
 
288
      /* Only to be called if it hasn't been given a value before. */
 
289
      DBUG_ASSERT(m_ptr == NULL);
 
290
      m_ptr= ptr;
 
291
    }
 
292
    Obj* get() { return m_ptr; }
 
293
  };
 
294
 
 
295
}
 
296
#endif
 
297
 
 
298
// NB. number of printed bit values is limited to sizeof(buf) - 1
 
299
#define DBUG_PRINT_BITSET(N,FRM,BS)                \
 
300
  do {                                             \
 
301
    char buf[256];                                 \
 
302
    uint i;                                        \
 
303
    for (i = 0 ; i < min(sizeof(buf) - 1, (BS)->n_bits) ; i++) \
 
304
      buf[i] = bitmap_is_set((BS), i) ? '1' : '0'; \
 
305
    buf[i] = '\0';                                 \
 
306
    DBUG_PRINT((N), ((FRM), buf));                 \
 
307
  } while (0)
 
308
 
 
309
#endif /* RPL_UTILITY_H */