← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/rpl_utility.h

Merged from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/rpl_utility.h
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, ulong size, uchar *field_metadata, 
62
 
      int metadata_size, uchar *null_bitmap)
 
61
  table_def(field_type *types, uint32_t size, unsigned char *field_metadata, 
 
62
      int metadata_size, unsigned char *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= (uchar *)my_multi_malloc(MYF(MY_WME),
 
66
    m_memory= (unsigned char *)my_multi_malloc(MYF(MY_WME),
67
67
                                       &m_type, size,
68
68
                                       &m_field_metadata,
69
 
                                       size * sizeof(uint16),
 
69
                                       size * sizeof(uint16_t),
70
70
                                       &m_null_bits, (size + 7) / 8,
71
71
                                       NULL);
72
72
 
73
 
    bzero(m_field_metadata, size * sizeof(uint16));
 
73
    bzero(m_field_metadata, size * sizeof(uint16_t));
74
74
 
75
75
    if (m_type)
76
76
      memcpy(m_type, types, size);
104
104
        case MYSQL_TYPE_ENUM:
105
105
        case MYSQL_TYPE_STRING:
106
106
        {
107
 
          uint16 x= field_metadata[index++] << 8U; // real_type
 
107
          uint16_t x= field_metadata[index++] << 8U; // real_type
108
108
          x+= field_metadata[index++];            // pack or field length
109
109
          m_field_metadata[i]= x;
110
110
          break;
121
121
        }
122
122
        case MYSQL_TYPE_NEWDECIMAL:
123
123
        {
124
 
          uint16 x= field_metadata[index++] << 8U; // precision
 
124
          uint16_t x= field_metadata[index++] << 8U; // precision
125
125
          x+= field_metadata[index++];            // decimals
126
126
          m_field_metadata[i]= x;
127
127
          break;
138
138
 
139
139
  ~table_def() {
140
140
    my_free(m_memory, MYF(0));
141
 
#ifndef DBUG_OFF
142
141
    m_type= 0;
143
142
    m_size= 0;
144
 
#endif
145
143
  }
146
144
 
147
145
  /**
149
147
 
150
148
    @return The number of fields that there is type data for.
151
149
   */
152
 
  ulong size() const { return m_size; }
 
150
  uint32_t size() const { return m_size; }
153
151
 
154
152
 
155
153
  /*
161
159
    <code>index</code>. Currently, only the type identifier is
162
160
    returned.
163
161
   */
164
 
  field_type type(ulong index) const
 
162
  field_type type(uint32_t index) const
165
163
  {
166
 
    DBUG_ASSERT(index < m_size);
 
164
    assert(index < m_size);
167
165
    return m_type[index];
168
166
  }
169
167
 
180
178
    corresponding fields to properly extract the data from the binary log 
181
179
    in the event that the master's field is smaller than the slave.
182
180
  */
183
 
  uint16 field_metadata(uint index) const
 
181
  uint16_t field_metadata(uint32_t index) const
184
182
  {
185
 
    DBUG_ASSERT(index < m_size);
 
183
    assert(index < m_size);
186
184
    if (m_field_metadata_size)
187
185
      return m_field_metadata[index];
188
186
    else
193
191
    This function returns whether the field on the master can be null.
194
192
    This value is derived from field->maybe_null().
195
193
  */
196
 
  my_bool maybe_null(uint index) const
 
194
  my_bool maybe_null(uint32_t index) const
197
195
  {
198
 
    DBUG_ASSERT(index < m_size);
 
196
    assert(index < m_size);
199
197
    return ((m_null_bits[(index / 8)] & 
200
198
            (1 << (index % 8))) == (1 << (index %8)));
201
199
  }
207
205
    WL#3915) or needs to advance the pointer for the fields in the raw 
208
206
    data from the master to a specific column.
209
207
  */
210
 
  uint32 calc_field_size(uint col, uchar *master_data) const;
 
208
  uint32 calc_field_size(uint32_t col, unsigned char *master_data) const;
211
209
 
212
210
  /**
213
211
    Decide if the table definition is compatible with a table.
229
227
  int compatible_with(Relay_log_info const *rli, TABLE *table) const;
230
228
 
231
229
private:
232
 
  ulong m_size;           // Number of elements in the types array
 
230
  uint32_t m_size;           // Number of elements in the types array
233
231
  field_type *m_type;                     // Array of type descriptors
234
 
  uint m_field_metadata_size;
235
 
  uint16 *m_field_metadata;
236
 
  uchar *m_null_bits;
237
 
  uchar *m_memory;
 
232
  uint32_t m_field_metadata_size;
 
233
  uint16_t *m_field_metadata;
 
234
  unsigned char *m_null_bits;
 
235
  unsigned char *m_memory;
238
236
};
239
237
 
240
238
/**
271
269
    ~auto_afree_ptr() { if (m_ptr) my_afree(m_ptr); }
272
270
    void assign(Obj* ptr) {
273
271
      /* Only to be called if it hasn't been given a value before. */
274
 
      DBUG_ASSERT(m_ptr == NULL);
 
272
      assert(m_ptr == NULL);
275
273
      m_ptr= ptr;
276
274
    }
277
275
    Obj* get() { return m_ptr; }
279
277
 
280
278
}
281
279
 
282
 
/*
283
 
  One test in mysqldump.test has 330 columns!
284
 
  So have a sufficient buffer and check its limit anyway.
285
 
*/
286
 
#define DBUG_PRINT_BITSET(N,FRM,BS)                             \
287
 
  do {                                                          \
288
 
    char buf[MAX_FIELDS+1];                                     \
289
 
    uint i;                                                     \
290
 
    for (i = 0 ; i < (BS)->n_bits && i < MAX_FIELDS ; ++i)      \
291
 
      buf[i] = bitmap_is_set((BS), i) ? '1' : '0';              \
292
 
    buf[i] = '\0';                                              \
293
 
    DBUG_PRINT((N), ((FRM), buf));                              \
294
 
  } while (0)
295
 
 
296
280
#endif /* RPL_UTILITY_H */