rpl_utility.h 9.52 KB
Newer Older
1 2
/*
   Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
3 4 5

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
unknown's avatar
unknown committed
6
   the Free Software Foundation; version 2 of the License.
7 8 9 10 11 12 13 14

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
15 16
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
*/
17 18 19 20 21 22 23 24 25 26

#ifndef RPL_UTILITY_H
#define RPL_UTILITY_H

#ifndef __cplusplus
#error "Don't include this C++ header file from a non-C++ file!"
#endif

#include "mysql_priv.h"

27
class Relay_log_info;
28

29

30
/**
31 32
  A table definition from the master.

33
  The responsibilities of this class is:
34
  - Extract and decode table definition data from the table map event
35 36 37 38 39 40 41
  - Check if table definition in table map is compatible with table
    definition on slave
 */

class table_def
{
public:
42
  /**
43 44 45
    Convenience declaration of the type of the field type data in a
    table map event.
  */
46 47
  typedef unsigned char field_type;

48
  /**
49 50
    Constructor.

51 52
    @param types Array of types
    @param size  Number of elements in array 'types'
53 54 55
    @param field_metadata Array of extra information about fields
    @param metadata_size Size of the field_metadata array
    @param null_bitmap The bitmap of fields that can be null
56
   */
57
  table_def(field_type *types, ulong size, uchar *field_metadata, 
58
      int metadata_size, uchar *null_bitmap, uint16 flags)
59
    : m_size(size), m_type(0), m_field_metadata_size(metadata_size),
60
    m_field_metadata(0), m_null_bits(0), m_flags(flags), m_memory(NULL)
61
  {
62
    m_memory= (uchar *)my_multi_malloc(MYF(MY_WME),
63 64 65 66 67 68 69 70
                                       &m_type, size,
                                       &m_field_metadata,
                                       size * sizeof(uint16),
                                       &m_null_bits, (size + 7) / 8,
                                       NULL);

    bzero(m_field_metadata, size * sizeof(uint16));

71 72 73 74
    if (m_type)
      memcpy(m_type, types, size);
    else
      m_size= 0;
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
    /*
      Extract the data from the table map into the field metadata array
      iff there is field metadata. The variable metadata_size will be
      0 if we are replicating from an older version server since no field
      metadata was written to the table map. This can also happen if 
      there were no fields in the master that needed extra metadata.
    */
    if (m_size && metadata_size)
    { 
      int index= 0;
      for (unsigned int i= 0; i < m_size; i++)
      {
        switch (m_type[i]) {
        case MYSQL_TYPE_TINY_BLOB:
        case MYSQL_TYPE_BLOB:
        case MYSQL_TYPE_MEDIUM_BLOB:
        case MYSQL_TYPE_LONG_BLOB:
        case MYSQL_TYPE_DOUBLE:
        case MYSQL_TYPE_FLOAT:
94
        case MYSQL_TYPE_GEOMETRY:
95 96 97 98
        {
          /*
            These types store a single byte.
          */
99
          m_field_metadata[i]= field_metadata[index];
100 101 102 103 104 105 106
          index++;
          break;
        }
        case MYSQL_TYPE_SET:
        case MYSQL_TYPE_ENUM:
        case MYSQL_TYPE_STRING:
        {
107 108
          uint16 x= field_metadata[index++] << 8U; // real_type
          x+= field_metadata[index++];            // pack or field length
109 110 111 112 113
          m_field_metadata[i]= x;
          break;
        }
        case MYSQL_TYPE_BIT:
        {
114
          uint16 x= field_metadata[index++]; 
115 116 117 118 119 120 121 122 123 124
          x = x + (field_metadata[index++] << 8U);
          m_field_metadata[i]= x;
          break;
        }
        case MYSQL_TYPE_VARCHAR:
        {
          /*
            These types store two bytes.
          */
          char *ptr= (char *)&field_metadata[index];
125
          m_field_metadata[i]= uint2korr(ptr);
126
          index= index + 2;
127 128 129 130
          break;
        }
        case MYSQL_TYPE_NEWDECIMAL:
        {
131 132
          uint16 x= field_metadata[index++] << 8U; // precision
          x+= field_metadata[index++];            // decimals
133 134 135 136 137 138 139 140 141 142 143
          m_field_metadata[i]= x;
          break;
        }
        default:
          m_field_metadata[i]= 0;
          break;
        }
      }
    }
    if (m_size && null_bitmap)
       memcpy(m_null_bits, null_bitmap, (m_size + 7) / 8);
144 145
  }

146
  ~table_def() {
147
    my_free(m_memory, MYF(0));
148 149 150 151 152
#ifndef DBUG_OFF
    m_type= 0;
    m_size= 0;
#endif
  }
153

154 155
  /**
    Return the number of fields there is type data for.
156

157
    @return The number of fields that there is type data for.
158
   */
159
  ulong size() const { return m_size; }
160

161

162 163 164
  /*
    Return a representation of the type data for one field.

165
    @param index Field index to return data for
166

167 168 169
    @return Will return a representation of the type data for field
    <code>index</code>. Currently, only the type identifier is
    returned.
170
   */
171
  field_type type(ulong index) const
172
  {
173
    DBUG_ASSERT(index < m_size);
174 175
    return m_type[index];
  }
176

177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192

