« back to all changes in this revision
Viewing changes to sql/field.cc
- browse files at revision 62
- compare with another revision
- compare with revision 1086.10.2
- download diff
- download tarball
- view history from revision 62
- Committer: Brian Aker
- Date: 2008-07-05 19:24:24 UTC
- mfrom: (53.2.8 codestyle)
- Revision ID: brian@tangent.org-20080705192424-3uslywtteymm7xqy
First pass of removing BIT_TYPE
- files modified:
- Makefile.am
added
removed
sql/field.cc
8434
8434
}
8435
8435
8436
8436
8437
/*
8438
Bit field.
8439
8440
We store the first 0 - 6 uneven bits among the null bits
8441
at the start of the record. The rest bytes are stored in
8442
the record itself.
8443
8444
For example:
8445
8446
CREATE TABLE t1 (a int, b bit(17), c bit(21) not null, d bit(8));
8447
We would store data as follows in the record:
8448
8449
Byte Bit
8450
1 7 - reserve for delete
8451
6 - null bit for 'a'
8452
5 - null bit for 'b'
8453
4 - first (high) bit of 'b'
8454
3 - first (high) bit of 'c'
8455
2 - second bit of 'c'
8456
1 - third bit of 'c'
8457
0 - forth bit of 'c'
8458
2 7 - firth bit of 'c'
8459
6 - null bit for 'd'
8460
3 - 6 four bytes for 'a'
8461
7 - 8 two bytes for 'b'
8462
9 - 10 two bytes for 'c'
8463
11 one byte for 'd'
8464
*/
8465
8466
Field_bit::Field_bit(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
8467
uchar null_bit_arg, uchar *bit_ptr_arg, uchar bit_ofs_arg,
8468
enum utype unireg_check_arg, const char *field_name_arg)
8469
: Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
8470
unireg_check_arg, field_name_arg),
8471
bit_ptr(bit_ptr_arg), bit_ofs(bit_ofs_arg), bit_len(len_arg & 7),
8472
bytes_in_rec(len_arg / 8)
8473
{
8474
flags|= UNSIGNED_FLAG;
8475
/*
8476
Ensure that Field::eq() can distinguish between two different bit fields.
8477
(two bit fields that are not null, may have same ptr and null_ptr)
8478
*/
8479
if (!null_ptr_arg)
8480
null_bit= bit_ofs_arg;
8481
}
8482
8483
8484
void Field_bit::hash(ulong *nr, ulong *nr2)
8485
{
8486
if (is_null())
8487
{
8488
*nr^= (*nr << 1) | 1;
8489
}
8490
else
8491
{
8492
CHARSET_INFO *cs= &my_charset_bin;
8493
longlong value= Field_bit::val_int();
8494
uchar tmp[8];
8495
mi_int8store(tmp,value);
8496
cs->coll->hash_sort(cs, tmp, 8, nr, nr2);
8497
}
8498
}
8499
8500
8501
size_t
8502
Field_bit::do_last_null_byte() const
8503
{
8504
/*
8505
Code elsewhere is assuming that bytes are 8 bits, so I'm using
8506
that value instead of the correct one: CHAR_BIT.
8507
8508
REFACTOR SUGGESTION (Matz): Change to use the correct number of
8509
bits. On systems with CHAR_BIT > 8 (not very common), the storage
8510
will lose the extra bits.
8511
*/
8512
DBUG_PRINT("test", ("bit_ofs: %d, bit_len: %d bit_ptr: 0x%lx",
8513
bit_ofs, bit_len, (long) bit_ptr));
8514
uchar *result;
8515
if (bit_len == 0)
8516
result= null_ptr;
8517
else if (bit_ofs + bit_len > 8)
8518
result= bit_ptr + 1;
8519
else
8520
result= bit_ptr;
8521
8522
if (result)
8523
return (size_t) (result - table->record[0]) + 1;
8524
return LAST_NULL_BYTE_UNDEF;
8525
}
8526
8527
8528
Field *Field_bit::new_key_field(MEM_ROOT *root,
8529
struct st_table *new_table,
8530
uchar *new_ptr, uchar *new_null_ptr,
8531
uint new_null_bit)
8532
{
8533
Field_bit *res;
8534
if ((res= (Field_bit*) Field::new_key_field(root, new_table,
8535
new_ptr, new_null_ptr,
8536
new_null_bit)))
8537
{
8538
/* Move bits normally stored in null_pointer to new_ptr */
8539
res->bit_ptr= new_ptr;
8540
res->bit_ofs= 0;
8541
if (bit_len)
8542
res->ptr++; // Store rest of data here
8543
}
8544
return res;
8545
}
8546
8547
8548
uint Field_bit::is_equal(Create_field *new_field)
8549
{
8550
return (new_field->sql_type == real_type() &&
8551
new_field->length == max_display_length());
8552
}
8553
8554
8555
int Field_bit::store(const char *from, uint length, CHARSET_INFO *cs)
8556
{
8557
ASSERT_COLUMN_MARKED_FOR_WRITE;
8558
int delta;
8559
8560
for (; length && !*from; from++, length--) {}; // skip left 0's
8561
delta= bytes_in_rec - length;
8562
8563
if (delta < -1 ||
8564
(delta == -1 && (uchar) *from > ((1 << bit_len) - 1)) ||
8565
(!bit_len && delta < 0))
8566
{
8567
set_rec_bits((1 << bit_len) - 1, bit_ptr, bit_ofs, bit_len);
8568
memset(ptr, 0xff, bytes_in_rec);
8569
if (table->in_use->really_abort_on_warning())
8570
set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
8571
else
8572
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
8573
return 1;
8574
}
8575
/* delta is >= -1 here */
8576
if (delta > 0)
8577
{
8578
if (bit_len)
8579
clr_rec_bits(bit_ptr, bit_ofs, bit_len);
8580
bzero(ptr, delta);
8581
memcpy(ptr + delta, from, length);
8582
}
8583
else if (delta == 0)
8584
{
8585
if (bit_len)
8586
clr_rec_bits(bit_ptr, bit_ofs, bit_len);
8587
memcpy(ptr, from, length);
8588
}
8589
else
8590
{
8591
if (bit_len)
8592
{
8593
set_rec_bits((uchar) *from, bit_ptr, bit_ofs, bit_len);
8594
from++;
8595
}
8596
memcpy(ptr, from, bytes_in_rec);
8597
}
8598
return 0;
8599
}
8600
8601
8602
int Field_bit::store(double nr)
8603
{
8604
return Field_bit::store((longlong) nr, FALSE);
8605
}
8606
8607
8608
int Field_bit::store(longlong nr, bool unsigned_val)
8609
{
8610
char buf[8];
8611
8612
mi_int8store(buf, nr);
8613
return store(buf, 8, NULL);
8614
}
8615
8616
8617
int Field_bit::store_decimal(const my_decimal *val)
8618
{
8619
int err= 0;
8620
longlong i= convert_decimal2longlong(val, 1, &err);
8621
return test(err | store(i, TRUE));
8622
}
8623
8624
8625
double Field_bit::val_real(void)
8626
{
8627
return (double) Field_bit::val_int();
8628
}
8629
8630
8631
longlong Field_bit::val_int(void)
8632
{
8633
ASSERT_COLUMN_MARKED_FOR_READ;
8634
uint64_t bits= 0;
8635
if (bit_len)
8636
{
8637
bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
8638
bits<<= (bytes_in_rec * 8);
8639
}
8640
8641
switch (bytes_in_rec) {
8642
case 0: return bits;
8643
case 1: return bits | (uint64_t) ptr[0];
8644
case 2: return bits | mi_uint2korr(ptr);
8645
case 3: return bits | mi_uint3korr(ptr);
8646
case 4: return bits | mi_uint4korr(ptr);
8647
case 5: return bits | mi_uint5korr(ptr);
8648
case 6: return bits | mi_uint6korr(ptr);
8649
case 7: return bits | mi_uint7korr(ptr);
8650
default: return mi_uint8korr(ptr + bytes_in_rec - sizeof(longlong));
8651
}
8652
}
8653
8654
8655
String *Field_bit::val_str(String *val_buffer,
8656
String *val_ptr __attribute__((unused)))
8657
{
8658
ASSERT_COLUMN_MARKED_FOR_READ;
8659
char buff[sizeof(longlong)];
8660
uint length= min(pack_length(), sizeof(longlong));
8661
uint64_t bits= val_int();
8662
mi_int8store(buff,bits);
8663
8664
val_buffer->alloc(length);
8665
memcpy_fixed((char*) val_buffer->ptr(), buff+8-length, length);
8666
val_buffer->length(length);
8667
val_buffer->set_charset(&my_charset_bin);
8668
return val_buffer;
8669
}
8670
8671
8672
my_decimal *Field_bit::val_decimal(my_decimal *deciaml_value)
8673
{
8674
ASSERT_COLUMN_MARKED_FOR_READ;
8675
int2my_decimal(E_DEC_FATAL_ERROR, val_int(), 1, deciaml_value);
8676
return deciaml_value;
8677
}
8678
8679
8680
/*
8681
Compare two bit fields using pointers within the record.
8682
SYNOPSIS
8683
cmp_max()
8684
a Pointer to field->ptr in first record
8685
b Pointer to field->ptr in second record
8686
max_len Maximum length used in index
8687
DESCRIPTION
8688
This method is used from key_rec_cmp used by merge sorts used
8689
by partitioned index read and later other similar places.
8690
The a and b pointer must be pointers to the field in a record
8691
(not the table->record[0] necessarily)
8692
*/
8693
int Field_bit::cmp_max(const uchar *a, const uchar *b, uint max_len)
8694
{
8695
my_ptrdiff_t a_diff= a - ptr;
8696
my_ptrdiff_t b_diff= b - ptr;
8697
if (bit_len)
8698
{
8699
int flag;
8700
uchar bits_a= get_rec_bits(bit_ptr+a_diff, bit_ofs, bit_len);
8701
uchar bits_b= get_rec_bits(bit_ptr+b_diff, bit_ofs, bit_len);
8702
if ((flag= (int) (bits_a - bits_b)))
8703
return flag;
8704
}
8705
return memcmp(a, b, field_length);
8706
}
8707
8708
8709
int Field_bit::key_cmp(const uchar *str, uint length)
8710
{
8711
if (bit_len)
8712
{
8713
int flag;
8714
uchar bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
8715
if ((flag= (int) (bits - *str)))
8716
return flag;
8717
str++;
8718
length--;
8719
}
8720
return memcmp(ptr, str, length);
8721
}
8722
8723
8724
int Field_bit::cmp_offset(uint row_offset)
8725
{
8726
if (bit_len)
8727
{
8728
int flag;
8729
uchar bits_a= get_rec_bits(bit_ptr, bit_ofs, bit_len);
8730
uchar bits_b= get_rec_bits(bit_ptr + row_offset, bit_ofs, bit_len);
8731
if ((flag= (int) (bits_a - bits_b)))
8732
return flag;
8733
}
8734
return memcmp(ptr, ptr + row_offset, bytes_in_rec);
8735
}
8736
8737
8738
uint Field_bit::get_key_image(uchar *buff, uint length, imagetype type_arg)
8739
{
8740
if (bit_len)
8741
{
8742
uchar bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
8743
*buff++= bits;
8744
length--;
8745
}
8746
uint data_length = min(length, bytes_in_rec);
8747
memcpy(buff, ptr, data_length);
8748
return data_length + 1;
8749
}
8750
8751
8752
/**
8753
Save the field metadata for bit fields.
8754
8755
Saves the bit length in the first byte and bytes in record in the
8756
second byte of the field metadata array at index of *metadata_ptr and
8757
*(metadata_ptr + 1).
8758
8759
@param metadata_ptr First byte of field metadata
8760
8761
@returns number of bytes written to metadata_ptr
8762
*/
8763
int Field_bit::do_save_field_metadata(uchar *metadata_ptr)
8764
{
8765
*metadata_ptr= bit_len;
8766
*(metadata_ptr + 1)= bytes_in_rec;
8767
return 2;
8768
}
8769
8770
8771
/**
8772
Returns the number of bytes field uses in row-based replication
8773
row packed size.
8774
8775
This method is used in row-based replication to determine the number
8776
of bytes that the field consumes in the row record format. This is
8777
used to skip fields in the master that do not exist on the slave.
8778
8779
@param field_metadata Encoded size in field metadata
8780
8781
@returns The size of the field based on the field metadata.
8782
*/
8783
uint Field_bit::pack_length_from_metadata(uint field_metadata)
8784
{
8785
uint const from_len= (field_metadata >> 8U) & 0x00ff;
8786
uint const from_bit_len= field_metadata & 0x00ff;
8787
uint const source_size= from_len + ((from_bit_len > 0) ? 1 : 0);
8788
return (source_size);
8789
}
8790
8791
8792
/**
8793
Check to see if field size is compatible with destination.
8794
8795
This method is used in row-based replication to verify that the slave's
8796
field size is less than or equal to the master's field size. The
8797
encoded field metadata (from the master or source) is decoded and compared
8798
to the size of this field (the slave or destination).
8799
8800
@param field_metadata Encoded size in field metadata
8801
8802
@retval 0 if this field's size is < the source field's size
8803
@retval 1 if this field's size is >= the source field's size
8804
*/
8805
int Field_bit::compatible_field_size(uint field_metadata)
8806
{
8807
int compatible= 0;
8808
uint const source_size= pack_length_from_metadata(field_metadata);
8809
uint const destination_size= row_pack_length();
8810
uint const from_bit_len= field_metadata & 0x00ff;
8811
uint const from_len= (field_metadata >> 8U) & 0x00ff;
8812
if ((bit_len == 0) || (from_bit_len == 0))
8813
compatible= (source_size <= destination_size);
8814
else if (from_bit_len > bit_len)
8815
compatible= (from_len < bytes_in_rec);
8816
else
8817
compatible= ((from_bit_len <= bit_len) && (from_len <= bytes_in_rec));
8818
return (compatible);
8819
}
8820
8821
8822
8823
void Field_bit::sql_type(String &res) const
8824
{
8825
CHARSET_INFO *cs= res.charset();
8826
ulong length= cs->cset->snprintf(cs, (char*) res.ptr(), res.alloced_length(),
8827
"bit(%d)", (int) field_length);
8828
res.length((uint) length);
8829
}
8830
8831
8832
uchar *
8833
Field_bit::pack(uchar *to, const uchar *from, uint max_length,
8834
bool low_byte_first __attribute__((unused)))
8835
{
8836
DBUG_ASSERT(max_length > 0);
8837
uint length;
8838
if (bit_len > 0)
8839
{
8840
/*
8841
We have the following:
8842
8843
ptr Points into a field in record R1
8844
from Points to a field in a record R2
8845
bit_ptr Points to the byte (in the null bytes) that holds the
8846
odd bits of R1
8847
from_bitp Points to the byte that holds the odd bits of R2
8848
8849
We have the following:
8850
8851
ptr - bit_ptr = from - from_bitp
8852
8853
We want to isolate 'from_bitp', so this gives:
8854
8855
ptr - bit_ptr - from = - from_bitp
8856
- ptr + bit_ptr + from = from_bitp
8857
bit_ptr + from - ptr = from_bitp
8858
*/
8859
uchar bits= get_rec_bits(bit_ptr + (from - ptr), bit_ofs, bit_len);
8860
*to++= bits;
8861
}
8862
length= min(bytes_in_rec, max_length - (bit_len > 0));
8863
memcpy(to, from, length);
8864
return to + length;
8865
}
8866
8867
8868
/**
8869
Unpack a bit field from row data.
8870
8871
This method is used to unpack a bit field from a master whose size
8872
of the field is less than that of the slave.
8873
8874
@param to Destination of the data
8875
@param from Source of the data
8876
@param param_data Bit length (upper) and length (lower) values
8877
8878
@return New pointer into memory based on from + length of the data
8879
*/
8880
const uchar *
8881
Field_bit::unpack(uchar *to, const uchar *from, uint param_data,
8882
bool low_byte_first __attribute__((unused)))
8883
{
8884
uint const from_len= (param_data >> 8U) & 0x00ff;
8885
uint const from_bit_len= param_data & 0x00ff;
8886
/*
8887
If the parameter data is zero (i.e., undefined), or if the master
8888
and slave have the same sizes, then use the old unpack() method.
8889
*/
8890
if (param_data == 0 || ((from_bit_len == bit_len) && (from_len == bytes_in_rec)))
8891
{
8892
if (bit_len > 0)
8893
{
8894
/*
8895
set_rec_bits is a macro, don't put the post-increment in the
8896
argument since that might cause strange side-effects.
8897
8898
For the choice of the second argument, see the explanation for
8899
Field_bit::pack().
8900
*/
8901
set_rec_bits(*from, bit_ptr + (to - ptr), bit_ofs, bit_len);
8902
from++;
8903
}
8904
memcpy(to, from, bytes_in_rec);
8905
return from + bytes_in_rec;
8906
}
8907
8908
/*
8909
We are converting a smaller bit field to a larger one here.
8910
To do that, we first need to construct a raw value for the original
8911
bit value stored in the from buffer. Then that needs to be converted
8912
to the larger field then sent to store() for writing to the field.
8913
Lastly the odd bits need to be masked out if the bytes_in_rec > 0.
8914
Otherwise stray bits can cause spurious values.
8915
*/
8916
uint new_len= (field_length + 7) / 8;
8917
char *value= (char *)my_alloca(new_len);
8918
bzero(value, new_len);
8919
uint len= from_len + ((from_bit_len > 0) ? 1 : 0);
8920
memcpy(value + (new_len - len), from, len);
8921
/*
8922
Mask out the unused bits in the partial byte.
8923
TODO: Add code to the master to always mask these bits and remove
8924
the following.
8925
*/
8926
if ((from_bit_len > 0) && (from_len > 0))
8927
value[new_len - len]= value[new_len - len] & ((1U << from_bit_len) - 1);
8928
bitmap_set_bit(table->write_set,field_index);
8929
store(value, new_len, system_charset_info);
8930
my_afree(value);
8931
return from + len;
8932
}
8933
8934
8935
void Field_bit::set_default()
8936
{
8937
if (bit_len > 0)
8938
{
8939
my_ptrdiff_t const offset= table->s->default_values - table->record[0];
8940
uchar bits= get_rec_bits(bit_ptr + offset, bit_ofs, bit_len);
8941
set_rec_bits(bits, bit_ptr, bit_ofs, bit_len);
8942
}
8943
Field::set_default();
8944
}
8945
8946
/*
8947
Bit field support for non-MyISAM tables.
8948
*/
8949
8950
Field_bit_as_char::Field_bit_as_char(uchar *ptr_arg, uint32 len_arg,
8951
uchar *null_ptr_arg, uchar null_bit_arg,
8952
enum utype unireg_check_arg,
8953
const char *field_name_arg)
8954
:Field_bit(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, 0, 0,
8955
unireg_check_arg, field_name_arg)
8956
{
8957
flags|= UNSIGNED_FLAG;
8958
bit_len= 0;
8959
bytes_in_rec= (len_arg + 7) / 8;
8960
}
8961
8962
8963
int Field_bit_as_char::store(const char *from, uint length, CHARSET_INFO *cs)
8964
{
8965
ASSERT_COLUMN_MARKED_FOR_WRITE;
8966
int delta;
8967
uchar bits= (uchar) (field_length & 7);
8968
8969
for (; length && !*from; from++, length--) {}; // skip left 0's
8970
delta= bytes_in_rec - length;
8971
8972
if (delta < 0 ||
8973
(delta == 0 && bits && (uint) (uchar) *from >= (uint) (1 << bits)))
8974
{
8975
memset(ptr, 0xff, bytes_in_rec);
8976
if (bits)
8977
*ptr&= ((1 << bits) - 1); /* set first uchar */
8978
if (table->in_use->really_abort_on_warning())
8979
set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
8980
else
8981
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
8982
return 1;
8983
}
8984
bzero(ptr, delta);
8985
memcpy(ptr + delta, from, length);
8986
return 0;
8987
}
8988
8989
8990
void Field_bit_as_char::sql_type(String &res) const
8991
{
8992
CHARSET_INFO *cs= res.charset();
8993
ulong length= cs->cset->snprintf(cs, (char*) res.ptr(), res.alloced_length(),
8994
"bit(%d)", (int) field_length);
8995
res.length((uint) length);
8996
}
8997
8998
8999
8437
/*****************************************************************************
9000
8438
Handling of field and Create_field
9001
8439
*****************************************************************************/
9024
8462
length*= charset->mbmaxlen;
9025
8463
key_length= pack_length;
9026
8464
break;
9027
case MYSQL_TYPE_BIT:
9028
if (f_bit_as_char(pack_flag))
9029
{
9030
key_length= pack_length= ((length + 7) & ~7) / 8;
9031
}
9032
else
9033
{
9034
pack_length= length / 8;
9035
/* We need one extra byte to store the bits we save among the null bits */
9036
key_length= pack_length + test(length & 7);
9037
}
9038
break;
9039
8465
case MYSQL_TYPE_NEWDECIMAL:
9040
8466
key_length= pack_length=
9041
8467
my_decimal_get_binary_size(my_decimal_length_to_precision(length,
9511
8937
{
9512
8938
uchar *bit_ptr= NULL;
9513
8939
uchar bit_offset= 0;
9514
if (field_type == MYSQL_TYPE_BIT && !f_bit_as_char(pack_flag))
9515
{
9516
bit_ptr= null_pos;
9517
bit_offset= null_bit;
9518
if (f_maybe_null(pack_flag)) // if null field
9519
{
9520
bit_ptr+= (null_bit == 7); // shift bit_ptr and bit_offset
9521
bit_offset= (bit_offset + 1) & 7;
9522
}
9523
}
9524
8940
9525
8941
if (!f_maybe_null(pack_flag))
9526
8942
{
9655
9071
case MYSQL_TYPE_NULL:
9656
9072
return new Field_null(ptr, field_length, unireg_check, field_name,
9657
9073
field_charset);
9658
case MYSQL_TYPE_BIT:
9659
return f_bit_as_char(pack_flag) ?
9660
new Field_bit_as_char(ptr, field_length, null_pos, null_bit,
9661
unireg_check, field_name) :
9662
new Field_bit(ptr, field_length, null_pos, null_bit, bit_ptr,
9663
bit_offset, unireg_check, field_name);
9664
9665
9074
default: // Impossible (Wrong version)
9666
9075
break;
9667
9076
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1