← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/unireg.cc

Resolving conflicts for a few files regarding FALSE=>false

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/unireg.cc
117
117
  uint tablespace_len= 0;
118
118
  Pack_header_error_handler pack_header_error_handler;
119
119
  int error;
120
 
  DBUG_ENTER("mysql_create_frm");
121
120
 
122
 
  DBUG_ASSERT(*fn_rext((char*)file_name)); // Check .frm extension
 
121
  assert(*fn_rext((char*)file_name)); // Check .frm extension
123
122
  formnames.type_names=0;
124
123
  if (!(screen_buff=pack_screens(create_fields,&info_length,&screens,0)))
125
 
    DBUG_RETURN(1);
126
 
  DBUG_ASSERT(db_file != NULL);
 
124
    return(1);
 
125
  assert(db_file != NULL);
127
126
 
128
127
 /* If fixed row records, we need one bit to check for deleted rows */
129
128
  if (!(create_info->table_options & HA_OPTION_PACK_RECORD))
143
142
  {
144
143
    my_free(screen_buff, MYF(0));
145
144
    if (! pack_header_error_handler.is_handled)
146
 
      DBUG_RETURN(1);
 
145
      return(1);
147
146
 
148
147
    // Try again without UNIREG screens (to get more columns)
149
148
    if (!(screen_buff=pack_screens(create_fields,&info_length,&screens,1)))
150
 
      DBUG_RETURN(1);
 
149
      return(1);
151
150
    if (pack_header(forminfo, ha_legacy_type(create_info->db_type),
152
151
                    create_fields,info_length,
153
152
                    screens, create_info->table_options, data_offset, db_file))
154
153
    {
155
154
      my_free(screen_buff, MYF(0));
156
 
      DBUG_RETURN(1);
 
155
      return(1);
157
156
    }
158
157
  }
159
158
  reclength=uint2korr(forminfo+266);
194
193
             create_info->comment.str,"TABLE COMMENT",
195
194
             (uint) TABLE_COMMENT_MAXLEN);
196
195
    my_free(screen_buff,MYF(0));
197
 
    DBUG_RETURN(1);
 
196
    return(1);
198
197
  }
199
198
 
200
199
  //if table comment is larger than 180 bytes, store into extra segment.
221
220
                       create_info, keys, key_info)) < 0)
222
221
  {
223
222
    my_free(screen_buff, MYF(0));
224
 
    DBUG_RETURN(1);
 
223
    return(1);
225
224
  }
226
225
 
227
226
  key_buff_length= uint4korr(fileinfo+47);
351
350
      }
352
351
    }
353
352
  }
354
 
  DBUG_RETURN(0);
 
353
  return(0);
355
354
 
356
355
err:
357
356
  my_free(screen_buff, MYF(0));
360
359
  VOID(my_close(file,MYF(MY_WME)));
361
360
err3:
362
361
  my_delete(file_name,MYF(0));
363
 
  DBUG_RETURN(1);
 
362
  return(1);
364
363
} /* mysql_create_frm */
365
364
 
366
365
 
390
389
                     List<Create_field> &create_fields,
391
390
                     uint keys, KEY *key_info, handler *file)
392
391
{
393
 
  DBUG_ENTER("rea_create_table");
 
392
  
394
393
 
395
394
  char frm_name[FN_REFLEN];
396
395
  strxmov(frm_name, path, reg_ext, NullS);
397
396
  if (mysql_create_frm(thd, frm_name, db, table_name, create_info,
398
397
                       create_fields, keys, key_info, file))
399
398
 
400
 
    DBUG_RETURN(1);
 
399
    return(1);
401
400
 
402
401
  // Make sure mysql_create_frm din't remove extension
403
 
  DBUG_ASSERT(*fn_rext(frm_name));
 
402
  assert(*fn_rext(frm_name));
404
403
  if (thd->variables.keep_files_on_create)
405
404
    create_info->options|= HA_CREATE_KEEP_FILES;
406
405
  if (file->ha_create_handler_files(path, NULL, CHF_CREATE_FLAG, create_info))
408
407
  if (!create_info->frm_only && ha_create_table(thd, path, db, table_name,
409
408
                                                create_info,0))
410
409
    goto err_handler;
411
 
  DBUG_RETURN(0);
 
410
  return(0);
412
411
 
413
412
err_handler:
414
413
  VOID(file->ha_create_handler_files(path, NULL, CHF_DELETE_FLAG, create_info));
415
414
  my_delete(frm_name, MYF(0));
416
 
  DBUG_RETURN(1);
 
415
  return(1);
417
416
} /* rea_create_table */
418
417
 
