static int FTB_WORD_cmp(my_off_t *v, FTB_WORD *a, FTB_WORD *b)
{
int i;
/* if a==curdoc, take it as a < b */
if (v && a->docid[0] == *v)
return -1;
/* ORDER BY docid, ndepth DESC */
i=CMP_NUM(a->docid[0], b->docid[0]);
if (!i)
i=CMP_NUM(b->ndepth,a->ndepth);
return i;
}
static int FTB_WORD_cmp_list(CHARSET_INFO *cs, FTB_WORD **a, FTB_WORD **b)
{
/* ORDER BY word, ndepth */
int i= ha_compare_text(cs, (uchar*) (*a)->word + 1, (*a)->len - 1,
(uchar*) (*b)->word + 1, (*b)->len - 1, 0, 0);
if (!i)
i= CMP_NUM((*a)->ndepth, (*b)->ndepth);
return i;
}
int ld_ldap2fldex(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg, int init)
{
int i;
struct ld_fld* lfld;
str v;
if (fld == NULL || msg == NULL) return 0;
for(i = 0; !DB_FLD_EMPTY(fld) && !DB_FLD_LAST(fld[i]); i++) {
lfld = DB_GET_PAYLOAD(fld + i);
if (init) {
if (fld[i].type == DB_NONE) {
switch (lfld->syntax) {
case LD_SYNTAX_STRING:
fld[i].type = DB_STR;
break;
case LD_SYNTAX_INT:
case LD_SYNTAX_BOOL:
case LD_SYNTAX_BIT:
fld[i].type = DB_INT;
break;
case LD_SYNTAX_FLOAT:
fld[i].type = DB_FLOAT;
break;
case LD_SYNTAX_GENTIME:
fld[i].type = DB_DATETIME;
break;
case LD_SYNTAX_BIN:
fld[i].type = DB_BITMAP;
break;
}
}
/* free the values of the previous object */
if (lfld->values) ldap_value_free_len(lfld->values);
lfld->values = ldap_get_values_len(ldap, msg, lfld->attr.s);
lfld->index = 0;
if (lfld->values == NULL || lfld->values[0] == NULL) {
fld[i].flags |= DB_NULL;
/* index == 0 means no value available */
lfld->valuesnum = 0;
if (lfld->client_side_filtering && lfld->filter) {
int j;
/* if the all filter conditions requires NULL value then we can accept the record */
for (j=0; lfld->filter[j]; j++) {
if (lfld->filter[j]->flags & DB_NULL && lfld->filter[j]->op == DB_EQ) {
continue;
}
return 1; /* get next record */
}
}
} else {
/* init the number of values */
fld[i].flags &= ~DB_NULL;
lfld->valuesnum = ldap_count_values_len(lfld->values);
if ((lfld->valuesnum > 1 || lfld->client_side_filtering) && lfld->filter) {
/* in case of multivalue we must check if value fits in filter criteria.
LDAP returns record (having each multivalue) if one particular
multivalue fits in filter provided to LDAP search. We need
filter out these values manually. It not perfect because
LDAP filtering may be based on different rule/locale than
raw (ASCII,...) comparision.
We reorder values so we'll have interesting values located from top up to valuesnum at the end.
The same algorithm is applied for client side filtering
*/
do {
int passed, j;
for (j=0, passed = 1; lfld->filter[j] && passed; j++) {
int op; /* b0..less, b1..equal, b2..greater, zero..non equal */
op = 0x00;
if (lfld->filter[j]->flags & DB_NULL) {
/* always non equal because field is not NULL */
}
else {
v.s = lfld->values[lfld->index]->bv_val;
v.len = lfld->values[lfld->index]->bv_len;
if (ldap_fld2db_fld(fld + i, v) < 0) {
passed = 0;
break; /* for loop */
}
else {
db_fld_val_t v;
int t;
static char buf[30];
t = lfld->filter[j]->type;
/* we need compare value provided in match condition with value returned by LDAP.
The match value should be the same type as LDAP value obtained during
db_cmd(). We implement some basic conversions.
*/
v = lfld->filter[j]->v;
if (t == DB_CSTR) {
v.lstr.s = v.cstr;
v.lstr.len = strlen(v.lstr.s);
t = DB_STR;
}
switch (fld[i].type) {
case DB_CSTR:
fld[i].v.lstr.s = fld[i].v.cstr;
fld[i].v.lstr.len = strlen(fld[i].v.lstr.s);
fld[i].type = DB_STR;
/* no break */
case DB_STR:
switch (t) {
case DB_INT:
v.lstr.len = snprintf(buf, sizeof(buf)-1, "%d", v.int4);
v.lstr.s = buf;
break;
/* numeric conversion for double/float not supported because of non unique string representation */
default:
goto skip_conv;
}
break;
case DB_INT:
switch (t) {
case DB_DOUBLE:
if ((double)(int)v.dbl != (double)v.dbl)
goto skip_conv;
v.int4 = v.dbl;
break;
case DB_FLOAT:
if ((float)(int)v.flt != (float)v.flt)
goto skip_conv;
v.int4 = v.flt;
break;
case DB_STR:
if (v.lstr.len > 0) {
char c, *p;
int n;
c = v.lstr.s[v.lstr.len];
v.lstr.s[v.lstr.len] = '\0';
n = strtol(v.lstr.s, &p, 10);
v.lstr.s[v.lstr.len] = c;
if ((*p) != '\0') {
goto skip_conv;
}
v.int4 = n;
}
break;
default:
goto skip_conv;
}
break;
case DB_FLOAT:
switch (t) {
case DB_DOUBLE:
v.flt = v.dbl;
break;
case DB_INT:
v.flt = v.int4;
break;
#ifdef __USE_ISOC99
case DB_STR:
if (v.lstr.len > 0) {
char c, *p;
float n;
c = v.lstr.s[v.lstr.len];
v.lstr.s[v.lstr.len] = '\0';
n = strtof(v.lstr.s, &p);
v.lstr.s[v.lstr.len] = c;
if ((*p) != '\0') {
goto skip_conv;
}
v.flt = n;
}
break;
#endif
default:
goto skip_conv;
}
break;
case DB_DOUBLE:
switch (t) {
case DB_FLOAT:
v.dbl = v.flt;
break;
case DB_INT:
v.dbl = v.int4;
break;
case DB_STR:
if (v.lstr.len > 0) {
char c, *p;
double n;
c = v.lstr.s[v.lstr.len];
v.lstr.s[v.lstr.len] = '\0';
n = strtod(v.lstr.s, &p);
v.lstr.s[v.lstr.len] = c;
if ((*p) != '\0') {
goto skip_conv;
}
v.dbl = n;
}
break;
default:
goto skip_conv;
}
break;
case DB_BLOB:
case DB_BITMAP:
case DB_DATETIME:
default:
goto skip_conv;
}
t = fld[i].type;
skip_conv:
if (t == fld[i].type) {
switch (fld[i].type) {
case DB_CSTR: /* impossible, already converted to DB_STR */
case DB_STR:
if (fld[i].v.lstr.len == v.lstr.len) {
op = strncmp(fld[i].v.lstr.s, v.lstr.s, v.lstr.len);
if (op < 0)
op = 0x01;
else if (op > 0)
op = 0x04;
else
op = 0x02;
}
else if (fld[i].v.lstr.len < v.lstr.len) {
op = strncmp(fld[i].v.lstr.s, v.lstr.s, fld[i].v.lstr.len);
if (op < 0)
op = 0x01;
else
op = 0x04;
}
else /* if (fld[i].v.lstr.len > v.lstr.len) */ {
op = strncmp(fld[i].v.lstr.s, v.lstr.s, v.lstr.len);
if (op > 0)
op = 0x04;
else
op = 0x01;
}
break;
case DB_BLOB:
if (fld[i].v.blob.len == v.blob.len && memcmp(fld[i].v.blob.s, v.blob.s, v.blob.len) == 0)
op = 0x02;
break;
case DB_INT:
CMP_NUM(fld[i].v, v, int4);
break;
case DB_BITMAP:
CMP_NUM(fld[i].v, v, bitmap);
break;
case DB_DATETIME:
CMP_NUM(fld[i].v, v, time);
break;
case DB_FLOAT:
CMP_NUM(fld[i].v, v, flt);
break;
case DB_DOUBLE:
CMP_NUM(fld[i].v, v, dbl);
break;
default:
;
}
}
}
}
switch (lfld->filter[j]->op) {
case DB_EQ:
passed = op == 0x02;
break;
case DB_NE:
passed = (op & 0x02) == 0;
break;
case DB_LT:
passed = op == 0x01;
break;
case DB_LEQ:
passed = op == 0x01 || op == 0x02;
break;
case DB_GT:
passed = op == 0x04;
break;
case DB_GEQ:
passed = op == 0x04 || op == 0x02;
break;
default:
;
}
}
if (passed) {
lfld->index++;
}
else {
char *save_bvval;
int save_bvlen;
int i;
/* shift following values, push useless value at the end and decrease num of values */
save_bvval = lfld->values[lfld->index]->bv_val;
save_bvlen = lfld->values[lfld->index]->bv_len;
for (i=lfld->index+1; i < lfld->valuesnum; i++) {
lfld->values[i-1]->bv_val = lfld->values[i]->bv_val;
lfld->values[i-1]->bv_len = lfld->values[i]->bv_len;
}
lfld->values[lfld->valuesnum-1]->bv_val = save_bvval;
lfld->values[lfld->valuesnum-1]->bv_len = save_bvlen;
lfld->valuesnum--;
}
} while (lfld->index < lfld->valuesnum);
if (lfld->valuesnum == 0) {
return 1; /* get next record */
}
}
}
/* pointer to the current value */
lfld->index = 0;
}
/* this is an empty value */
if (!lfld->valuesnum)
continue;
v.s = lfld->values[lfld->index]->bv_val;
v.len = lfld->values[lfld->index]->bv_len;
if (ldap_fld2db_fld(fld + i, v) < 0)
return -1;
}
return 0;
}
int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
register uchar *b, uint key_length, uint nextflag,
uint *diff_pos)
{
int flag;
int16 s_1,s_2;
int32 l_1,l_2;
uint32 u_1,u_2;
float f_1,f_2;
double d_1,d_2;
uint next_key_length;
uchar *orig_b= b;
*diff_pos=0;
for ( ; (int) key_length >0 ; key_length=next_key_length, keyseg++)
{
uchar *end;
uint piks=! (keyseg->flag & HA_NO_SORT);
(*diff_pos)++;
diff_pos[1]= (uint)(b - orig_b);
/* Handle NULL part */
if (keyseg->null_bit)
{
key_length--;
if (*a != *b && piks)
{
flag = (int) *a - (int) *b;
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
}
b++;
if (!*a++) /* If key was NULL */
{
if (nextflag == (SEARCH_FIND | SEARCH_UPDATE))
nextflag=SEARCH_SAME; /* Allow duplicate keys */
else if (nextflag & SEARCH_NULL_ARE_NOT_EQUAL)
{
/*
This is only used from mi_check() to calculate cardinality.
It can't be used when searching for a key as this would cause
compare of (a,b) and (b,a) to return the same value.
*/
return -1;
}
next_key_length=key_length;
continue; /* To next key part */
}
}
end= a+ min(keyseg->length,key_length);
next_key_length=key_length-keyseg->length;
switch ((enum ha_base_keytype) keyseg->type) {
case HA_KEYTYPE_TEXT: /* Ascii; Key is converted */
if (keyseg->flag & HA_SPACE_PACK)
{
int a_length,b_length,pack_length;
get_key_length(a_length,a);
get_key_pack_length(b_length,pack_length,b);
next_key_length=key_length-b_length-pack_length;
if (piks &&
(flag=ha_compare_text(keyseg->charset,a,a_length,b,b_length,
(my_bool) ((nextflag & SEARCH_PREFIX) &&
next_key_length <= 0),
(my_bool)!(nextflag & SEARCH_PREFIX))))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a+=a_length;
b+=b_length;
break;
}
else
{
uint length=(uint) (end-a), a_length=length, b_length=length;
if (piks &&
(flag= ha_compare_text(keyseg->charset, a, a_length, b, b_length,
(my_bool) ((nextflag & SEARCH_PREFIX) &&
next_key_length <= 0),
(my_bool)!(nextflag & SEARCH_PREFIX))))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a=end;
b+=length;
}
break;
case HA_KEYTYPE_BINARY:
case HA_KEYTYPE_BIT:
if (keyseg->flag & HA_SPACE_PACK)
{
int a_length,b_length,pack_length;
get_key_length(a_length,a);
get_key_pack_length(b_length,pack_length,b);
next_key_length=key_length-b_length-pack_length;
if (piks &&
(flag=compare_bin(a,a_length,b,b_length,
(my_bool) ((nextflag & SEARCH_PREFIX) &&
next_key_length <= 0),1)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a+=a_length;
b+=b_length;
break;
}
else
{
uint length=keyseg->length;
if (piks &&
(flag=compare_bin(a,length,b,length,
(my_bool) ((nextflag & SEARCH_PREFIX) &&
next_key_length <= 0),0)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a+=length;
b+=length;
}
break;
case HA_KEYTYPE_VARTEXT1:
case HA_KEYTYPE_VARTEXT2:
{
int a_length,b_length,pack_length;
get_key_length(a_length,a);
get_key_pack_length(b_length,pack_length,b);
next_key_length=key_length-b_length-pack_length;
if (piks &&
(flag= ha_compare_text(keyseg->charset,a,a_length,b,b_length,
(my_bool) ((nextflag & SEARCH_PREFIX) &&
next_key_length <= 0),
(my_bool) ((nextflag & (SEARCH_FIND |
SEARCH_UPDATE)) ==
SEARCH_FIND &&
! (keyseg->flag &
HA_END_SPACE_ARE_EQUAL)))))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a+= a_length;
b+= b_length;
break;
}
break;
case HA_KEYTYPE_VARBINARY1:
case HA_KEYTYPE_VARBINARY2:
{
int a_length,b_length,pack_length;
get_key_length(a_length,a);
get_key_pack_length(b_length,pack_length,b);
next_key_length=key_length-b_length-pack_length;
if (piks &&
(flag=compare_bin(a,a_length,b,b_length,
(my_bool) ((nextflag & SEARCH_PREFIX) &&
next_key_length <= 0), 0)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a+=a_length;
b+=b_length;
}
break;
case HA_KEYTYPE_INT8:
{
int i_1= (int) *((signed char*) a);
int i_2= (int) *((signed char*) b);
if (piks && (flag = CMP_NUM(i_1,i_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b++;
break;
}
case HA_KEYTYPE_SHORT_INT:
s_1= mi_sint2korr(a);
s_2= mi_sint2korr(b);
if (piks && (flag = CMP_NUM(s_1,s_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 2; /* sizeof(short int); */
break;
case HA_KEYTYPE_USHORT_INT:
{
uint16 us_1,us_2;
us_1= mi_sint2korr(a);
us_2= mi_sint2korr(b);
if (piks && (flag = CMP_NUM(us_1,us_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+=2; /* sizeof(short int); */
break;
}
case HA_KEYTYPE_LONG_INT:
l_1= mi_sint4korr(a);
l_2= mi_sint4korr(b);
if (piks && (flag = CMP_NUM(l_1,l_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 4; /* sizeof(long int); */
break;
case HA_KEYTYPE_ULONG_INT:
u_1= mi_sint4korr(a);
u_2= mi_sint4korr(b);
if (piks && (flag = CMP_NUM(u_1,u_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 4; /* sizeof(long int); */
break;
case HA_KEYTYPE_INT24:
l_1=mi_sint3korr(a);
l_2=mi_sint3korr(b);
if (piks && (flag = CMP_NUM(l_1,l_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 3;
break;
case HA_KEYTYPE_UINT24:
l_1=mi_uint3korr(a);
l_2=mi_uint3korr(b);
if (piks && (flag = CMP_NUM(l_1,l_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 3;
break;
case HA_KEYTYPE_FLOAT:
mi_float4get(f_1,a);
mi_float4get(f_2,b);
/*
The following may give a compiler warning about floating point
comparison not being safe, but this is ok in this context as
we are bascily doing sorting
*/
if (piks && (flag = CMP_NUM(f_1,f_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 4; /* sizeof(float); */
break;
case HA_KEYTYPE_DOUBLE:
mi_float8get(d_1,a);
mi_float8get(d_2,b);
/*
The following may give a compiler warning about floating point
comparison not being safe, but this is ok in this context as
we are bascily doing sorting
*/
if (piks && (flag = CMP_NUM(d_1,d_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 8; /* sizeof(double); */
break;
case HA_KEYTYPE_NUM: /* Numeric key */
{
int swap_flag= 0;
int alength,blength;
if (keyseg->flag & HA_REVERSE_SORT)
{
swap_variables(uchar*, a, b);
swap_flag=1; /* Remember swap of a & b */
end= a+ (int) (end-b);
}
if (keyseg->flag & HA_SPACE_PACK)
{
alength= *a++; blength= *b++;
end=a+alength;
next_key_length=key_length-blength-1;
}
else
{
alength= (int) (end-a);
blength=keyseg->length;
/* remove pre space from keys */
for ( ; alength && *a == ' ' ; a++, alength--) ;
for ( ; blength && *b == ' ' ; b++, blength--) ;
}
if (piks)
{
if (*a == '-')
{
if (*b != '-')
return -1;
a++; b++;
swap_variables(uchar*, a, b);
swap_variables(int, alength, blength);
swap_flag=1-swap_flag;
alength--; blength--;
end=a+alength;
}
else if (*b == '-')
return 1;
while (alength && (*a == '+' || *a == '0'))
{
a++; alength--;
}
while (blength && (*b == '+' || *b == '0'))
{
b++; blength--;
}
if (alength != blength)
return (alength < blength) ? -1 : 1;
while (a < end)
if (*a++ != *b++)
return ((int) a[-1] - (int) b[-1]);
}
else
{
b+=(end-a);
a=end;
}
if (swap_flag) /* Restore pointers */
swap_variables(uchar*, a, b);
break;
}
#ifdef HAVE_LONG_LONG
case HA_KEYTYPE_LONGLONG:
{
longlong ll_a,ll_b;
ll_a= mi_sint8korr(a);
ll_b= mi_sint8korr(b);
if (piks && (flag = CMP_NUM(ll_a,ll_b)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 8;
break;
}
case HA_KEYTYPE_ULONGLONG:
{
ulonglong ll_a,ll_b;
ll_a= mi_uint8korr(a);
ll_b= mi_uint8korr(b);
if (piks && (flag = CMP_NUM(ll_a,ll_b)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 8;
break;
}
#endif
case HA_KEYTYPE_END: /* Ready */
goto end; /* diff_pos is incremented */
}
}
(*diff_pos)++;
end:
if (!(nextflag & SEARCH_FIND))
{
uint i;
if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST)) /* Find record after key */
return (nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
flag=0;
for (i=keyseg->length ; i-- > 0 ; )
{
if (*a++ != *b++)
{
flag= FCMP(a[-1],b[-1]);
break;
}
}
if (nextflag & SEARCH_SAME)
return (flag); /* read same */
if (nextflag & SEARCH_BIGGER)
return (flag <= 0 ? -1 : 1); /* read next */
return (flag < 0 ? -1 : 1); /* read previous */
}
return 0;
} /* ha_key_cmp */
int ha_key_cmp(HA_KEYSEG *keyseg, const uchar *a,
const uchar *b, uint key_length, uint32 nextflag,
uint *diff_pos)
{
int flag;
int16 s_1,s_2;
int32 l_1,l_2;
uint32 u_1,u_2;
float f_1,f_2;
double d_1,d_2;
uint next_key_length;
const uchar *orig_b= b;
*diff_pos=0;
for ( ; (int) key_length >0 ; key_length=next_key_length, keyseg++)
{
const uchar *end;
uint piks=! (keyseg->flag & HA_NO_SORT);
(*diff_pos)++;
diff_pos[1]= (uint)(b - orig_b);
/* Handle NULL part */
if (keyseg->null_bit)
{
key_length--;
if (*a != *b && piks)
{
flag = (int) *a - (int) *b;
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
}
b++;
if (!*a++) /* If key was NULL */
{
if ((nextflag & (SEARCH_FIND | SEARCH_UPDATE | SEARCH_INSERT |
SEARCH_NULL_ARE_EQUAL)) ==
(SEARCH_FIND | SEARCH_UPDATE | SEARCH_INSERT))
{
/* Allow duplicate keys */
nextflag= (nextflag & ~(SEARCH_FIND | SEARCH_UPDATE)) | SEARCH_SAME;
}
else if (nextflag & SEARCH_NULL_ARE_NOT_EQUAL)
{
/*
This is only used from mi_check() to calculate cardinality.
It can't be used when searching for a key as this would cause
compare of (a,b) and (b,a) to return the same value.
*/
return -1;
}
next_key_length=key_length;
continue; /* To next key part */
}
}
end= a+ MY_MIN(keyseg->length,key_length);
next_key_length=key_length-keyseg->length;
switch ((enum ha_base_keytype) keyseg->type) {
case HA_KEYTYPE_TEXT: /* Ascii; Key is converted */
if (keyseg->flag & HA_SPACE_PACK)
{
int a_length,b_length,pack_length;
get_key_length(a_length,a);
get_key_pack_length(b_length,pack_length,b);
next_key_length=key_length-b_length-pack_length;
if (piks &&
(flag=ha_compare_text(keyseg->charset,a,a_length,b,b_length,
(my_bool) ((nextflag & SEARCH_PREFIX) &&
next_key_length <= 0),
(my_bool)!(nextflag & SEARCH_PREFIX))))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a+=a_length;
b+=b_length;
break;
}
else
{
uint length=(uint) (end-a), a_length=length, b_length=length;
if (piks &&
(flag= ha_compare_text(keyseg->charset, a, a_length, b, b_length,
(my_bool) ((nextflag & SEARCH_PREFIX) &&
next_key_length <= 0),
(my_bool)!(nextflag & SEARCH_PREFIX))))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a=end;
b+=length;
}
break;
case HA_KEYTYPE_BINARY:
case HA_KEYTYPE_BIT:
if (keyseg->flag & HA_SPACE_PACK)
{
int a_length,b_length,pack_length;
get_key_length(a_length,a);
get_key_pack_length(b_length,pack_length,b);
next_key_length=key_length-b_length-pack_length;
if (piks &&
(flag=compare_bin(a,a_length,b,b_length,
(my_bool) ((nextflag & SEARCH_PREFIX) &&
next_key_length <= 0),1)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a+=a_length;
b+=b_length;
break;
}
else
{
uint length=keyseg->length;
if (piks &&
(flag=compare_bin(a,length,b,length,
(my_bool) ((nextflag & SEARCH_PREFIX) &&
next_key_length <= 0),0)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a+=length;
b+=length;
}
break;
case HA_KEYTYPE_VARTEXT1:
case HA_KEYTYPE_VARTEXT2:
{
int a_length,b_length,pack_length;
get_key_length(a_length,a);
get_key_pack_length(b_length,pack_length,b);
next_key_length=key_length-b_length-pack_length;
if (piks &&
(flag= ha_compare_text(keyseg->charset,a,a_length,b,b_length,
(my_bool) ((nextflag & SEARCH_PREFIX) &&
next_key_length <= 0),
(my_bool) ((nextflag & (SEARCH_FIND |
SEARCH_UPDATE)) ==
SEARCH_FIND &&
! (keyseg->flag &
HA_END_SPACE_ARE_EQUAL)))))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a+= a_length;
b+= b_length;
break;
}
break;
case HA_KEYTYPE_VARBINARY1:
case HA_KEYTYPE_VARBINARY2:
{
int a_length,b_length,pack_length;
get_key_length(a_length,a);
get_key_pack_length(b_length,pack_length,b);
next_key_length=key_length-b_length-pack_length;
if (piks &&
(flag=compare_bin(a,a_length,b,b_length,
(my_bool) ((nextflag & SEARCH_PREFIX) &&
next_key_length <= 0), 0)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a+=a_length;
b+=b_length;
}
break;
case HA_KEYTYPE_INT8:
{
int i_1= (int) *((signed char*) a);
int i_2= (int) *((signed char*) b);
if (piks && (flag = CMP_NUM(i_1,i_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b++;
break;
}
case HA_KEYTYPE_SHORT_INT:
s_1= mi_sint2korr(a);
s_2= mi_sint2korr(b);
if (piks && (flag = CMP_NUM(s_1,s_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 2; /* sizeof(short int); */
break;
case HA_KEYTYPE_USHORT_INT:
{
uint16 us_1,us_2;
us_1= mi_sint2korr(a);
us_2= mi_sint2korr(b);
if (piks && (flag = CMP_NUM(us_1,us_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+=2; /* sizeof(short int); */
break;
}
case HA_KEYTYPE_LONG_INT:
l_1= mi_sint4korr(a);
l_2= mi_sint4korr(b);
if (piks && (flag = CMP_NUM(l_1,l_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 4; /* sizeof(long int); */
break;
case HA_KEYTYPE_ULONG_INT:
u_1= mi_sint4korr(a);
u_2= mi_sint4korr(b);
if (piks && (flag = CMP_NUM(u_1,u_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 4; /* sizeof(long int); */
break;
case HA_KEYTYPE_INT24:
l_1=mi_sint3korr(a);
l_2=mi_sint3korr(b);
if (piks && (flag = CMP_NUM(l_1,l_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 3;
break;
case HA_KEYTYPE_UINT24:
l_1=mi_uint3korr(a);
l_2=mi_uint3korr(b);
if (piks && (flag = CMP_NUM(l_1,l_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 3;
break;
case HA_KEYTYPE_FLOAT:
mi_float4get(f_1,a);
mi_float4get(f_2,b);
/*
The following may give a compiler warning about floating point
comparison not being safe, but this is ok in this context as
we are bascily doing sorting
*/
if (piks && (flag = CMP_NUM(f_1,f_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 4; /* sizeof(float); */
break;
case HA_KEYTYPE_DOUBLE:
mi_float8get(d_1,a);
mi_float8get(d_2,b);
/*
The following may give a compiler warning about floating point
comparison not being safe, but this is ok in this context as
we are bascily doing sorting
*/
if (piks && (flag = CMP_NUM(d_1,d_2)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 8; /* sizeof(double); */
break;
case HA_KEYTYPE_NUM: /* Numeric key */
{
int swap_flag= 0;
int alength,blength;
if (keyseg->flag & HA_REVERSE_SORT)
{
swap_variables(const uchar*, a, b);
swap_flag=1; /* Remember swap of a & b */
end= a+ (int) (end-b);
}
if (keyseg->flag & HA_SPACE_PACK)
{
alength= *a++; blength= *b++;
end=a+alength;
next_key_length=key_length-blength-1;
}
else
{
alength= (int) (end-a);
blength=keyseg->length;
/* remove pre space from keys */
for ( ; alength && *a == ' ' ; a++, alength--) ;
for ( ; blength && *b == ' ' ; b++, blength--) ;
}
if (piks)
{
if (*a == '-')
{
if (*b != '-')
return -1;
a++; b++;
swap_variables(const uchar*, a, b);
swap_variables(int, alength, blength);
swap_flag=1-swap_flag;
alength--; blength--;
end=a+alength;
}
else if (*b == '-')
return 1;
while (alength && (*a == '+' || *a == '0'))
{
a++; alength--;
}
while (blength && (*b == '+' || *b == '0'))
{
b++; blength--;
}
if (alength != blength)
return (alength < blength) ? -1 : 1;
while (a < end)
if (*a++ != *b++)
return ((int) a[-1] - (int) b[-1]);
}
else
{
b+=(end-a);
a=end;
}
if (swap_flag) /* Restore pointers */
swap_variables(const uchar*, a, b);
break;
}
#ifdef HAVE_LONG_LONG
case HA_KEYTYPE_LONGLONG:
{
longlong ll_a,ll_b;
ll_a= mi_sint8korr(a);
ll_b= mi_sint8korr(b);
if (piks && (flag = CMP_NUM(ll_a,ll_b)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 8;
break;
}
case HA_KEYTYPE_ULONGLONG:
{
ulonglong ll_a,ll_b;
ll_a= mi_uint8korr(a);
ll_b= mi_uint8korr(b);
if (piks && (flag = CMP_NUM(ll_a,ll_b)))
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
a= end;
b+= 8;
break;
}
#endif
case HA_KEYTYPE_END: /* Ready */
goto end; /* diff_pos is incremented */
}
}
(*diff_pos)++;
end:
if (!(nextflag & SEARCH_FIND))
{
/*
Compare rowid and possible transid
This happens in the following case:
- INSERT, UPDATE, DELETE when we have not unique keys or
are using versioning
- SEARCH_NEXT, SEARCH_PREVIOUS when we need to restart search
The logic for comparing transid are as follows:
Keys with have a transid have lowest bit in the rowidt. This means that
if we are comparing a key with a transid with another key that doesn't
have a tranid, we must reset the lowest bit for both keys.
When we have transid, the keys are compared in transid order.
A key without a transid is regared to be smaller than a key with
a transid.
*/
uint i;
uchar key_mask, tmp_a, tmp_b;
if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST)) /* Find record after key */
return (nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
key_mask= (uchar) 255;
if (!(nextflag & (SEARCH_USER_KEY_HAS_TRANSID |
SEARCH_PAGE_KEY_HAS_TRANSID)))
{
/*
Neither key has a trid. Only compare row id's and don't
try to store rows in trid order
*/
key_length= keyseg->length;
nextflag&= ~SEARCH_INSERT;
}
else
{
/*
Set key_mask so that we reset the last bit in the rowid before
we compare it. This is needed as the lowest bit in the rowid is
used to mark if the key has a transid or not.
*/
key_mask= (uchar) 254;
if (!test_all_bits(nextflag, (SEARCH_USER_KEY_HAS_TRANSID |
SEARCH_PAGE_KEY_HAS_TRANSID)))
{
/*
No transaction id for user key or for key on page
Ignore transid as at least one of the keys are visible for all
*/
key_length= keyseg->length;
}
else
{
/*
Both keys have trids. No need of special handling of incomplete
trids below.
*/
nextflag&= ~SEARCH_INSERT;
}
}
DBUG_ASSERT(key_length > 0);
for (i= key_length-1 ; (int) i-- > 0 ; )
{
if (*a++ != *b++)
{
flag= FCMP(a[-1],b[-1]);
goto found;
}
}
tmp_a= *a & key_mask;
tmp_b= *b & key_mask;
flag= FCMP(tmp_a, tmp_b);
if (flag == 0 && (nextflag & SEARCH_INSERT))
{
/*
Ensure that on insert we get rows stored in trid order.
If one of the parts doesn't have a trid, this should be regarded
as smaller than the other
*/
return (nextflag & SEARCH_USER_KEY_HAS_TRANSID) ? -1 : 1;
}
found:
if (nextflag & SEARCH_SAME)
return (flag); /* read same */
if (nextflag & SEARCH_BIGGER)
return (flag <= 0 ? -1 : 1); /* read next */
return (flag < 0 ? -1 : 1); /* read previous */
}
return 0;
} /* ha_key_cmp */