← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/rpl_utility.h

Merging mainline

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/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_BLOB:
 
93
        case MYSQL_TYPE_DOUBLE:
 
94
        case MYSQL_TYPE_FLOAT:
94
95
        {
95
96
          /*
96
97
            These types store a single byte.
99
100
          index++;
100
101
          break;
101
102
        }
102
 
        case DRIZZLE_TYPE_ENUM:
 
103
        case MYSQL_TYPE_SET:
 
104
        case MYSQL_TYPE_ENUM:
 
105
        case MYSQL_TYPE_STRING:
103
106
        {
104
 
          uint16_t x= field_metadata[index++] << 8U; // real_type
 
107
          uint16 x= field_metadata[index++] << 8U; // real_type
105
108
          x+= field_metadata[index++];            // pack or field length
106
109
          m_field_metadata[i]= x;
107
110
          break;
108
111
        }
109
 
        case DRIZZLE_TYPE_VARCHAR:
 
112
        case MYSQL_TYPE_VARCHAR:
110
113
        {
111
114
          /*
112
115
            These types store two bytes.
116
119
          index= index + 2;
117
120
          break;
118
121
        }
119
 
        case DRIZZLE_TYPE_NEWDECIMAL:
 
122
        case MYSQL_TYPE_NEWDECIMAL:
120
123
        {
121
 
          uint16_t x= field_metadata[index++] << 8U; // precision
 
124
          uint16 x= field_metadata[index++] << 8U; // precision
122
125
          x+= field_metadata[index++];            // decimals
123
126
          m_field_metadata[i]= x;
124
127
          break;
134
137
  }
135
138
 
136
139
  ~table_def() {
137
 
    free(m_memory);
 
140
    my_free(m_memory, MYF(0));
138
141
    m_type= 0;
139
142
    m_size= 0;
140
143
  }
144
147
 
145
148
    @return The number of fields that there is type data for.
146
149
   */
147
 
  uint32_t size() const { return m_size; }
 
150
  ulong size() const { return m_size; }
148
151
 
149
152
 
150
153
  /*
156
159
    <code>index</code>. Currently, only the type identifier is
157
160
    returned.
158
161
   */
159
 
  field_type type(uint32_t index) const
 
162
  field_type type(ulong index) const
160
163
  {
161
164
    assert(index < m_size);
162
165
    return m_type[index];
175
178
    corresponding fields to properly extract the data from the binary log 
176
179
    in the event that the master's field is smaller than the slave.
177
180
  */
178
 
  uint16_t field_metadata(uint32_t index) const
 
181
  uint16 field_metadata(uint index) const
179
182
  {
180
183
    assert(index < m_size);
181
184
    if (m_field_metadata_size)
188
191
    This function returns whether the field on the master can be null.
189
192
    This value is derived from field->maybe_null().
190
193
  */
191
 
  bool maybe_null(uint32_t index) const
 
194
  my_bool maybe_null(uint index) const
192
195
  {
193
196
    assert(index < m_size);
194
197
    return ((m_null_bits[(index / 8)] & 
202
205
    WL#3915) or needs to advance the pointer for the fields in the raw 
203
206
    data from the master to a specific column.
204
207
  */
205
 
  uint32_t calc_field_size(uint32_t col, unsigned char *master_data) const;
 
208
  uint32 calc_field_size(uint col, uchar *master_data) const;
206
209
 
207
210
  /**
208
211
    Decide if the table definition is compatible with a table.
221
224
    @retval 1  if the table definition is not compatible with @c table
222
225
    @retval 0  if the table definition is compatible with @c table
223
226
  */
224
 
  int compatible_with(Relay_log_info const *rli, Table *table) const;
 
227
  int compatible_with(Relay_log_info const *rli, TABLE *table) const;
225
228
 
226
229
private:
227
 
  uint32_t m_size;           // Number of elements in the types array
 
230
  ulong m_size;           // Number of elements in the types array
228
231
  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;
 
232
  uint m_field_metadata_size;
 
233
  uint16 *m_field_metadata;
 
234
  uchar *m_null_bits;
 
235
  uchar *m_memory;
233
236
};
234
237
 
235
238
/**
236
239
   Extend the normal table list with a few new fields needed by the
237
240
   slave thread, but nowhere else.
238
241
 */
239
 
struct RPL_TableList
240
 
  : public TableList
 
242
struct RPL_TABLE_LIST
 
243
  : public TABLE_LIST
241
244
{
242
245
  bool m_tabledef_valid;
243
246
  table_def m_tabledef;