← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/rpl_utility.h

  • Committer: Monty Taylor
  • Date: 2008-07-05 22:08:52 UTC
  • mto: This revision was merged to the branch mainline in revision 77.
  • Revision ID: monty@inaugust.com-20080705220852-cqd9t6tfkhvlcf73
Removed HAVE_LONG_LONG, as this is now assumed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/rpl_utility.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
 
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 */
19
15
 
20
16
#ifndef RPL_UTILITY_H
21
17
#define RPL_UTILITY_H
22
18
 
23
 
#include <drizzled/server_includes.h>
 
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
24
 
25
25
class Relay_log_info;
26
26
 
58
58
    @param metadata_size Size of the field_metadata array
59
59
    @param null_bitmap The bitmap of fields that can be null
60
60
   */
61
 
  table_def(field_type *types, uint32_t size, unsigned char *field_metadata, 
62
 
      int metadata_size, unsigned char *null_bitmap)
 
61
  table_def(field_type *types, ulong size, uchar *field_metadata, 
 
62
      int metadata_size, uchar *null_bitmap)
63
63
    : m_size(size), m_type(0), m_field_metadata_size(metadata_size),
64
64
      m_field_metadata(0), m_null_bits(0), m_memory(NULL)
65
65
  {
66
 
    m_memory= (unsigned char *)my_multi_malloc(MYF(MY_WME),
 
66
    m_memory= (uchar *)my_multi_malloc(MYF(MY_WME),
67
67
                                       &m_type, size,
68
68
                                       &m_field_metadata,
69
 
                                       size * sizeof(uint16_t),
 
69
                                       size * sizeof(uint16),
70
70
                                       &m_null_bits, (size + 7) / 8,
71
71
                                       NULL);
72
72
 
73
 
    memset(m_field_metadata, 0, size * sizeof(uint16_t));
 
73
    bzero(m_field_metadata, size * sizeof(uint16));
74
74
 
75
75
    if (m_type)
76
76
      memcpy(m_type, types, size);
89
89
      for (unsigned int i= 0; i < m_size; i++)
90
90
      {
91
91
        switch (m_type[i]) {
92
 
        case DRIZZLE_TYPE_BLOB:
93
 
        case DRIZZLE_TYPE_DOUBLE:
 
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:
94
98
        {
95
99
          /*
96
100
            These types store a single byte.
99
103
          index++;
100
104
          break;
101
105
        }
102
 
        case DRIZZLE_TYPE_ENUM:
 
106
        case MYSQL_TYPE_SET:
 
107
        case MYSQL_TYPE_ENUM:
 
108
        case MYSQL_TYPE_STRING:
103
109
        {
104
 
          uint16_t x= field_metadata[index++] << 8U; // real_type
 
110
          uint16 x= field_metadata[index++] << 8U; // real_type
105
111
          x+= field_metadata[index++];            // pack or field length
106
112
          m_field_metadata[i]= x;
107
113
          break;
108
114
        }
109
 
        case DRIZZLE_TYPE_VARCHAR:
 
115
        case MYSQL_TYPE_BIT:
 
116
        {
 
117
          uint16 x= field_metadata[index++]; 
 
118
          x = x + (field_metadata[index++] << 8U);
 
119
          m_field_metadata[i]= x;
 
120
          break;
 
121
        }
 
122
        case MYSQL_TYPE_VARCHAR:
110
123
        {
111
124
          /*
112
125
            These types store two bytes.
116
129
          index= index + 2;
117
130
          break;
118
131
        }
119
 
        case DRIZZLE_TYPE_NEWDECIMAL:
 
132
        case MYSQL_TYPE_NEWDECIMAL:
120
133
        {
121
 
          uint16_t x= field_metadata[index++] << 8U; // precision
 
134
          uint16 x= field_metadata[index++] << 8U; // precision
122
135
          x+= field_metadata[index++];            // decimals
123
136
          m_field_metadata[i]= x;
124
137
          break;
134
147
  }
135
148
 
136
149
  ~table_def() {
137
 
    free(m_memory);
 
150
    my_free(m_memory, MYF(0));
 
151
#ifndef DBUG_OFF
138
152
    m_type= 0;
139
153
    m_size= 0;
 
154
#endif
140
155
  }
141
156
 
142
157
  /**
144
159
 
145
160
    @return The number of fields that there is type data for.
146
161
   */
147
 
  uint32_t size() const { return m_size; }
 
162
  ulong size() const { return m_size; }
148
163
 
149
164
 
150
165
  /*
156
171
    <code>index</code>. Currently, only the type identifier is
157
172
    returned.
158
173
   */
159
 
  field_type type(uint32_t index) const
 
174
  field_type type(ulong index) const
160
175
  {
161
 
    assert(index < m_size);
 
176
    DBUG_ASSERT(index < m_size);
162
177
    return m_type[index];
163
178
  }
164
179
 
175
190
    corresponding fields to properly extract the data from the binary log 
176
191
    in the event that the master's field is smaller than the slave.
177
192
  */
178
 
  uint16_t field_metadata(uint32_t index) const
 
193
  uint16 field_metadata(uint index) const
179
194
  {
180
 
    assert(index < m_size);
 
195
    DBUG_ASSERT(index < m_size);
181
196
    if (m_field_metadata_size)
182
197
      return m_field_metadata[index];
183
198
    else
188
203
    This function returns whether the field on the master can be null.
189
204
    This value is derived from field->maybe_null().
190
205
  */
191
 
  bool maybe_null(uint32_t index) const
 
206
  my_bool maybe_null(uint index) const
192
207
  {
193
 
    assert(index < m_size);
 
208
    DBUG_ASSERT(index < m_size);
194
209
    return ((m_null_bits[(index / 8)] & 
195
210
            (1 << (index % 8))) == (1 << (index %8)));
196
211
  }
202
217
    WL#3915) or needs to advance the pointer for the fields in the raw 
203
218
    data from the master to a specific column.
204
219
  */
205
 
  uint32_t calc_field_size(uint32_t col, unsigned char *master_data) const;
 
220
  uint32 calc_field_size(uint col, uchar *master_data) const;
206
221
 
207
222
  /**
208
223
    Decide if the table definition is compatible with a table.
221
236
    @retval 1  if the table definition is not compatible with @c table
222
237
    @retval 0  if the table definition is compatible with @c table
223
238
  */
224
 
  int compatible_with(Relay_log_info const *rli, Table *table) const;
 
239
  int compatible_with(Relay_log_info const *rli, TABLE *table) const;
225
240
 
226
241
private:
227
 
  uint32_t m_size;           // Number of elements in the types array
 
242
  ulong m_size;           // Number of elements in the types array
228
243
  field_type *m_type;                     // Array of type descriptors
229
 
  uint32_t m_field_metadata_size;
230
 
  uint16_t *m_field_metadata;
231
 
  unsigned char *m_null_bits;
232
 
  unsigned char *m_memory;
 
244
  uint m_field_metadata_size;
 
245
  uint16 *m_field_metadata;
 
246
  uchar *m_null_bits;
 
247
  uchar *m_memory;
233
248
};
234
249
 
235
250
/**
236
251
   Extend the normal table list with a few new fields needed by the
237
252
   slave thread, but nowhere else.
238
253
 */
239
 
struct RPL_TableList
240
 
  : public TableList
 
254
struct RPL_TABLE_LIST
 
255
  : public TABLE_LIST
241
256
{
242
257
  bool m_tabledef_valid;
243
258
  table_def m_tabledef;
266
281
    ~auto_afree_ptr() { if (m_ptr) my_afree(m_ptr); }
267
282
    void assign(Obj* ptr) {
268
283
      /* Only to be called if it hasn't been given a value before. */
269
 
      assert(m_ptr == NULL);
 
284
      DBUG_ASSERT(m_ptr == NULL);
270
285
      m_ptr= ptr;
271
286
    }
272
287
    Obj* get() { return m_ptr; }
274
289
 
275
290
}
276
291
 
 
292
/*
 
293
  One test in mysqldump.test has 330 columns!
 
294
  So have a sufficient buffer and check its limit anyway.
 
295
*/
 
296
#define DBUG_PRINT_BITSET(N,FRM,BS)                             \
 
297
  do {                                                          \
 
298
    char buf[MAX_FIELDS+1];                                     \
 
299
    uint i;                                                     \
 
300
    for (i = 0 ; i < (BS)->n_bits && i < MAX_FIELDS ; ++i)      \
 
301
      buf[i] = bitmap_is_set((BS), i) ? '1' : '0';              \
 
302
    buf[i] = '\0';                                              \
 
303
    DBUG_PRINT((N), ((FRM), buf));                              \
 
304
  } while (0)
 
305
 
277
306
#endif /* RPL_UTILITY_H */