419
418
 
429
428
  uchar *info,*pos,*start_screen;
430
429
  uint fields=create_fields.elements;
431
430
  List_iterator<Create_field> it(create_fields);
432
 
  DBUG_ENTER("pack_screens");
 
431
  
433
432
 
434
433
  start_row=4; end_row=22; cols=80; fields_on_screen=end_row+1-start_row;
435
434
 
441
440
    length+=(uint) strlen(field->field_name)+1+TE_INFO_LENGTH+cols/2;
442
441
 
443
442
  if (!(info=(uchar*) my_malloc(length,MYF(MY_WME))))
444
 
    DBUG_RETURN(0);
 
443
    return(0);
445
444
 
446
445
  start_screen=0;
447
446
  row=end_row;
489
488
  start_screen[3]=(uchar) (row-start_row+1);
490
489
 
491
490
  *info_length=(uint) (pos-info);
492
 
  DBUG_RETURN(info);
 
491
  return(info);
493
492
} /* pack_screens */
494
493
 
495
494
 
502
501
  uchar *pos, *keyname_pos;
503
502
  KEY *key,*end;
504
503
  KEY_PART_INFO *key_part,*key_part_end;
505
 
  DBUG_ENTER("pack_keys");
 
504
  
506
505
 
507
506
  pos=keybuff+6;
508
507
  key_parts=0;
566
565
  }
567
566
  length=(uint) (pos-keyname_pos);
568
567
  int2store(keybuff+4,length);
569
 
  DBUG_RETURN((uint) (pos-keybuff));
 
568
  return((uint) (pos-keybuff));
570
569
} /* pack_keys */
571
570
 
572
571
 
580
579
  uint length,int_count,int_length,no_empty, int_parts;
581
580
  uint time_stamp_pos,null_fields;
582
581
  ulong reclength, totlength, n_length, com_length;
583
 
  DBUG_ENTER("pack_header");
 
582
  
584
583
 
585
584
  if (create_fields.elements > MAX_FIELDS)
586
585
  {
587
586
    my_message(ER_TOO_MANY_FIELDS, ER(ER_TOO_MANY_FIELDS), MYF(0));
588
 
    DBUG_RETURN(1);
 
587
    return(1);
589
588
  }
590
589
 
591
590
  totlength= 0L;
611
610
      my_error(ER_WRONG_STRING_LENGTH, MYF(0),
612
611
               field->comment.str,"COLUMN COMMENT",
613
612
               (uint) COLUMN_COMMENT_MAXLEN);
614
 
      DBUG_RETURN(1);
 
613
      return(1);
615
614
    }
616
615
 
617
616
    totlength+= field->length;
633
632
      time_stamp_pos= (uint) field->offset+ (uint) data_offset + 1;
634
633
    length=field->pack_length;
635
634
    /* Ensure we don't have any bugs when generating offsets */
636
 
    DBUG_ASSERT(reclength == field->offset + data_offset);
 
635
    assert(reclength == field->offset + data_offset);
637
636
    if ((uint) field->offset+ (uint) data_offset+ length > reclength)
638
637
      reclength=(uint) (field->offset+ data_offset + length);
639
638
    n_length+= (ulong) strlen(field->field_name)+1;
695
694
  if (reclength > (ulong) file->max_record_length())
696
695
  {
697
696
    my_error(ER_TOO_BIG_ROWSIZE, MYF(0), (uint) file->max_record_length());
698
 
    DBUG_RETURN(1);
 
697
    return(1);
699
698
  }
700
699
  /* Hack to avoid bugs with small static rows in MySQL */
701
700
  reclength=max(file->min_record_length(table_options),reclength);
703
702
      n_length+int_length+com_length > 65535L || int_count > 255)
