« back to all changes in this revision
Viewing changes to sql/unireg.cc
- browse files at revision 98
- compare with another revision
- compare with revision 1099.4.91
- download diff
- download tarball
- view history from revision 98
- Committer: Brian Aker
- Date: 2008-07-08 16:53:50 UTC
- mfrom: (51.1.8 remove-dbug)
- Revision ID: brian@tangent.org-20080708165350-y246k7585xv56c0m
Merging in Jay's Tree
added
removed
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 */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1