summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--sql/field.cc98
-rw-r--r--sql/field.h3
-rw-r--r--sql/opt_range.cc152
-rw-r--r--sql/opt_range.h4
-rw-r--r--sql/sql_class.cc4
-rw-r--r--sql/sql_select.cc2
-rw-r--r--sql/table.cc1
7 files changed, 140 insertions, 124 deletions
diff --git a/sql/field.cc b/sql/field.cc
index d099da2d959..afb728b7d78 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -4360,7 +4360,7 @@ int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs)
set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED);
error= 1;
}
- memcpy(ptr+2,from,length);
+ memcpy(ptr+HA_KEY_BLOB_LENGTH,from,length);
int2store(ptr, length);
return error;
}
@@ -4389,18 +4389,18 @@ int Field_varstring::store(longlong nr)
double Field_varstring::val_real(void)
{
int not_used;
- uint length=uint2korr(ptr)+2;
+ uint length=uint2korr(ptr)+HA_KEY_BLOB_LENGTH;
CHARSET_INFO *cs=charset();
- return my_strntod(cs,ptr+2,length,(char**)0, &not_used);
+ return my_strntod(cs, ptr+HA_KEY_BLOB_LENGTH, length, (char**)0, &not_used);
}
longlong Field_varstring::val_int(void)
{
int not_used;
- uint length=uint2korr(ptr)+2;
+ uint length=uint2korr(ptr)+HA_KEY_BLOB_LENGTH;
CHARSET_INFO *cs=charset();
- return my_strntoll(cs,ptr+2,length,10,NULL, &not_used);
+ return my_strntoll(cs,ptr+HA_KEY_BLOB_LENGTH,length,10,NULL, &not_used);
}
@@ -4408,7 +4408,7 @@ String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
String *val_ptr)
{
uint length=uint2korr(ptr);
- val_ptr->set((const char*) ptr+2,length,field_charset);
+ val_ptr->set((const char*) ptr+HA_KEY_BLOB_LENGTH,length,field_charset);
return val_ptr;
}
@@ -4418,18 +4418,21 @@ int Field_varstring::cmp(const char *a_ptr, const char *b_ptr)
uint a_length=uint2korr(a_ptr);
uint b_length=uint2korr(b_ptr);
int diff;
- diff=my_strnncoll(field_charset,
- (const uchar*)a_ptr+2,min(a_length,b_length),
- (const uchar*)b_ptr+2,min(a_length,b_length));
+ diff= my_strnncoll(field_charset,
+ (const uchar*) a_ptr+HA_KEY_BLOB_LENGTH,
+ min(a_length,b_length),
+ (const uchar*) b_ptr+HA_KEY_BLOB_LENGTH,
+ min(a_length,b_length));
return diff ? diff : (int) (a_length - b_length);
}
void Field_varstring::sort_string(char *to,uint length)
{
uint tot_length=uint2korr(ptr);
- tot_length=my_strnxfrm(field_charset,
- (unsigned char *) to, length,
- (unsigned char *)ptr+2, tot_length);
+ tot_length= my_strnxfrm(field_charset,
+ (uchar*) to, length,
+ (uchar*) ptr+HA_KEY_BLOB_LENGTH,
+ tot_length);
if (tot_length < length)
field_charset->cset->fill(field_charset, to+tot_length,length-tot_length,
binary() ? (char) 0 : ' ');
@@ -4454,7 +4457,7 @@ char *Field_varstring::pack(char *to, const char *from, uint max_length)
if (max_length > 255)
*to++= (char) (length >> 8);
if (length)
- memcpy(to, from+2, length);
+ memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
return to+length;
}
@@ -4474,7 +4477,7 @@ const char *Field_varstring::unpack(char *to, const char *from)
to[1] = *from++;
}
if (length)
- memcpy(to+2, from, length);
+ memcpy(to+HA_KEY_BLOB_LENGTH, from, length);
return from+length;
}
@@ -4485,8 +4488,8 @@ int Field_varstring::pack_cmp(const char *a, const char *b, uint key_length)
uint b_length;
if (key_length > 255)
{
- a_length=uint2korr(a); a+=2;
- b_length=uint2korr(b); b+=2;
+ a_length=uint2korr(a); a+= 2;
+ b_length=uint2korr(b); b+= 2;
}
else
{
@@ -4494,32 +4497,32 @@ int Field_varstring::pack_cmp(const char *a, const char *b, uint key_length)
b_length= (uint) (uchar) *b++;
}
return my_strnncoll(field_charset,
- (const uchar *)a,a_length,
- (const uchar *)b,b_length);
+ (const uchar*) a, a_length,
+ (const uchar*) b, b_length);
}
int Field_varstring::pack_cmp(const char *b, uint key_length)
{
- char *a=ptr+2;
- uint a_length=uint2korr(ptr);
+ char *a= ptr+HA_KEY_BLOB_LENGTH;
+ uint a_length= uint2korr(ptr);
uint b_length;
if (key_length > 255)
{
- b_length=uint2korr(b); b+=2;
+ b_length=uint2korr(b); b+= 2;
}
else
{
b_length= (uint) (uchar) *b++;
}
return my_strnncoll(field_charset,
- (const uchar *)a,a_length,
- (const uchar *)b,b_length);
+ (const uchar*) a, a_length,
+ (const uchar*) b, b_length);
}
uint Field_varstring::packed_col_length(const char *data_ptr, uint length)
{
if (length > 255)
- return uint2korr(data_ptr)+2;
+ return uint2korr(data_ptr)+HA_KEY_BLOB_LENGTH;
else
return (uint) ((uchar) *data_ptr)+1;
}
@@ -4532,22 +4535,21 @@ uint Field_varstring::max_packed_col_length(uint max_length)
void Field_varstring::get_key_image(char *buff, uint length, CHARSET_INFO *cs,
imagetype type)
{
- length-= HA_KEY_BLOB_LENGTH;
uint f_length=uint2korr(ptr);
if (f_length > length)
f_length= length;
int2store(buff,length);
- memcpy(buff+2,ptr+2,length);
+ memcpy(buff+HA_KEY_BLOB_LENGTH, ptr+HA_KEY_BLOB_LENGTH, length);
#ifdef HAVE_purify
if (f_length < length)
- bzero(buff+2+f_length, (length-f_length));
+ bzero(buff+HA_KEY_BLOB_LENGTH+f_length, (length-f_length));
#endif
}
void Field_varstring::set_key_image(char *buff,uint length, CHARSET_INFO *cs)
{
length=uint2korr(buff); // Real length is here
- (void) Field_varstring::store(buff+2, length, cs);
+ (void) Field_varstring::store(buff+HA_KEY_BLOB_LENGTH, length, cs);
}
@@ -4800,7 +4802,6 @@ int Field_blob::cmp_binary(const char *a_ptr, const char *b_ptr,
void Field_blob::get_key_image(char *buff,uint length,
CHARSET_INFO *cs, imagetype type)
{
- length-= HA_KEY_BLOB_LENGTH;
uint32 blob_length= get_length(ptr);
char *blob;
@@ -4839,18 +4840,18 @@ void Field_blob::get_key_image(char *buff,uint length,
Must clear this as we do a memcmp in opt_range.cc to detect
identical keys
*/
- bzero(buff+2+blob_length, (length-blob_length));
+ bzero(buff+HA_KEY_BLOB_LENGTH+blob_length, (length-blob_length));
length=(uint) blob_length;
}
int2store(buff,length);
get_ptr(&blob);
- memcpy(buff+2,blob,length);
+ memcpy(buff+HA_KEY_BLOB_LENGTH, blob, length);
}
void Field_blob::set_key_image(char *buff,uint length, CHARSET_INFO *cs)
{
- length=uint2korr(buff);
- (void) Field_blob::store(buff+2,length,cs);
+ length= uint2korr(buff);
+ (void) Field_blob::store(buff+HA_KEY_BLOB_LENGTH, length, cs);
}
@@ -4858,16 +4859,16 @@ int Field_blob::key_cmp(const byte *key_ptr, uint max_key_length)
{
char *blob1;
uint blob_length=get_length(ptr);
- max_key_length-=2;
memcpy_fixed(&blob1,ptr+packlength,sizeof(char*));
return Field_blob::cmp(blob1,min(blob_length, max_key_length),
- (char*) key_ptr+2,uint2korr(key_ptr));
+ (char*) key_ptr+HA_KEY_BLOB_LENGTH,
+ uint2korr(key_ptr));
}
int Field_blob::key_cmp(const byte *a,const byte *b)
{
- return Field_blob::cmp((char*) a+2,uint2korr(a),
- (char*) b+2,uint2korr(b));
+ return Field_blob::cmp((char*) a+HA_KEY_BLOB_LENGTH, uint2korr(a),
+ (char*) b+HA_KEY_BLOB_LENGTH, uint2korr(b));
}
@@ -4883,8 +4884,8 @@ void Field_blob::sort_string(char *to,uint length)
memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
blob_length=my_strnxfrm(field_charset,
- (unsigned char *)to, length,
- (unsigned char *)blob, blob_length);
+ (uchar*) to, length,
+ (uchar*) blob, blob_length);
if (blob_length < length)
field_charset->cset->fill(field_charset, to+blob_length,
length-blob_length,
@@ -4966,8 +4967,8 @@ int Field_blob::pack_cmp(const char *a, const char *b, uint key_length)
b_length= (uint) (uchar) *b++;
}
return my_strnncoll(field_charset,
- (const uchar *)a,a_length,
- (const uchar *)b,b_length);
+ (const uchar*) a, a_length,
+ (const uchar*) b, b_length);
}
@@ -4989,8 +4990,8 @@ int Field_blob::pack_cmp(const char *b, uint key_length)
b_length= (uint) (uchar) *b++;
}
return my_strnncoll(field_charset,
- (const uchar *)a,a_length,
- (const uchar *)b,b_length);
+ (const uchar*) a, a_length,
+ (const uchar*) b, b_length);
}
/* Create a packed key that will be used for storage from a MySQL row */
@@ -5026,7 +5027,7 @@ char *Field_blob::pack_key_from_key_image(char *to, const char *from,
if (max_length > 255)
*to++= (char) (length >> 8);
if (length)
- memcpy(to, from+2, length);
+ memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
return to+length;
}
@@ -5049,11 +5050,12 @@ uint Field_blob::max_packed_col_length(uint max_length)
void Field_geom::get_key_image(char *buff, uint length, CHARSET_INFO *cs,
imagetype type)
{
- length-= HA_KEY_BLOB_LENGTH;
- ulong blob_length= get_length(ptr);
char *blob;
const char *dummy;
MBR mbr;
+ ulong blob_length= get_length(ptr);
+ Geometry_buffer buffer;
+ Geometry *gobj;
if (blob_length < SRID_SIZE)
{
@@ -5061,8 +5063,6 @@ void Field_geom::get_key_image(char *buff, uint length, CHARSET_INFO *cs,
return;
}
get_ptr(&blob);
- Geometry_buffer buffer;
- Geometry *gobj;
gobj= Geometry::create_from_wkb(&buffer,
blob + SRID_SIZE, blob_length - SRID_SIZE);
if (gobj->get_mbr(&mbr, &dummy))
@@ -5555,7 +5555,7 @@ uint32 calc_pack_length(enum_field_types type,uint32 length)
switch (type) {
case FIELD_TYPE_STRING:
case FIELD_TYPE_DECIMAL: return (length);
- case FIELD_TYPE_VAR_STRING: return (length+2);
+ case FIELD_TYPE_VAR_STRING: return (length+HA_KEY_BLOB_LENGTH);
case FIELD_TYPE_YEAR:
case FIELD_TYPE_TINY : return 1;
case FIELD_TYPE_SHORT : return 2;
diff --git a/sql/field.h b/sql/field.h
index 75bb96f2f6d..6dd476b6968 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -199,7 +199,8 @@ public:
{ memcpy(buff,ptr,length); }
inline void set_image(char *buff,uint length, CHARSET_INFO *cs)
{ memcpy(ptr,buff,length); }
- virtual void get_key_image(char *buff,uint length, CHARSET_INFO *cs, imagetype type)
+ virtual void get_key_image(char *buff,uint length, CHARSET_INFO *cs,
+ imagetype type)
{ get_image(buff,length,cs); }
virtual void set_key_image(char *buff,uint length, CHARSET_INFO *cs)
{ set_image(buff,length,cs); }
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index b6ac0eab53b..112523747f0 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -177,11 +177,11 @@ public:
if (maybe_null && *min_value)
{
**min_key=1;
- bzero(*min_key+1,length);
+ bzero(*min_key+1,length-1);
}
else
- memcpy(*min_key,min_value,length+(int) maybe_null);
- (*min_key)+= length+(int) maybe_null;
+ memcpy(*min_key,min_value,length);
+ (*min_key)+= length;
}
if (!(max_flag & NO_MAX_RANGE) &&
!(max_key_flag & (NO_MAX_RANGE | NEAR_MAX)))
@@ -189,18 +189,18 @@ public:
if (maybe_null && *max_value)
{
**max_key=1;
- bzero(*max_key+1,length);
+ bzero(*max_key+1,length-1);
}
else
- memcpy(*max_key,max_value,length+(int) maybe_null);
- (*max_key)+= length+(int) maybe_null;
+ memcpy(*max_key,max_value,length);
+ (*max_key)+= length;
}
}
void store_min_key(KEY_PART *key,char **range_key, uint *range_key_flag)
{
SEL_ARG *key_tree= first();
- key_tree->store(key[key_tree->part].part_length,
+ key_tree->store(key[key_tree->part].store_length,
range_key,*range_key_flag,range_key,NO_MAX_RANGE);
*range_key_flag|= key_tree->min_flag;
if (key_tree->next_key_part &&
@@ -213,7 +213,7 @@ public:
void store_max_key(KEY_PART *key,char **range_key, uint *range_key_flag)
{
SEL_ARG *key_tree= last();
- key_tree->store(key[key_tree->part].part_length,
+ key_tree->store(key[key_tree->part].store_length,
range_key, NO_MIN_RANGE, range_key,*range_key_flag);
(*range_key_flag)|= key_tree->max_flag;
if (key_tree->next_key_part &&
@@ -676,19 +676,21 @@ int SQL_SELECT::test_quick_select(THD *thd, key_map keys_to_use,
if (!keys_to_use.is_set(idx))
continue;
KEY *key_info= &head->key_info[idx];
+ KEY_PART_INFO *key_part_info= key_info->key_part;
+
if (key_info->flags & HA_FULLTEXT)
continue; // ToDo: ft-keys in non-ft ranges, if possible SerG
param.key[param.keys]=key_parts;
- for (uint part=0 ; part < key_info->key_parts ; part++,key_parts++)
+ for (uint part=0 ; part < key_info->key_parts ;
+ part++, key_parts++, key_part_info++)
{
- key_parts->key=param.keys;
- key_parts->part=part;
- key_parts->part_length= key_info->key_part[part].length;
- key_parts->field= key_info->key_part[part].field;
- key_parts->null_bit= key_info->key_part[part].null_bit;
- if (key_parts->field->type() == FIELD_TYPE_BLOB)
- key_parts->part_length+=HA_KEY_BLOB_LENGTH;
+ key_parts->key= param.keys;
+ key_parts->part= part;
+ key_parts->length= key_part_info->length;
+ key_parts->store_length= key_part_info->store_length;
+ key_parts->field= key_part_info->field;
+ key_parts->null_bit= key_part_info->null_bit;
key_parts->image_type =
(key_info->flags & HA_SPATIAL) ? Field::itMBR : Field::itRAW;
}
@@ -1043,18 +1045,26 @@ get_mm_leaf(PARAM *param, COND *conf_func, Field *field, KEY_PART *key_part,
DBUG_RETURN(0); // Can only optimize strings
offset=maybe_null;
- length=key_part->part_length;
- if (field->type() == FIELD_TYPE_BLOB)
+ length=key_part->store_length;
+
+ if (length != key_part->length + maybe_null)
{
- offset+=HA_KEY_BLOB_LENGTH;
- field_length=key_part->part_length-HA_KEY_BLOB_LENGTH;
+ /* key packed with length prefix */
+ offset+= HA_KEY_BLOB_LENGTH;
+ field_length= length - HA_KEY_BLOB_LENGTH;
}
else
{
- if (length < field_length)
- length=field_length; // Only if overlapping key
+ if (unlikely(length < field_length))
+ {
+ /*
+ This can only happen in a table created with UNIREG where one key
+ overlaps many fields
+ */
+ length= field_length;
+ }
else
- field_length=length;
+ field_length= length;
}
length+=offset;
if (!(min_str= (char*) alloc_root(param->mem_root, length*2)))
@@ -1067,7 +1077,7 @@ get_mm_leaf(PARAM *param, COND *conf_func, Field *field, KEY_PART *key_part,
res->ptr(), res->length(),
((Item_func_like*)(param->cond))->escape,
wild_one, wild_many,
- field_length,
+ field_length-maybe_null,
min_str+offset, max_str+offset,
&min_length, &max_length);
if (like_error) // Can't optimize with LIKE
@@ -1105,13 +1115,13 @@ get_mm_leaf(PARAM *param, COND *conf_func, Field *field, KEY_PART *key_part,
if (field->key_type() == HA_KEYTYPE_VARTEXT)
copies= 2;
str= str2= (char*) alloc_root(param->mem_root,
- (key_part->part_length+maybe_null)*copies+1);
+ (key_part->store_length)*copies+1);
if (!str)
DBUG_RETURN(0);
if (maybe_null)
*str= (char) field->is_real_null(); // Set to 1 if null
- field->get_key_image(str+maybe_null,key_part->part_length,
- field->charset(),key_part->image_type);
+ field->get_key_image(str+maybe_null, key_part->length,
+ field->charset(), key_part->image_type);
if (copies == 2)
{
/*
@@ -1120,16 +1130,17 @@ get_mm_leaf(PARAM *param, COND *conf_func, Field *field, KEY_PART *key_part,
all rows between 'X' and 'X ...'
*/
uint length= uint2korr(str+maybe_null);
- str2= str+ key_part->part_length + maybe_null;
+ str2= str+ key_part->store_length;
/* remove end space */
while (length > 0 && str[length+HA_KEY_BLOB_LENGTH+maybe_null-1] == ' ')
length--;
int2store(str+maybe_null, length);
/* Create key that is space filled */
memcpy(str2, str, length + HA_KEY_BLOB_LENGTH + maybe_null);
- bfill(str2+ length+ HA_KEY_BLOB_LENGTH +maybe_null,
- key_part->part_length-length - HA_KEY_BLOB_LENGTH, ' ');
- int2store(str2+maybe_null, key_part->part_length - HA_KEY_BLOB_LENGTH);
+ my_fill_8bit(field->charset(),
+ str2+ length+ HA_KEY_BLOB_LENGTH +maybe_null,
+ key_part->length-length, ' ');
+ int2store(str2+maybe_null, key_part->length);
}
if (!(tree=new SEL_ARG(field,str,str2)))
DBUG_RETURN(0); // out of memory
@@ -2236,7 +2247,7 @@ check_quick_keys(PARAM *param,uint idx,SEL_ARG *key_tree,
uint tmp_min_flag,tmp_max_flag,keynr;
char *tmp_min_key=min_key,*tmp_max_key=max_key;
- key_tree->store(param->key[idx][key_tree->part].part_length,
+ key_tree->store(param->key[idx][key_tree->part].store_length,
&tmp_min_key,min_key_flag,&tmp_max_key,max_key_flag);
uint min_key_length= (uint) (tmp_min_key- param->min_key);
uint max_key_length= (uint) (tmp_max_key- param->max_key);
@@ -2373,7 +2384,7 @@ get_quick_keys(PARAM *param,QUICK_SELECT *quick,KEY_PART *key,
return 1;
}
char *tmp_min_key=min_key,*tmp_max_key=max_key;
- key_tree->store(key[key_tree->part].part_length,
+ key_tree->store(key[key_tree->part].store_length,
&tmp_min_key,min_key_flag,&tmp_max_key,max_key_flag);
if (key_tree->next_key_part &&
@@ -2491,13 +2502,10 @@ static bool null_part_in_key(KEY_PART *key_part, const char *key, uint length)
{
for (const char *end=key+length ;
key < end;
- key+= key_part++->part_length)
+ key+= key_part++->store_length)
{
- if (key_part->null_bit)
- {
- if (*key++)
- return 1;
- }
+ if (key_part->null_bit && *key)
+ return 1;
}
return 0;
}
@@ -2541,9 +2549,8 @@ QUICK_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table, TABLE_REF *ref)
{
key_part->part=part;
key_part->field= key_info->key_part[part].field;
- key_part->part_length= key_info->key_part[part].length;
- if (key_part->field->type() == FIELD_TYPE_BLOB)
- key_part->part_length+=HA_KEY_BLOB_LENGTH;
+ key_part->length= key_info->key_part[part].length;
+ key_part->store_length= key_info->key_part[part].store_length;
key_part->null_bit= key_info->key_part[part].null_bit;
}
if (quick->ranges.push_back(range))
@@ -2668,14 +2675,16 @@ int QUICK_SELECT::cmp_next(QUICK_RANGE *range_arg)
return 0; /* key can't be to large */
KEY_PART *key_part=key_parts;
+ uint store_length;
for (char *key=range_arg->max_key, *end=key+range_arg->max_length;
key < end;
- key+= key_part++->part_length)
+ key+= store_length, key_part++)
{
int cmp;
+ store_length= key_part->store_length;
if (key_part->null_bit)
{
- if (*key++)
+ if (*key)
{
if (!key_part->field->is_null())
return 1;
@@ -2683,13 +2692,15 @@ int QUICK_SELECT::cmp_next(QUICK_RANGE *range_arg)
}
else if (key_part->field->is_null())
return 0;
+ key++; // Skip null byte
+ store_length--;
}
- if ((cmp=key_part->field->key_cmp((byte*) key, key_part->part_length)) < 0)
+ if ((cmp=key_part->field->key_cmp((byte*) key, key_part->length)) < 0)
return 0;
if (cmp > 0)
return 1;
}
- return (range_arg->flag & NEAR_MAX) ? 1 : 0; // Exact match
+ return (range_arg->flag & NEAR_MAX) ? 1 : 0; // Exact match
}
@@ -2841,15 +2852,18 @@ int QUICK_SELECT_DESC::cmp_prev(QUICK_RANGE *range_arg)
return 0; /* key can't be to small */
KEY_PART *key_part = key_parts;
+ uint store_length;
+
for (char *key = range_arg->min_key, *end = key + range_arg->min_length;
key < end;
- key += key_part++->part_length)
+ key += store_length, key_part++)
{
int cmp;
+ store_length= key_part->store_length;
if (key_part->null_bit)
{
// this key part allows null values; NULL is lower than everything else
- if (*key++)
+ if (*key)
{
// the range is expecting a null value
if (!key_part->field->is_null())
@@ -2858,9 +2872,11 @@ int QUICK_SELECT_DESC::cmp_prev(QUICK_RANGE *range_arg)
}
else if (key_part->field->is_null())
return 1; // null -- outside the range
+ key++;
+ store_length--;
}
if ((cmp = key_part->field->key_cmp((byte*) key,
- key_part->part_length)) > 0)
+ key_part->length)) > 0)
return 0;
if (cmp < 0)
return 1;
@@ -2888,23 +2904,20 @@ bool QUICK_SELECT_DESC::range_reads_after_key(QUICK_RANGE *range_arg)
bool QUICK_SELECT_DESC::test_if_null_range(QUICK_RANGE *range_arg,
uint used_key_parts)
{
- uint offset,end;
+ uint offset, end;
KEY_PART *key_part = key_parts,
*key_part_end= key_part+used_key_parts;
for (offset= 0, end = min(range_arg->min_length, range_arg->max_length) ;
offset < end && key_part != key_part_end ;
- offset += key_part++->part_length)
+ offset+= key_part++->store_length)
{
- uint null_length=test(key_part->null_bit);
if (!memcmp((char*) range_arg->min_key+offset,
(char*) range_arg->max_key+offset,
- key_part->part_length + null_length))
- {
- offset+=null_length;
+ key_part->store_length))
continue;
- }
- if (null_length && range_arg->min_key[offset])
+
+ if (key_part->null_bit && range_arg->min_key[offset])
return 1; // min_key is null and max_key isn't
// Range doesn't cover NULL. This is ok if there is no more null parts
break;
@@ -2946,33 +2959,34 @@ static void
print_key(KEY_PART *key_part,const char *key,uint used_length)
{
char buff[1024];
+ const char *key_end= key+used_length;
String tmp(buff,sizeof(buff),&my_charset_bin);
+ uint store_length;
- for (uint length=0;
- length < used_length ;
- length+=key_part->part_length, key+=key_part->part_length, key_part++)
+ for (; key < key_end; key+=store_length, key_part++)
{
- Field *field=key_part->field;
- if (length != 0)
- fputc('/',DBUG_FILE);
+ Field *field= key_part->field;
+ uint store_length= key_part->store_length;
+
if (field->real_maybe_null())
{
- length++; // null byte is not in part_length
- if (*key++)
+ if (*key)
{
fwrite("NULL",sizeof(char),4,DBUG_FILE);
continue;
}
+ key++;
+ store_length--;
}
- field->set_key_image((char*) key,key_part->part_length -
- ((field->type() == FIELD_TYPE_BLOB) ?
- HA_KEY_BLOB_LENGTH : 0),
- field->charset());
+ field->set_key_image((char*) key, key_part->length, field->charset());
field->val_str(&tmp,&tmp);
fwrite(tmp.ptr(),sizeof(char),tmp.length(),DBUG_FILE);
+ if (key+store_length < key_end)
+ fputc('/',DBUG_FILE);
}
}
+
static void print_quick(QUICK_SELECT *quick,const key_map* needed_reg)
{
QUICK_RANGE *range;
diff --git a/sql/opt_range.h b/sql/opt_range.h
index bf10c02c295..4af56393a57 100644
--- a/sql/opt_range.h
+++ b/sql/opt_range.h
@@ -35,7 +35,7 @@
typedef struct st_key_part {
- uint16 key,part,part_length;
+ uint16 key,part, store_length, length;
uint8 null_bit;
Field *field;
Field::imagetype image_type;
@@ -68,7 +68,7 @@ class QUICK_RANGE :public Sql_alloc {
class QUICK_SELECT {
public:
- bool next,dont_free;
+ bool next,dont_free,sorted;
int error;
uint index, max_used_key_length, used_key_parts;
TABLE *head;
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 44d35f5c165..5cad16f31df 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -84,10 +84,10 @@ extern "C" void free_user_var(user_var_entry *entry)
****************************************************************************/
THD::THD():user_time(0), current_statement(0), is_fatal_error(0),
- no_table_fix_fields_cache(0),
last_insert_id_used(0),
insert_id_used(0), rand_used(0), in_lock_tables(0),
- global_read_lock(0), bootstrap(0)
+ global_read_lock(0), bootstrap(0),
+ no_table_fix_fields_cache(0)
{
host= user= priv_user= db= ip=0;
host_or_ip= "connecting host";
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 3108b06b396..0f816ff97bf 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -7152,6 +7152,8 @@ test_if_skip_sort_order(JOIN_TAB *tab,ORDER *order,ha_rows select_limit,
/* fall through */
}
}
+ else if (select && select->quick)
+ select->quick->sorted= 1;
DBUG_RETURN(1); /* No need to sort */
}
}
diff --git a/sql/table.cc b/sql/table.cc
index 23d99466a83..1b59056ffe7 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -553,7 +553,6 @@ int openfrm(const char *name, const char *alias, uint db_stat, uint prgflag,
keyinfo->key_length+= HA_KEY_NULL_LENGTH;
}
if (field->type() == FIELD_TYPE_BLOB ||
- field->type() == FIELD_TYPE_GEOMETRY ||
field->real_type() == FIELD_TYPE_VAR_STRING)
{
if (field->type() == FIELD_TYPE_BLOB)
View Lorry Controller Status