704
703
  {
705
704
    my_message(ER_TOO_MANY_FIELDS, ER(ER_TOO_MANY_FIELDS), MYF(0));
706
 
    DBUG_RETURN(1);
 
705
    return(1);
707
706
  }
708
707
 
709
708
  bzero((char*)forminfo,288);
726
725
  int2store(forminfo+282,null_fields);
727
726
  int2store(forminfo+284,com_length);
728
727
  /* Up to forminfo+288 is free to use for additional information */
729
 
  DBUG_RETURN(0);
 
728
  return(0);
730
729
} /* pack_header */
731
730
 
732
731
 
767
766
  uint int_count, comment_length=0;
768
767
  uchar buff[MAX_FIELD_WIDTH];
769
768
  Create_field *field;
770
 
  DBUG_ENTER("pack_fields");
 
769
  
771
770
 
772
771
        /* Write field info */
773
772
 
796
795
    comment_length+= field->comment.length;
797
796
    set_if_bigger(int_count,field->interval_id);
798
797
    if (my_write(file, buff, FCOMP, MYF_RW))
799
 
      DBUG_RETURN(1);
 
798
      return(1);
800
799
  }
801
800
 
802
801
        /* Write fieldnames */
803
802
  buff[0]=(uchar) NAMES_SEP_CHAR;
804
803
  if (my_write(file, buff, 1, MYF_RW))
805
 
    DBUG_RETURN(1);
 
804
    return(1);
806
805
  i=0;
807
806
  it.rewind();
808
807
  while ((field=it++))
812
811
    if (i == create_fields.elements-1)
813
812
      *pos++=0;
814
813
    if (my_write(file, buff, (size_t) (pos-(char*) buff),MYF_RW))
815
 
      DBUG_RETURN(1);
 
814
      return(1);
816
815
    i++;
817
816
  }
818
817
 
857
856
          {
858
857
            my_message(ER_WRONG_FIELD_TERMINATORS,ER(ER_WRONG_FIELD_TERMINATORS),
859
858
                       MYF(0));
860
 
            DBUG_RETURN(1);
 
859
            return(1);
861
860
          }
862
861
        }
863
862
 
872
871
      }
873
872
    }
874
873
    if (my_write(file,(uchar*) tmp.ptr(),tmp.length(),MYF_RW))
875
 
      DBUG_RETURN(1);
 
874
      return(1);
876
875
  }
877
876
  if (comment_length)
878
877
  {
883
882
      if (field->comment.length)
884
883
        if (my_write(file, (uchar*) field->comment.str, field->comment.length,
885
884
                     MYF_RW))
886
 
          DBUG_RETURN(1);
 
885
          return(1);
887
886
    }
888
887
  }
889
 
  DBUG_RETURN(0);
 
888
  return(0);
890
889
}
891
890
 
892
891
 
907
906
  TABLE_SHARE share;
908
907
  Create_field *field;
909
908
  enum_check_fields old_count_cuted_fields= thd->count_cuted_fields;
910
 
  DBUG_ENTER("make_empty_rec");
 
909
  
911
910
 
912
911
  /* We need a table to generate columns for default values */
913
912
  bzero((char*) &table, sizeof(table));
916
915
 
917
916
  if (!(buff=(uchar*) my_malloc((size_t) reclength,MYF(MY_WME | MY_ZEROFILL))))
918
917
  {
919
 
    DBUG_RETURN(1);
 
918
    return(1);
920
919
  }
921
920
 
922
921
  table.in_use= thd;
992
991
    else
993
992
      regfield->reset();
994
993
  }
995
 
  DBUG_ASSERT(data_offset == ((null_count + 7) / 8));
 
994
  assert(data_offset == ((null_count + 7) / 8));
996
995
 
997
996
  /*
998
997
    We need to set the unused bits to 1. If the number of bits is a multiple
1006
1005
err:
1007
1006
  my_free(buff, MYF(MY_FAE));
1008
1007
  thd->count_cuted_fields= old_count_cuted_fields;
1009
 
  DBUG_RETURN(error);
 
1008
  return(error);
1010
1009
} /* make_empty_rec */