← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/unireg.cc

  • Committer: Brian Aker
  • Date: 2008-07-14 16:24:25 UTC
  • Revision ID: brian@tangent.org-20080714162425-juw3vw221gs9kysh
Cleanup around intptr_t

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/unireg.cc
23
23
    str is a (long) to record position where 0 is the first position.
24
24
*/
25
25
 
26
 
#include <drizzled/server_includes.h>
27
 
#include <drizzled/drizzled_error_messages.h>
 
26
#include "mysql_priv.h"
 
27
#include <m_ctype.h>
 
28
#include <assert.h>
28
29
 
29
30
#define FCOMP                   17              /* Bytes for a packed field */
30
31
 
31
 
static unsigned char * pack_screens(List<Create_field> &create_fields,
32
 
                            uint32_t *info_length, uint32_t *screens, bool small_file);
33
 
static uint32_t pack_keys(unsigned char *keybuff,uint32_t key_count, KEY *key_info,
 
32
static uchar * pack_screens(List<Create_field> &create_fields,
 
33
                            uint *info_length, uint *screens, bool small_file);
 
34
static uint pack_keys(uchar *keybuff,uint key_count, KEY *key_info,
34
35
                      ulong data_offset);
35
 
static bool pack_header(unsigned char *forminfo,
 
36
static bool pack_header(uchar *forminfo,enum legacy_db_type table_type,
36
37
                        List<Create_field> &create_fields,
37
 
                        uint32_t info_length, uint32_t screens, uint32_t table_options,
 
38
                        uint info_length, uint screens, uint table_options,
38
39
                        ulong data_offset, handler *file);
39
 
static uint32_t get_interval_id(uint32_t *int_count,List<Create_field> &create_fields,
 
40
static uint get_interval_id(uint *int_count,List<Create_field> &create_fields,
40
41
                            Create_field *last_field);
41
42
static bool pack_fields(File file, List<Create_field> &create_fields,
42
43
                        ulong data_offset);
43
44
static bool make_empty_rec(THD *thd, int file, enum legacy_db_type table_type,
44
 
                           uint32_t table_options,
 
45
                           uint table_options,
45
46
                           List<Create_field> &create_fields,
46
 
                           uint32_t reclength, ulong data_offset,
 
47
                           uint reclength, ulong data_offset,
47
48
                           handler *handler);
48
49
 
49
50
/**
55
56
 
56
57
struct Pack_header_error_handler: public Internal_error_handler
57
58
{
58
 
  virtual bool handle_error(uint32_t sql_errno,
 
59
  virtual bool handle_error(uint sql_errno,
59
60
                            const char *message,
60
 
                            DRIZZLE_ERROR::enum_warning_level level,
 
61
                            MYSQL_ERROR::enum_warning_level level,
61
62
                            THD *thd);
62
63
  bool is_handled;
63
 
  Pack_header_error_handler() :is_handled(false) {}
 
64
  Pack_header_error_handler() :is_handled(FALSE) {}
64
65
};
65
66
 
66
67
 
67
68
bool
68
69
Pack_header_error_handler::
69
 
handle_error(uint32_t sql_errno,
 
70
handle_error(uint sql_errno,
70
71
             const char * /* message */,
71
 
             DRIZZLE_ERROR::enum_warning_level /* level */,
 
72
             MYSQL_ERROR::enum_warning_level /* level */,
72
73
             THD * /* thd */)
73
74
{
74
75
  is_handled= (sql_errno == ER_TOO_MANY_FIELDS);
99
100
                      const char *db, const char *table,
100
101
                      HA_CREATE_INFO *create_info,
101
102
                      List<Create_field> &create_fields,
102
 
                      uint32_t keys, KEY *key_info,
 
103
                      uint keys, KEY *key_info,
103
104
                      handler *db_file)
104
105
{
105
106
  LEX_STRING str_db_type;
106
 
  uint32_t reclength, info_length, screens, key_info_length, maxlength, tmp_len;
 
107
  uint reclength, info_length, screens, key_info_length, maxlength, tmp_len;
107
108
  ulong key_buff_length;
108
109
  File file;
109
110
  ulong filepos, data_offset;
110
 
  unsigned char fileinfo[64],forminfo[288],*keybuff;
 
111
  uchar fileinfo[64],forminfo[288],*keybuff;
111
112
  TYPELIB formnames;
112
 
  unsigned char *screen_buff;
 
113
  uchar *screen_buff;
113
114
  char buff[128];
114
 
  const uint32_t format_section_header_size= 8;
115
 
  uint32_t format_section_len;
 
115
  const uint format_section_header_size= 8;
 
116
  uint format_section_len;
116
117
  Pack_header_error_handler pack_header_error_handler;
117
118
  int error;
118
119
 
129
130
 
130
131
  thd->push_internal_handler(&pack_header_error_handler);
131
132
 
132
 
  error= pack_header(forminfo,
 
133
  error= pack_header(forminfo, ha_legacy_type(create_info->db_type),
133
134
                     create_fields,info_length,
134
135
                     screens, create_info->table_options,
135
136
                     data_offset, db_file);
138
139
 
139
140
  if (error)
140
141
  {
141
 
    free(screen_buff);
 
142
    my_free(screen_buff, MYF(0));
142
143
    if (! pack_header_error_handler.is_handled)
143
144
      return(1);
144
145
 
145
146
    // Try again without UNIREG screens (to get more columns)
146
147
    if (!(screen_buff=pack_screens(create_fields,&info_length,&screens,1)))
147
148
      return(1);
148
 
    if (pack_header(forminfo,
 
149
    if (pack_header(forminfo, ha_legacy_type(create_info->db_type),
149
150
                    create_fields,info_length,
150
151
                    screens, create_info->table_options, data_offset, db_file))
151
152
    {
152
 
      free(screen_buff);
 
153
      my_free(screen_buff, MYF(0));
153
154
      return(1);
154
155
    }
155
156
  }
184
185
  if (tmp_len < create_info->comment.length)
185
186
  {
186
187
    my_error(ER_WRONG_STRING_LENGTH, MYF(0),
187
 
             create_info->comment.str,"Table COMMENT",
 
188
             create_info->comment.str,"TABLE COMMENT",
188
189
             (uint) TABLE_COMMENT_MAXLEN);
189
 
    free(screen_buff);
 
190
    my_free(screen_buff,MYF(0));
190
191
    return(1);
191
192
  }
192
193
 
199
200
  else{
200
201
    strmake((char*) forminfo+47, create_info->comment.str ?
201
202
            create_info->comment.str : "", create_info->comment.length);
202
 
    forminfo[46]=(unsigned char) create_info->comment.length;
 
203
    forminfo[46]=(uchar) create_info->comment.length;
203
204
#ifdef EXTRA_DEBUG
204
205
    /*
205
206
      EXTRA_DEBUG causes strmake() to initialize its buffer behind the
206
207
      payload with a magic value to detect wrong buffer-sizes. We
207
208
      explicitly zero that segment again.
208
209
    */
209
 
    memset(forminfo+47 + forminfo[46], 0, 61 - forminfo[46]);
 
210
    memset((char*) forminfo+47 + forminfo[46], 0, 61 - forminfo[46]);
210
211
#endif
211
212
  }
212
213
 
213
214
  if ((file=create_frm(thd, file_name, db, table, reclength, fileinfo,
214
215
                       create_info, keys, key_info)) < 0)
215
216
  {
216
 
    free(screen_buff);
 
217
    my_free(screen_buff, MYF(0));
217
218
    return(1);
218
219
  }
219
220
 
220
221
  key_buff_length= uint4korr(fileinfo+47);
221
 
  keybuff=(unsigned char*) my_malloc(key_buff_length, MYF(0));
 
222
  keybuff=(uchar*) my_malloc(key_buff_length, MYF(0));
222
223
  key_info_length= pack_keys(keybuff, keys, key_info, data_offset);
223
 
  get_form_pos(file,fileinfo,&formnames);
 
224
  VOID(get_form_pos(file,fileinfo,&formnames));
224
225
  if (!(filepos=make_new_entry(file,fileinfo,&formnames,"")))
225
226
    goto err;
226
227
  maxlength=(uint) next_io_size((ulong) (uint2korr(forminfo)+1000));
227
228
  int2store(forminfo+2,maxlength);
228
229
  int4store(fileinfo+10,(ulong) (filepos+maxlength));
229
 
  fileinfo[26]= (unsigned char) test((create_info->max_rows == 1) &&
 
230
  fileinfo[26]= (uchar) test((create_info->max_rows == 1) &&
230
231
                             (create_info->min_rows == 1) && (keys == 0));
231
232
  int2store(fileinfo+28,key_info_length);
232
233
 
236
237
  if (pwrite(file, fileinfo, 64, 0L) == 0 ||
237
238
      pwrite(file, keybuff, key_info_length, (ulong) uint2korr(fileinfo+6)) == 0)
238
239
    goto err;
239
 
  my_seek(file,
 
240
  VOID(my_seek(file,
240
241
               (ulong) uint2korr(fileinfo+6)+ (ulong) key_buff_length,
241
 
               MY_SEEK_SET,MYF(0));
 
242
               MY_SEEK_SET,MYF(0)));
242
243
  if (make_empty_rec(thd,file,ha_legacy_type(create_info->db_type),
243
244
                     create_info->table_options,
244
245
                     create_fields,reclength, data_offset, db_file))
245
246
    goto err;
246
247
 
247
248
  int2store(buff, create_info->connect_string.length);
248
 
  if (my_write(file, (const unsigned char*)buff, 2, MYF(MY_NABP)) ||
249
 
      my_write(file, (const unsigned char*)create_info->connect_string.str,
 
249
  if (my_write(file, (const uchar*)buff, 2, MYF(MY_NABP)) ||
 
250
      my_write(file, (const uchar*)create_info->connect_string.str,
250
251
               create_info->connect_string.length, MYF(MY_NABP)))
251
252
      goto err;
252
253
 
253
254
  int2store(buff, str_db_type.length);
254
 
  if (my_write(file, (const unsigned char*)buff, 2, MYF(MY_NABP)) ||
255
 
      my_write(file, (const unsigned char*)str_db_type.str,
 
255
  if (my_write(file, (const uchar*)buff, 2, MYF(MY_NABP)) ||
 
256
      my_write(file, (const uchar*)str_db_type.str,
256
257
               str_db_type.length, MYF(MY_NABP)))
257
258
    goto err;
258
259
 
259
260
  {
260
 
    memset(buff, 0, 6);
261
 
    if (my_write(file, (unsigned char*) buff, 6, MYF_RW))
 
261
    bzero((uchar*) buff, 6);
 
262
    if (my_write(file, (uchar*) buff, 6, MYF_RW))
262
263
      goto err;
263
264
  }
264
265
 
265
 
  if (forminfo[46] == (unsigned char)255)
 
266
  if (forminfo[46] == (uchar)255)
266
267
  {
267
 
    unsigned char comment_length_buff[2];
 
268
    uchar comment_length_buff[2];
268
269
    int2store(comment_length_buff,create_info->comment.length);
269
270
    if (my_write(file, comment_length_buff, 2, MYF(MY_NABP)) ||
270
 
        my_write(file, (unsigned char*)create_info->comment.str,
 
271
        my_write(file, (uchar*)create_info->comment.str,
271
272
                  create_info->comment.length, MYF(MY_NABP)))
272
273
      goto err;
273
274
  }
276
277
  {
277
278
    /* prepare header */
278
279
    {
279
 
      uint32_t flags= 0;
 
280
      uint flags= 0;
280
281
 
281
 
      memset(buff, 0, format_section_header_size);
 
282
      bzero(buff, format_section_header_size);
282
283
      /* length of section 2 bytes*/
283
284
      int2store(buff+0, format_section_len);
284
285
      /* flags of section 4 bytes*/
286
287
      /* 2 bytes left for future use */
287
288
    }
288
289
    /* write header */
289
 
    if (my_write(file, (const unsigned char*)buff, format_section_header_size, MYF_RW))
 
290
    if (my_write(file, (const uchar*)buff, format_section_header_size, MYF_RW))
290
291
      goto err;
291
292
    buff[0]= 0;
292
 
    if (my_write(file, (const unsigned char*)buff, 1, MYF_RW))
 
293
    if (my_write(file, (const uchar*)buff, 1, MYF_RW))
293
294
      goto err;
294
295
    /* write column info, 1 byte per column */
295
296
    {
296
297
      List_iterator<Create_field> it(create_fields);
297
298
      Create_field *field;
298
 
      unsigned char column_format, write_byte;
 
299
      uchar column_format, write_byte;
299
300
      while ((field=it++))
300
301
      {
301
 
        column_format= (unsigned char)field->column_format();
 
302
        column_format= (uchar)field->column_format();
302
303
        write_byte= (column_format << COLUMN_FORMAT_SHIFT);
303
304
        if (my_write(file, &write_byte, 1, MYF_RW))
304
305
          goto err;
305
306
      }
306
307
    }
307
308
  }
308
 
  my_seek(file,filepos,MY_SEEK_SET,MYF(0));
 
309
  VOID(my_seek(file,filepos,MY_SEEK_SET,MYF(0)));
309
310
  if (my_write(file, forminfo, 288, MYF_RW) ||
310
311
      my_write(file, screen_buff, info_length, MYF_RW) ||
311
312
      pack_fields(file, create_fields, data_offset))
312
313
    goto err;
313
314
 
314
 
  free(screen_buff);
315
 
  free(keybuff);
 
315
  my_free(screen_buff,MYF(0));
 
316
  my_free(keybuff, MYF(0));
316
317
 
317
 
  if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
 
318
  if (opt_sync_frm && !(create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
318
319
      (my_sync(file, MYF(MY_WME)) ||
319
320
       my_sync_dir_by_file(file_name, MYF(MY_WME))))
320
321
      goto err2;
341
342
  return(0);
342
343
 
343
344
err:
344
 
  free(screen_buff);
345
 
  free(keybuff);
 
345
  my_free(screen_buff, MYF(0));
 
346
  my_free(keybuff, MYF(0));
346
347
err2:
347
 
  my_close(file,MYF(MY_WME));
 
348
  VOID(my_close(file,MYF(MY_WME)));
348
349
err3:
349
350
  my_delete(file_name,MYF(0));
350
351
  return(1);
375
376
                     const char *db, const char *table_name,
376
377
                     HA_CREATE_INFO *create_info,
377
378
                     List<Create_field> &create_fields,
378
 
                     uint32_t keys, KEY *key_info, handler *file)
 
379
                     uint keys, KEY *key_info, handler *file)
379
380
{
380
381
  
381
382
 
382
383
  char frm_name[FN_REFLEN];
383
 
  strxmov(frm_name, path, reg_ext, NULL);
 
384
  strxmov(frm_name, path, reg_ext, NullS);
384
385
  if (mysql_create_frm(thd, frm_name, db, table_name, create_info,
385
386
                       create_fields, keys, key_info, file))
386
387
 
398
399
  return(0);
399
400
 
400
401
err_handler:
401
 
  file->ha_create_handler_files(path, NULL, CHF_DELETE_FLAG, create_info);
 
402
  VOID(file->ha_create_handler_files(path, NULL, CHF_DELETE_FLAG, create_info));
402
403
  my_delete(frm_name, MYF(0));
403
404
  return(1);
404
405
} /* rea_create_table */
406
407
 
407
408
        /* Pack screens to a screen for save in a form-file */
408
409
 
409
 
static unsigned char *pack_screens(List<Create_field> &create_fields,
410
 
                           uint32_t *info_length, uint32_t *screens,
 
410
static uchar *pack_screens(List<Create_field> &create_fields,
 
411
                           uint *info_length, uint *screens,
411
412
                           bool small_file)
412
413
{
413
 
  register uint32_t i;
414
 
  uint32_t row,start_row,end_row,fields_on_screen;
415
 
  uint32_t length,cols;
416
 
  unsigned char *info,*pos,*start_screen;
417
 
  uint32_t fields=create_fields.elements;
 
414
  register uint i;
 
415
  uint row,start_row,end_row,fields_on_screen;
 
416
  uint length,cols;
 
417
  uchar *info,*pos,*start_screen;
 
418
  uint fields=create_fields.elements;
418
419
  List_iterator<Create_field> it(create_fields);
419
420
  
420
421
 
427
428
  while ((field=it++))
428
429
    length+=(uint) strlen(field->field_name)+1+TE_INFO_LENGTH+cols/2;
429
430
 
430
 
  if (!(info=(unsigned char*) my_malloc(length,MYF(MY_WME))))
 
431
  if (!(info=(uchar*) my_malloc(length,MYF(MY_WME))))
431
432
    return(0);
432
433
 
433
434
  start_screen=0;
443
444
      {
444
445
        length=(uint) (pos-start_screen);
445
446
        int2store(start_screen,length);
446
 
        start_screen[2]=(unsigned char) (fields_on_screen+1);
447
 
        start_screen[3]=(unsigned char) (fields_on_screen);
 
447
        start_screen[2]=(uchar) (fields_on_screen+1);
 
448
        start_screen[3]=(uchar) (fields_on_screen);
448
449
      }
449
450
      row=start_row;
450
451
      start_screen=pos;
451
452
      pos+=4;
452
 
      pos[0]= (unsigned char) start_row-2;      /* Header string */
453
 
      pos[1]= (unsigned char) (cols >> 2);
454
 
      pos[2]= (unsigned char) (cols >> 1) +1;
 
453
      pos[0]= (uchar) start_row-2;      /* Header string */
 
454
      pos[1]= (uchar) (cols >> 2);
 
455
      pos[2]= (uchar) (cols >> 1) +1;
455
456
      strfill((char *) pos+3,(uint) (cols >> 1),' ');
456
457
      pos+=(cols >> 1)+4;
457
458
    }
461
462
 
462
463
    if (!small_file)
463
464
    {
464
 
      pos[0]=(unsigned char) row;
 
465
      pos[0]=(uchar) row;
465
466
      pos[1]=0;
466
 
      pos[2]=(unsigned char) (length+1);
467
 
      pos=(unsigned char*) strmake((char*) pos+3,cfield->field_name,length)+1;
 
467
      pos[2]=(uchar) (length+1);
 
468
      pos=(uchar*) strmake((char*) pos+3,cfield->field_name,length)+1;
468
469
    }
469
 
    cfield->row=(uint8_t) row;
470
 
    cfield->col=(uint8_t) (length+1);
471
 
    cfield->sc_length=(uint8_t) cmin(cfield->length,(uint32_t)cols-(length+2));
 
470
    cfield->row=(uint8) row;
 
471
    cfield->col=(uint8) (length+1);
 
472
    cfield->sc_length=(uint8) min(cfield->length,cols-(length+2));
472
473
  }
473
474
  length=(uint) (pos-start_screen);
474
475
  int2store(start_screen,length);
475
 
  start_screen[2]=(unsigned char) (row-start_row+2);
476
 
  start_screen[3]=(unsigned char) (row-start_row+1);
 
476
  start_screen[2]=(uchar) (row-start_row+2);
 
477
  start_screen[3]=(uchar) (row-start_row+1);
477
478
 
478
479
  *info_length=(uint) (pos-info);
479
480
  return(info);
482
483
 
483
484
        /* Pack keyinfo and keynames to keybuff for save in form-file. */
484
485
 
485
 
static uint32_t pack_keys(unsigned char *keybuff, uint32_t key_count, KEY *keyinfo,
 
486
static uint pack_keys(uchar *keybuff, uint key_count, KEY *keyinfo,
486
487
                      ulong data_offset)
487
488
{
488
 
  uint32_t key_parts,length;
489
 
  unsigned char *pos, *keyname_pos;
 
489
  uint key_parts,length;
 
490
  uchar *pos, *keyname_pos;
490
491
  KEY *key,*end;
491
492
  KEY_PART_INFO *key_part,*key_part_end;
492
493
  
497
498
  {
498
499
    int2store(pos, (key->flags ^ HA_NOSAME));
499
500
    int2store(pos+2,key->key_length);
500
 
    pos[4]= (unsigned char) key->key_parts;
501
 
    pos[5]= (unsigned char) key->algorithm;
 
501
    pos[4]= (uchar) key->key_parts;
 
502
    pos[5]= (uchar) key->algorithm;
502
503
    int2store(pos+6, key->block_size);
503
504
    pos+=8;
504
505
    key_parts+=key->key_parts;
507
508
         key_part++)
508
509
 
509
510
    {
510
 
      uint32_t offset;
 
511
      uint offset;
511
512
      int2store(pos,key_part->fieldnr+1+FIELD_NAME_USED);
512
513
      offset= (uint) (key_part->offset+data_offset+1);
513
514
      int2store(pos+2, offset);
519
520
  }
520
521
        /* Save keynames */
521
522
  keyname_pos=pos;
522
 
  *pos++=(unsigned char) NAMES_SEP_CHAR;
 
523
  *pos++=(uchar) NAMES_SEP_CHAR;
523
524
  for (key=keyinfo ; key != end ; key++)
524
525
  {
525
 
    unsigned char *tmp=(unsigned char*) my_stpcpy((char*) pos,key->name);
526
 
    *tmp++= (unsigned char) NAMES_SEP_CHAR;
 
526
    uchar *tmp=(uchar*) strmov((char*) pos,key->name);
 
527
    *tmp++= (uchar) NAMES_SEP_CHAR;
527
528
    *tmp=0;
528
529
    pos=tmp;
529
530
  }
534
535
    if (key->flags & HA_USES_COMMENT)
535
536
    {
536
537
      int2store(pos, key->comment.length);
537
 
      unsigned char *tmp= (unsigned char*)my_stpncpy((char*) pos+2,key->comment.str,key->comment.length);
 
538
      uchar *tmp= (uchar*)strnmov((char*) pos+2,key->comment.str,key->comment.length);
538
539
      pos= tmp;
539
540
    }
540
541
  }
547
548
  }
548
549
  else
549
550
  {
550
 
    keybuff[0]=(unsigned char) key_count;
551
 
    keybuff[1]=(unsigned char) key_parts;
 
551
    keybuff[0]=(uchar) key_count;
 
552
    keybuff[1]=(uchar) key_parts;
552
553
    keybuff[2]= keybuff[3]= 0;
553
554
  }
554
555
  length=(uint) (pos-keyname_pos);
559
560
 
560
561
/* Make formheader */
561
562
 
562
 
static bool pack_header(unsigned char *forminfo,
 
563
static bool pack_header(uchar *forminfo,
 
564
                        enum legacy_db_type table_type __attribute__((__unused__)),
563
565
                        List<Create_field> &create_fields,
564
 
                        uint32_t info_length, uint32_t screens, uint32_t table_options,
 
566
                        uint info_length, uint screens, uint table_options,
565
567
                        ulong data_offset, handler *file)
566
568
{
567
 
  uint32_t length,int_count,int_length,no_empty, int_parts;
568
 
  uint32_t time_stamp_pos,null_fields;
 
569
  uint length,int_count,int_length,no_empty, int_parts;
 
570
  uint time_stamp_pos,null_fields;
569
571
  ulong reclength, totlength, n_length, com_length;
570
572
 
571
573
 
587
589
  Create_field *field;
588
590
  while ((field=it++))
589
591
  {
590
 
    uint32_t tmp_len= system_charset_info->cset->charpos(system_charset_info,
 
592
    uint tmp_len= system_charset_info->cset->charpos(system_charset_info,
591
593
                                                     field->comment.str,
592
594
                                                     field->comment.str +
593
595
                                                     field->comment.length,
614
616
      We mark first TIMESTAMP field with NOW() in DEFAULT or ON UPDATE 
615
617
      as auto-update field.
616
618
    */
617
 
    if (field->sql_type == DRIZZLE_TYPE_TIMESTAMP &&
 
619
    if (field->sql_type == MYSQL_TYPE_TIMESTAMP &&
618
620
        MTYP_TYPENR(field->unireg_check) != Field::NONE &&
619
621
        !time_stamp_pos)
620
622
      time_stamp_pos= (uint) field->offset+ (uint) data_offset + 1;
628
630
    field->save_interval= 0;
629
631
    if (field->interval)
630
632
    {
631
 
      uint32_t old_int_count=int_count;
 
633
      uint old_int_count=int_count;
632
634
 
633
635
      if (field->charset->mbminlen > 1)
634
636
      {
648
650
                                    (field->interval->count+1));
649
651
        field->interval->type_names[field->interval->count]= 0;
650
652
        field->interval->type_lengths=
651
 
          (uint32_t *) sql_alloc(sizeof(uint) * field->interval->count);
 
653
          (uint *) sql_alloc(sizeof(uint) * field->interval->count);
652
654
 
653
 
        for (uint32_t pos= 0; pos < field->interval->count; pos++)
 
655
        for (uint pos= 0; pos < field->interval->count; pos++)
654
656
        {
655
657
          char *dst;
656
658
          const char *src= field->save_interval->type_names[pos];
657
 
          uint32_t hex_length;
 
659
          uint hex_length;
658
660
          length= field->save_interval->type_lengths[pos];
659
661
          hex_length= length * 2;
660
662
          field->interval->type_lengths[pos]= hex_length;
685
687
    return(1);
686
688
  }
687
689
  /* Hack to avoid bugs with small static rows in MySQL */
688
 
  reclength=cmax((ulong)file->min_record_length(table_options),reclength);
 
690
  reclength=max(file->min_record_length(table_options),reclength);
689
691
  if (info_length+(ulong) create_fields.elements*FCOMP+288+
690
692
      n_length+int_length+com_length > 65535L || int_count > 255)
691
693
  {
693
695
    return(1);
694
696
  }
695
697
 
696
 
  memset(forminfo, 0, 288);
 
698
  bzero((char*)forminfo,288);
697
699
  length=(info_length+create_fields.elements*FCOMP+288+n_length+int_length+
698
700
          com_length);
699
701
  int2store(forminfo,length);
700
 
  forminfo[256] = (uint8_t) screens;
 
702
  forminfo[256] = (uint8) screens;
701
703
  int2store(forminfo+258,create_fields.elements);
702
704
  int2store(forminfo+260,info_length);
703
705
  int2store(forminfo+262,totlength);
719
721
 
720
722
        /* get each unique interval each own id */
721
723
 
722
 
static uint32_t get_interval_id(uint32_t *int_count,List<Create_field> &create_fields,
 
724
static uint get_interval_id(uint *int_count,List<Create_field> &create_fields,
723
725
                            Create_field *last_field)
724
726
{
725
727
  List_iterator<Create_field> it(create_fields);
750
752
static bool pack_fields(File file, List<Create_field> &create_fields,
751
753
                        ulong data_offset)
752
754
{
753
 
  register uint32_t i;
754
 
  uint32_t int_count, comment_length=0;
755
 
  unsigned char buff[MAX_FIELD_WIDTH];
 
755
  register uint i;
 
756
  uint int_count, comment_length=0;
 
757
  uchar buff[MAX_FIELD_WIDTH];
756
758
  Create_field *field;
757
759
  
758
760
 
763
765
  int_count=0;
764
766
  while ((field=it++))
765
767
  {
766
 
    uint32_t recpos;
767
 
    buff[0]= (unsigned char) field->row;
768
 
    buff[1]= (unsigned char) field->col;
769
 
    buff[2]= (unsigned char) field->sc_length;
 
768
    uint recpos;
 
769
    buff[0]= (uchar) field->row;
 
770
    buff[1]= (uchar) field->col;
 
771
    buff[2]= (uchar) field->sc_length;
770
772
    int2store(buff+3, field->length);
771
773
    /* The +1 is here becasue the col offset in .frm file have offset 1 */
772
774
    recpos= field->offset+1 + (uint) data_offset;
773
775
    int3store(buff+5,recpos);
774
776
    int2store(buff+8,field->pack_flag);
775
777
    int2store(buff+10,field->unireg_check);
776
 
    buff[12]= (unsigned char) field->interval_id;
777
 
    buff[13]= (unsigned char) field->sql_type; 
 
778
    buff[12]= (uchar) field->interval_id;
 
779
    buff[13]= (uchar) field->sql_type; 
778
780
    if (field->charset) 
779
 
      buff[14]= (unsigned char) field->charset->number;
 
781
      buff[14]= (uchar) field->charset->number;
780
782
    else
781
783
      buff[14]= 0;                              // Numerical
782
784
    int2store(buff+15, field->comment.length);
787
789
  }
788
790
 
789
791
        /* Write fieldnames */
790
 
  buff[0]=(unsigned char) NAMES_SEP_CHAR;
 
792
  buff[0]=(uchar) NAMES_SEP_CHAR;
791
793
  if (my_write(file, buff, 1, MYF_RW))
792
794
    return(1);
793
795
  i=0;
794
796
  it.rewind();
795
797
  while ((field=it++))
796
798
  {
797
 
    char *pos= my_stpcpy((char*) buff,field->field_name);
 
799
    char *pos= strmov((char*) buff,field->field_name);
798
800
    *pos++=NAMES_SEP_CHAR;
799
801
    if (i == create_fields.elements-1)
800
802
      *pos++=0;
816
818
      {
817
819
        unsigned char  sep= 0;
818
820
        unsigned char  occ[256];
819
 
        uint32_t           i;
 
821
        uint           i;
820
822
        unsigned char *val= NULL;
821
823
 
822
 
        memset(occ, 0, sizeof(occ));
 
824
        bzero(occ, sizeof(occ));
823
825
 
824
826
        for (i=0; (val= (unsigned char*) field->interval->type_names[i]); i++)
825
 
          for (uint32_t j = 0; j < field->interval->type_lengths[i]; j++)
 
827
          for (uint j = 0; j < field->interval->type_lengths[i]; j++)
826
828
            occ[(unsigned int) (val[j])]= 1;
827
829
 
828
830
        if (!occ[(unsigned char)NAMES_SEP_CHAR])
831
833
          sep= ',';
832
834
        else
833
835
        {
834
 
          for (uint32_t i=1; i<256; i++)
 
836
          for (uint i=1; i<256; i++)
835
837
          {
836
838
            if(!occ[i])
837
839
            {
858
860
        tmp.append('\0');                      // End of intervall
859
861
      }
860
862
    }
861
 
    if (my_write(file,(unsigned char*) tmp.ptr(),tmp.length(),MYF_RW))
 
863
    if (my_write(file,(uchar*) tmp.ptr(),tmp.length(),MYF_RW))
862
864
      return(1);
863
865
  }
864
866
  if (comment_length)
868
870
    while ((field=it++))
869
871
    {
870
872
      if (field->comment.length)
871
 
        if (my_write(file, (unsigned char*) field->comment.str, field->comment.length,
 
873
        if (my_write(file, (uchar*) field->comment.str, field->comment.length,
872
874
                     MYF_RW))
873
875
          return(1);
874
876
    }
880
882
/* save an empty record on start of formfile */
881
883
 
882
884
static bool make_empty_rec(THD *thd, File file,
883
 
                           enum legacy_db_type table_type __attribute__((unused)),
884
 
                           uint32_t table_options,
 
885
                           enum legacy_db_type table_type __attribute__((__unused__)),
 
886
                           uint table_options,
885
887
                           List<Create_field> &create_fields,
886
 
                           uint32_t reclength,
 
888
                           uint reclength,
887
889
                           ulong data_offset,
888
890
                           handler *handler)
889
891
{
890
892
  int error= 0;
891
893
  Field::utype type;
892
 
  uint32_t null_count;
893
 
  unsigned char *buff,*null_pos;
894
 
  Table table;
 
894
  uint null_count;
 
895
  uchar *buff,*null_pos;
 
896
  TABLE table;
895
897
  TABLE_SHARE share;
896
898
  Create_field *field;
897
899
  enum_check_fields old_count_cuted_fields= thd->count_cuted_fields;
898
900
  
899
901
 
900
902
  /* We need a table to generate columns for default values */
901
 
  memset(&table, 0, sizeof(table));
902
 
  memset(&share, 0, sizeof(share));
 
903
  bzero((char*) &table, sizeof(table));
 
904
  bzero((char*) &share, sizeof(share));
903
905
  table.s= &share;
904
906
 
905
 
  if (!(buff=(unsigned char*) my_malloc((size_t) reclength,MYF(MY_WME | MY_ZEROFILL))))
 
907
  if (!(buff=(uchar*) my_malloc((size_t) reclength,MYF(MY_WME | MY_ZEROFILL))))
906
908
  {
907
909
    return(1);
908
910
  }
967
969
        goto err;
968
970
      }
969
971
    }
970
 
    else if (regfield->real_type() == DRIZZLE_TYPE_ENUM &&
 
972
    else if (regfield->real_type() == MYSQL_TYPE_ENUM &&
971
973
             (field->flags & NOT_NULL_FLAG))
972
974
    {
973
975
      regfield->set_notnull();
974
 
      regfield->store((int64_t) 1, true);
 
976
      regfield->store((int64_t) 1, TRUE);
975
977
    }
976
978
    else if (type == Field::YES)                // Old unireg type
977
979
      regfield->store(ER(ER_YES),(uint) strlen(ER(ER_YES)),system_charset_info);
987
989
    of 8 there are no unused bits.
988
990
  */
989
991
  if (null_count & 7)
990
 
    *(null_pos + null_count / 8)|= ~(((unsigned char) 1 << (null_count & 7)) - 1);
 
992
    *(null_pos + null_count / 8)|= ~(((uchar) 1 << (null_count & 7)) - 1);
991
993
 
992
994
  error= my_write(file, buff, (size_t) reclength,MYF_RW) != 0;
993
995
 
994
996
err:
995
 
  free(buff);
 
997
  my_free(buff, MYF(MY_FAE));
996
998
  thd->count_cuted_fields= old_count_cuted_fields;
997
999
  return(error);
998
1000
} /* make_empty_rec */