← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/rpl_utility.h

  • Committer: Monty Taylor
  • Date: 2008-10-27 23:19:48 UTC
  • mto: (520.4.12 merge-innodb-plugin)
  • mto: This revision was merged to the branch mainline in revision 563.
  • Revision ID: monty@inaugust.com-20081027231948-3kl6ss04plbakqcr
Split some more things out of common_includes.h.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/rpl_utility.h
21
21
#define RPL_UTILITY_H
22
22
 
23
23
#include <drizzled/server_includes.h>
24
 
#include <drizzled/table_list.h>
25
24
 
26
25
class Relay_log_info;
27
26
 
59
58
    @param metadata_size Size of the field_metadata array
60
59
    @param null_bitmap The bitmap of fields that can be null
61
60
   */
62
 
  table_def(field_type *types, uint32_t size, unsigned char *field_metadata,
 
61
  table_def(field_type *types, uint32_t size, unsigned char *field_metadata, 
63
62
      int metadata_size, unsigned char *null_bitmap)
64
63
    : m_size(size), m_type(0), m_field_metadata_size(metadata_size),
65
64
      m_field_metadata(0), m_null_bits(0), m_memory(NULL)
81
80
      Extract the data from the table map into the field metadata array
82
81
      iff there is field metadata. The variable metadata_size will be
83
82
      0 if we are replicating from an older version server since no field
84
 
      metadata was written to the table map. This can also happen if
 
83
      metadata was written to the table map. This can also happen if 
85
84
      there were no fields in the master that needed extra metadata.
86
85
    */
87
86
    if (m_size && metadata_size)
88
 
    {
 
87
    { 
89
88
      int index= 0;
90
89
      for (unsigned int i= 0; i < m_size; i++)
91
90
      {
169
168
    table map for a given field. If there is no metadata for that field
170
169
    or there is no extra metadata at all, the function returns 0.
171
170
 
172
 
    The function returns the value for the field metadata for column at
173
 
    position indicated by index. As mentioned, if the field was a type
174
 
    that stores field metadata, that value is returned else zero (0) is
175
 
    returned. This method is used in the unpack() methods of the
176
 
    corresponding fields to properly extract the data from the binary log
 
171
    The function returns the value for the field metadata for column at 
 
172
    position indicated by index. As mentioned, if the field was a type 
 
173
    that stores field metadata, that value is returned else zero (0) is 
 
174
    returned. This method is used in the unpack() methods of the 
 
175
    corresponding fields to properly extract the data from the binary log 
177
176
    in the event that the master's field is smaller than the slave.
178
177
  */
179
178
  uint16_t field_metadata(uint32_t index) const
192
191
  bool maybe_null(uint32_t index) const
193
192
  {
194
193
    assert(index < m_size);
195
 
    return ((m_null_bits[(index / 8)] &
 
194
    return ((m_null_bits[(index / 8)] & 
196
195
            (1 << (index % 8))) == (1 << (index %8)));
197
196
  }
198
197
 
199
198
  /*
200
199
    This function returns the field size in raw bytes based on the type
201
 
    and the encoded field data from the master's raw data. This method can
202
 
    be used for situations where the slave needs to skip a column (e.g.,
203
 
    WL#3915) or needs to advance the pointer for the fields in the raw
 
200
    and the encoded field data from the master's raw data. This method can 
 
201
    be used for situations where the slave needs to skip a column (e.g., 
 
202
    WL#3915) or needs to advance the pointer for the fields in the raw 
204
203
    data from the master to a specific column.
205
204
  */
206
205
  uint32_t calc_field_size(uint32_t col, unsigned char *master_data) const;
244
243
  table_def m_tabledef;
245
244
};
246
245
 
 
246
 
 
247
/* Anonymous namespace for template functions/classes */
 
248
namespace {
 
249
 
 
250
  /*
 
251
    Smart pointer that will automatically call my_afree (a macro) when
 
252
    the pointer goes out of scope.  This is used so that I do not have
 
253
    to remember to call my_afree() before each return.  There is no
 
254
    overhead associated with this, since all functions are inline.
 
255
 
 
256
    I (Matz) would prefer to use the free function as a template
 
257
    parameter, but that is not possible when the "function" is a
 
258
    macro.
 
259
  */
 
260
  template <class Obj>
 
261
  class auto_afree_ptr
 
262
  {
 
263
    Obj* m_ptr;
 
264
  public:
 
265
    auto_afree_ptr(Obj* ptr) : m_ptr(ptr) { }
 
266
    ~auto_afree_ptr() { if (m_ptr) my_afree(m_ptr); }
 
267
    void assign(Obj* ptr) {
 
268
      /* Only to be called if it hasn't been given a value before. */
 
269
      assert(m_ptr == NULL);
 
270
      m_ptr= ptr;
 
271
    }
 
272
    Obj* get() { return m_ptr; }
 
273
  };
 
274
 
 
275
}
 
276
 
247
277
#endif /* RPL_UTILITY_H */