← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/unireg.cc

Merged from trunk.

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;
515
514
    int2store(pos+6, key->block_size);
516
515
    pos+=8;
517
516
    key_parts+=key->key_parts;
518
 
    DBUG_PRINT("loop", ("flags: %lu  key_parts: %d at 0x%lx",
519
 
                        key->flags, key->key_parts,
520
 
                        (long) key->key_part));
521
517
    for (key_part=key->key_part,key_part_end=key_part+key->key_parts ;
522
518
         key_part != key_part_end ;
523
519
         key_part++)
524
520
 
525
521
    {
526
522
      uint offset;
527
 
      DBUG_PRINT("loop",("field: %d  startpos: %lu  length: %d",
528
 
                         key_part->fieldnr, key_part->offset + data_offset,
529
 
                         key_part->length));
530
523
      int2store(pos,key_part->fieldnr+1+FIELD_NAME_USED);
531
524
      offset= (uint) (key_part->offset+data_offset+1);
532
525
      int2store(pos+2, offset);
572
565
  }
573
566
  length=(uint) (pos-keyname_pos);
574
567
  int2store(keybuff+4,length);
575
 
  DBUG_RETURN((uint) (pos-keybuff));
 
568
  return((uint) (pos-keybuff));
576
569
} /* pack_keys */
577
570
 
578
571
 
586
579
  uint length,int_count,int_length,no_empty, int_parts;
587
580
  uint time_stamp_pos,null_fields;
588
581
  ulong reclength, totlength, n_length, com_length;
589
 
  DBUG_ENTER("pack_header");
 
582
  
590
583
 
591
584
  if (create_fields.elements > MAX_FIELDS)
592
585
  {
593
586
    my_message(ER_TOO_MANY_FIELDS, ER(ER_TOO_MANY_FIELDS), MYF(0));
594
 
    DBUG_RETURN(1);
 
587
    return(1);
595
588
  }
596
589
 
597
590
  totlength= 0L;
617
610
      my_error(ER_WRONG_STRING_LENGTH, MYF(0),
618
611
               field->comment.str,"COLUMN COMMENT",
619
612
               (uint) COLUMN_COMMENT_MAXLEN);
620
 
      DBUG_RETURN(1);
 
613
      return(1);
621
614
    }
622
615
 
623
616
    totlength+= field->length;
639
632
      time_stamp_pos= (uint) field->offset+ (uint) data_offset + 1;
640
633
    length=field->pack_length;
641
634
    /* Ensure we don't have any bugs when generating offsets */
642
 
    DBUG_ASSERT(reclength == field->offset + data_offset);
 
635
    assert(reclength == field->offset + data_offset);
643
636
    if ((uint) field->offset+ (uint) data_offset+ length > reclength)
644
637
      reclength=(uint) (field->offset+ data_offset + length);
645
638
    n_length+= (ulong) strlen(field->field_name)+1;
701
694
  if (reclength > (ulong) file->max_record_length())
702
695
  {
703
696
    my_error(ER_TOO_BIG_ROWSIZE, MYF(0), (uint) file->max_record_length());
704
 
    DBUG_RETURN(1);
 
697
    return(1);
705
698
  }
706
699
  /* Hack to avoid bugs with small static rows in MySQL */
707
700
  reclength=max(file->min_record_length(table_options),reclength);
709
702
      n_length+int_length+com_length > 65535L || int_count > 255)
710
703
  {
711
704
    my_message(ER_TOO_MANY_FIELDS, ER(ER_TOO_MANY_FIELDS), MYF(0));
712
 
    DBUG_RETURN(1);
 
705
    return(1);
713
706
  }
714
707
 
715
708
  bzero((char*)forminfo,288);
732
725
  int2store(forminfo+282,null_fields);
733
726
  int2store(forminfo+284,com_length);
734
727
  /* Up to forminfo+288 is free to use for additional information */
735
 
  DBUG_RETURN(0);
 
728
  return(0);
736
729
} /* pack_header */
737
730
 
738
731
 
773
766
  uint int_count, comment_length=0;
774
767
  uchar buff[MAX_FIELD_WIDTH];
775
768
  Create_field *field;
776
 
  DBUG_ENTER("pack_fields");
 
769
  
777
770
 
778
771
        /* Write field info */
779
772
 
802
795
    comment_length+= field->comment.length;
803
796
    set_if_bigger(int_count,field->interval_id);
804
797
    if (my_write(file, buff, FCOMP, MYF_RW))
805
 
      DBUG_RETURN(1);
 
798
      return(1);
806
799
  }
807
800
 
808
801
        /* Write fieldnames */
809
802
  buff[0]=(uchar) NAMES_SEP_CHAR;
810
803
  if (my_write(file, buff, 1, MYF_RW))
811
 
    DBUG_RETURN(1);
 
804
    return(1);
812
805
  i=0;
813
806
  it.rewind();
814
807
  while ((field=it++))
818
811
    if (i == create_fields.elements-1)
819
812
      *pos++=0;
820
813
    if (my_write(file, buff, (size_t) (pos-(char*) buff),MYF_RW))
821
 
      DBUG_RETURN(1);
 
814
      return(1);
822
815
    i++;
823
816
  }
824
817
 
863
856
          {
864
857
            my_message(ER_WRONG_FIELD_TERMINATORS,ER(ER_WRONG_FIELD_TERMINATORS),
865
858
                       MYF(0));
866
 
            DBUG_RETURN(1);
 
859
            return(1);
867
860
          }
868
861
        }
869
862
 
878
871
      }
879
872
    }
880
873
    if (my_write(file,(uchar*) tmp.ptr(),tmp.length(),MYF_RW))
881
 
      DBUG_RETURN(1);
 
874
      return(1);
882
875
  }
883
876
  if (comment_length)
884
877
  {
889
882
      if (field->comment.length)
890
883
        if (my_write(file, (uchar*) field->comment.str, field->comment.length,
891
884
                     MYF_RW))
892
 
          DBUG_RETURN(1);
 
885
          return(1);
893
886
    }
894
887
  }
895
 
  DBUG_RETURN(0);
 
888
  return(0);
896
889
}
897
890
 
898
891
 
913
906
  TABLE_SHARE share;
914
907
  Create_field *field;
915
908
  enum_check_fields old_count_cuted_fields= thd->count_cuted_fields;
916
 
  DBUG_ENTER("make_empty_rec");
 
909
  
917
910
 
918
911
  /* We need a table to generate columns for default values */
919
912
  bzero((char*) &table, sizeof(table));
922
915
 
923
916
  if (!(buff=(uchar*) my_malloc((size_t) reclength,MYF(MY_WME | MY_ZEROFILL))))
924
917
  {
925
 
    DBUG_RETURN(1);
 
918
    return(1);
926
919
  }
927
920
 
928
921
  table.in_use= thd;
998
991
    else
999
992
      regfield->reset();
1000
993
  }
1001
 
  DBUG_ASSERT(data_offset == ((null_count + 7) / 8));
 
994
  assert(data_offset == ((null_count + 7) / 8));
1002
995
 
1003
996
  /*
1004
997
    We need to set the unused bits to 1. If the number of bits is a multiple
1012
1005
err:
1013
1006
  my_free(buff, MYF(MY_FAE));
1014
1007
  thd->count_cuted_fields= old_count_cuted_fields;
1015
 
  DBUG_RETURN(error);
 
1008
  return(error);
1016
1009
} /* make_empty_rec */