  /*
    This function allows callers to get the extra field data from the
    table map for a given field. If there is no metadata for that field
    or there is no extra metadata at all, the function returns 0.

    The function returns the value for the field metadata for column at 
    position indicated by index. As mentioned, if the field was a type 
    that stores field metadata, that value is returned else zero (0) is 
    returned. This method is used in the unpack() methods of the 
    corresponding fields to properly extract the data from the binary log 
    in the event that the master's field is smaller than the slave.
  */
  uint16 field_metadata(uint index) const
  {
    DBUG_ASSERT(index < m_size);
193
    if (m_field_metadata_size)
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
      return m_field_metadata[index];
    else
      return 0;
  }

  /*
    This function returns whether the field on the master can be null.
    This value is derived from field->maybe_null().
  */
  my_bool maybe_null(uint index) const
  {
    DBUG_ASSERT(index < m_size);
    return ((m_null_bits[(index / 8)] & 
            (1 << (index % 8))) == (1 << (index %8)));
  }

  /*
    This function returns the field size in raw bytes based on the type
    and the encoded field data from the master's raw data. This method can 
    be used for situations where the slave needs to skip a column (e.g., 
    WL#3915) or needs to advance the pointer for the fields in the raw 
    data from the master to a specific column.
  */
217
  uint32 calc_field_size(uint col, uchar *master_data) const;
218

219
  /**
220 221
    Decide if the table definition is compatible with a table.

222 223
    Compare the definition with a table to see if it is compatible
    with it.
224

225
    A table definition is compatible with a table if:
226 227 228 229
      - the columns types of the table definition is a (not
        necessarily proper) prefix of the column type of the table, or
      - the other way around

230 231 232 233 234
    @param rli   Pointer to relay log info
    @param table Pointer to table to compare with.

    @retval 1  if the table definition is not compatible with @c table
    @retval 0  if the table definition is compatible with @c table
235
  */
236
#ifndef MYSQL_CLIENT
237
  int compatible_with(Relay_log_info const *rli, TABLE *table) const;
238
#endif
239 240

private:
241
  ulong m_size;           // Number of elements in the types array
242
  field_type *m_type;                     // Array of type descriptors
243
  uint m_field_metadata_size;
244
  uint16 *m_field_metadata;
245
  uchar *m_null_bits;
246
  uint16 m_flags;         // Table flags
247
  uchar *m_memory;
248 249
};

250 251

#ifndef MYSQL_CLIENT
252 253 254 255 256
/**
   Extend the normal table list with a few new fields needed by the
   slave thread, but nowhere else.
 */
struct RPL_TABLE_LIST
257
  : public TABLE_LIST
258
{
259
  bool m_tabledef_valid;
260 261 262
  table_def m_tabledef;
};

263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292

/* Anonymous namespace for template functions/classes */
namespace {

  /*
    Smart pointer that will automatically call my_afree (a macro) when
    the pointer goes out of scope.  This is used so that I do not have
    to remember to call my_afree() before each return.  There is no
    overhead associated with this, since all functions are inline.

    I (Matz) would prefer to use the free function as a template
    parameter, but that is not possible when the "function" is a
    macro.
  */
  template <class Obj>
  class auto_afree_ptr
  {
    Obj* m_ptr;
  public:
    auto_afree_ptr(Obj* ptr) : m_ptr(ptr) { }
    ~auto_afree_ptr() { if (m_ptr) my_afree(m_ptr); }
    void assign(Obj* ptr) {
      /* Only to be called if it hasn't been given a value before. */
      DBUG_ASSERT(m_ptr == NULL);
      m_ptr= ptr;
    }
    Obj* get() { return m_ptr; }
  };

}
293 294 295 296 297 298 299 300 301 302

class Deferred_log_events
{
private:
  DYNAMIC_ARRAY array;
  Log_event *last_added;

public:
  Deferred_log_events(Relay_log_info *rli);
  ~Deferred_log_events();
303
  /* queue for exection at Query-log-event time prior the Query */
304 305 306 307 308 309 310
  int add(Log_event *ev);
  bool is_empty();
  bool execute(Relay_log_info *rli);
  void rewind();
  bool is_last(Log_event *ev) { return ev == last_added; };
};

311
#endif
312

313
// NB. number of printed bit values is limited to sizeof(buf) - 1
314 315 316
#define DBUG_PRINT_BITSET(N,FRM,BS)                \
  do {                                             \
    char buf[256];                                 \
317 318
    uint i;                                        \
    for (i = 0 ; i < min(sizeof(buf) - 1, (BS)->n_bits) ; i++) \
319
      buf[i] = bitmap_is_set((BS), i) ? '1' : '0'; \
320
    buf[i] = '\0';                                 \
321 322 323
    DBUG_PRINT((N), ((FRM), buf));                 \
  } while (0)

324
#endif /* RPL_UTILITY_H */