← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/rpl_record.cc

Merged from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/rpl_record.cc
65
65
  my_ptrdiff_t const rec_offset= record - table->record[0];
66
66
  my_ptrdiff_t const def_offset= table->s->default_values - table->record[0];
67
67
 
68
 
  DBUG_ENTER("pack_row");
69
68
 
70
69
  /*
71
70
    We write the null bits and the packed records using one pass
75
74
  unsigned int null_bits= (1U << 8) - 1;
76
75
  // Mask to mask out the correct but among the null bits
77
76
  unsigned int null_mask= 1U;
78
 
  DBUG_PRINT("debug", ("null ptr: 0x%lx; row start: %p; null bytes: %d",
79
 
                       (ulong) null_ptr, row_data, null_byte_count));
80
 
  DBUG_PRINT_BITSET("debug", "cols: %s", cols);
81
77
  for ( ; (field= *p_field) ; p_field++)
82
78
  {
83
 
    DBUG_PRINT("debug", ("field: %s; null mask: 0x%x",
84
 
                         field->field_name, null_mask));
85
79
    if (bitmap_is_set(cols, p_field - table->field))
86
80
    {
87
81
      my_ptrdiff_t offset;
88
82
      if (field->is_null(rec_offset))
89
83
      {
90
 
        DBUG_PRINT("debug", ("Is NULL; null_mask: 0x%x; null_bits: 0x%x",
91
 
                             null_mask, null_bits));
92
84
        offset= def_offset;
93
85
        null_bits |= null_mask;
94
86
      }
109
101
#endif
110
102
        pack_ptr= field->pack(pack_ptr, field->ptr + offset,
111
103
                              field->max_data_length(), TRUE);
112
 
        DBUG_PRINT("debug", ("Packed into row; pack_ptr: 0x%lx;"
113
 
                             " pack_ptr':0x%lx; bytes: %d",
114
 
                             (ulong) old_pack_ptr,
115
 
                             (ulong) pack_ptr,
116
 
                             (int) (pack_ptr - old_pack_ptr)));
117
104
      }
118
105
 
119
106
      null_mask <<= 1;
125
112
        null_bits= (1U << 8) - 1;
126
113
      }
127
114
    }
128
 
#ifndef DBUG_OFF
129
 
    else
130
 
    {
131
 
      DBUG_PRINT("debug", ("Skipped"));
132
 
    }
133
 
#endif
134
115
  }
135
116
 
136
117
  /*
148
129
  */
149
130
  DBUG_ASSERT(null_ptr == row_data + null_byte_count);
150
131
  DBUG_DUMP("row_data", row_data, pack_ptr - row_data);
151
 
  DBUG_RETURN(static_cast<size_t>(pack_ptr - row_data));
 
132
  return(static_cast<size_t>(pack_ptr - row_data));
152
133
}
153
134
#endif
154
135
 
193
174
           uchar const *const row_data, MY_BITMAP const *cols,
194
175
           uchar const **const row_end, ulong *const master_reclength)
195
176
{
196
 
  DBUG_ENTER("unpack_row");
197
177
  DBUG_ASSERT(row_data);
198
178
  size_t const master_null_byte_count= (bitmap_bits_set(cols) + 7) / 8;
199
179
  int error= 0;
224
204
  {
225
205
    Field *const f= *field_ptr;
226
206
 
227
 
    DBUG_PRINT("debug", ("%sfield: %s; null mask: 0x%x; null bits: 0x%lx;"
228
 
                         " row start: %p; null bytes: %ld",
229
 
                         bitmap_is_set(cols, field_ptr -  begin_ptr) ? "+" : "-",
230
 
                         f->field_name, null_mask, (ulong) null_bits,
231
 
                         pack_ptr, (ulong) master_null_byte_count));
232
207
 
233
208
    /*
234
209
      No need to bother about columns that does not exist: they have
250
225
 
251
226
      if ((null_bits & null_mask) && f->maybe_null())
252
227
      {
253
 
        DBUG_PRINT("debug", ("Was NULL; null mask: 0x%x; null bits: 0x%x",
254
 
                             null_mask, null_bits));
255
 
 
256
228
        f->set_null();
257
229
      }
258
230
      else
274
246
        uchar const *const old_pack_ptr= pack_ptr;
275
247
#endif
276
248
        pack_ptr= f->unpack(f->ptr, pack_ptr, metadata, TRUE);
277
 
        DBUG_PRINT("debug", ("Unpacked; metadata: 0x%x;"
278
 
                             " pack_ptr: 0x%lx; pack_ptr': 0x%lx; bytes: %d",
279
 
                             metadata, (ulong) old_pack_ptr, (ulong) pack_ptr,
280
 
                             (int) (pack_ptr - old_pack_ptr)));
281
249
      }
282
250
 
283
251
      null_mask <<= 1;
284
252
    }
285
 
#ifndef DBUG_OFF
286
 
    else
287
 
    {
288
 
      DBUG_PRINT("debug", ("Non-existent: skipped"));
289
 
    }
290
 
#endif
291
253
    i++;
292
254
  }
293
255
 
334
296
      *master_reclength = table->s->reclength;
335
297
  }
336
298
  
337
 
  DBUG_RETURN(error);
 
299
  return(error);
338
300
}
339
301
 
340
302
/**
368
330
int prepare_record(TABLE *const table, 
369
331
                   const MY_BITMAP *cols, uint width, const bool check)
370
332
{
371
 
  DBUG_ENTER("prepare_record");
372
333
 
373
334
  int error= 0;
374
335
  empty_record(table);
380
341
    have no sensible default.
381
342
  */
382
343
 
383
 
  DBUG_PRINT_BITSET("debug", "cols: %s", cols);
384
344
  for (Field **field_ptr= table->field ; *field_ptr ; ++field_ptr)
385
345
  {
386
346
    if ((uint) (field_ptr - table->field) >= cols->n_bits ||
396
356
      }
397
357
      else
398
358
      {
399
 
        DBUG_PRINT("debug", ("Set default; field: %s", f->field_name));
400
359
        f->set_default();
401
360
      }
402
361
    }
403
362
  }
404
363
 
405
 
  DBUG_RETURN(error);
 
364
  return(error);
406
365
}
407
366
 
408
367
#endif // HAVE_REPLICATION