« back to all changes in this revision
Viewing changes to src/myxt_xt.cc
- browse files at revision 725
- compare with another revision
- download diff
- download tarball
- view history from revision 725
- Committer: Paul McCullagh
- Date: 2009-11-10 15:17:41 UTC
- Revision ID: paul.mccullagh@primebase.org-20091110151741-skjch5yqshrilo14
Merged changes required to compile with Drizzle
added
removed
src/myxt_xt.cc
36
36
#include <drizzled/current_session.h>
37
37
#include <drizzled/sql_lex.h>
38
38
#include <drizzled/session.h>
39
extern "C" struct charset_info_st *session_charset(Session *session);
39
//extern "C" struct charset_info_st *session_charset(Session *session);
40
40
extern pthread_key_t THR_Session;
41
41
#else
42
42
#include "mysql_priv.h"
171
171
172
172
for (u_int i=0; i<ind->mi_seg_count && (int) k_length > 0; i++, old += keyseg->length, keyseg++)
173
173
{
174
#ifndef DRIZZLED
174
175
enum ha_base_keytype type = (enum ha_base_keytype) keyseg->type;
176
#endif
175
177
u_int length = keyseg->length < k_length ? keyseg->length : k_length;
176
178
u_int char_length;
177
179
xtWord1 *pos;
192
194
pos = old;
193
195
if (keyseg->flag & HA_SPACE_PACK) {
194
196
uchar *end = pos + length;
197
#ifndef DRIZZLED
195
198
if (type != HA_KEYTYPE_NUM) {
199
#endif
196
200
while (end > pos && end[-1] == ' ')
197
201
end--;
202
#ifndef DRIZZLED
198
203
}
199
204
else {
200
205
while (pos < end && pos[0] == ' ')
201
206
pos++;
202
207
}
208
#endif
203
209
k_length -= length;
204
210
length = (u_int) (end-pos);
205
211
FIX_LENGTH(cs, pos, length, char_length);
276
282
char_length= ((cs && cs->mbmaxlen > 1) ? length/cs->mbmaxlen : length);
277
283
278
284
pos = record + keyseg->start;
285
#ifndef DRIZZLED
279
286
if (type == HA_KEYTYPE_BIT)
280
287
{
281
288
if (keyseg->bit_length)
289
296
key+= length;
290
297
continue;
291
298
}
299
#endif
292
300
if (keyseg->flag & HA_SPACE_PACK)
293
301
{
294
302
end = pos + length;
303
#ifndef DRIZZLED
295
304
if (type != HA_KEYTYPE_NUM) {
305
#endif
296
306
while (end > pos && end[-1] == ' ')
297
307
end--;
308
#ifndef DRIZZLED
298
309
}
299
310
else {
300
311
while (pos < end && pos[0] == ' ')
301
312
pos++;
302
313
}
314
#endif
303
315
length = (u_int) (end-pos);
304
316
FIX_LENGTH(cs, pos, length, char_length);
305
317
store_key_length_inc(key,char_length);
333
345
if (keyseg->flag & HA_SWAP_KEY)
334
346
{ /* Numerical column */
335
347
#ifdef HAVE_ISNAN
348
#ifndef DRIZZLED
336
349
if (type == HA_KEYTYPE_FLOAT)
337
350
{
338
351
float nr;
345
358
continue;
346
359
}
347
360
}
348
else if (type == HA_KEYTYPE_DOUBLE) {
361
else
362
#endif
363
if (type == HA_KEYTYPE_DOUBLE) {
349
364
double nr;
350
365
351
366
float8get(nr,pos);
414
429
char_length= ((cs && cs->mbmaxlen > 1) ? length/cs->mbmaxlen : length);
415
430
416
431
pos = record + keyseg->start;
432
#ifndef DRIZZLED
417
433
if (type == HA_KEYTYPE_BIT)
418
434
{
419
435
if (keyseg->bit_length)
427
443
key+= length;
428
444
continue;
429
445
}
446
#endif
430
447
if (keyseg->flag & HA_SPACE_PACK)
431
448
{
432
449
end = pos + length;
450
#ifndef DRIZZLED
433
451
if (type != HA_KEYTYPE_NUM) {
452
#endif
434
453
while (end > pos && end[-1] == ' ')
435
454
end--;
455
#ifndef DRIZZLED
436
456
}
437
457
else {
438
458
while (pos < end && pos[0] == ' ')
439
459
pos++;
440
460
}
461
#endif
441
462
length = (u_int) (end-pos);
442
463
FIX_LENGTH(cs, pos, length, char_length);
443
464
store_key_length_inc(key,char_length);
471
492
if (keyseg->flag & HA_SWAP_KEY)
472
493
{ /* Numerical column */
473
494
#ifdef HAVE_ISNAN
495
#ifndef DRIZZLED
474
496
if (type == HA_KEYTYPE_FLOAT)
475
497
{
476
498
float nr;
483
505
continue;
484
506
}
485
507
}
486
else if (type == HA_KEYTYPE_DOUBLE) {
508
else
509
#endif
510
if (type == HA_KEYTYPE_DOUBLE) {
487
511
double nr;
488
512
489
513
float8get(nr,pos);
825
849
}
826
850
record[keyseg->null_pos] &= ~keyseg->null_bit;
827
851
}
852
#ifndef DRIZZLED
828
853
if (keyseg->type == HA_KEYTYPE_BIT)
829
854
{
830
855
uint length = keyseg->length;
845
870
key+= length;
846
871
continue;
847
872
}
873
#endif
848
874
if (keyseg->flag & HA_SPACE_PACK)
849
875
{
850
876
uint length;
854
880
goto err;
855
881
#endif
856
882
pos = record+keyseg->start;
883
#ifndef DRIZZLED
857
884
if (keyseg->type != (int) HA_KEYTYPE_NUM)
858
885
{
886
#endif
859
887
memcpy(pos,key,(size_t) length);
860
888
bfill(pos+length,keyseg->length-length,' ');
889
#ifndef DRIZZLED
861
890
}
862
891
else
863
892
{
864
893
bfill(pos,keyseg->length-length,' ');
865
894
memcpy(pos+keyseg->length-length,key,(size_t) length);
866
895
}
896
#endif
867
897
key+=length;
868
898
continue;
869
899
}
945
975
static int my_compare_bin(uchar *a, uint a_length, uchar *b, uint b_length,
946
976
my_bool part_key, my_bool skip_end_space)
947
977
{
948
uint length= min(a_length,b_length);
978
uint length= a_length < b_length ? a_length : b_length;
949
979
uchar *end= a+ length;
950
980
int flag;
951
981
1023
1053
get_key_pack_length(seg_len, pack_len, key_data);
1024
1054
key_data += seg_len;
1025
1055
break;
1056
#ifndef DRIZZLED
1026
1057
case HA_KEYTYPE_NUM: {
1027
1058
/* Numeric key */
1028
1059
if (keyseg->flag & HA_SPACE_PACK)
1035
1066
case HA_KEYTYPE_INT8:
1036
1067
case HA_KEYTYPE_SHORT_INT:
1037
1068
case HA_KEYTYPE_USHORT_INT:
1069
case HA_KEYTYPE_INT24:
1070
case HA_KEYTYPE_FLOAT:
1071
case HA_KEYTYPE_BIT:
1072
#endif
1038
1073
case HA_KEYTYPE_LONG_INT:
1039
1074
case HA_KEYTYPE_ULONG_INT:
1040
case HA_KEYTYPE_INT24:
1041
1075
case HA_KEYTYPE_UINT24:
1042
case HA_KEYTYPE_FLOAT:
1043
1076
case HA_KEYTYPE_DOUBLE:
1044
1077
case HA_KEYTYPE_LONGLONG:
1045
1078
case HA_KEYTYPE_ULONGLONG:
1046
case HA_KEYTYPE_BIT:
1047
1079
key_data += keyseg->length;
1048
1080
break;
1049
1081
case HA_KEYTYPE_END:
1190
1222
b += b_length;
1191
1223
break;
1192
1224
}
1225
#ifndef DRIZZLED
1193
1226
case HA_KEYTYPE_INT8:
1194
1227
{
1195
1228
int i_1 = (int) *((signed char *) a);
1218
1251
b += keyseg->length;
1219
1252
break;
1220
1253
}
1254
#endif
1221
1255
case HA_KEYTYPE_LONG_INT: {
1222
1256
int32 l_1 = sint4korr(a);
1223
1257
int32 l_2 = sint4korr(b);
1236
1270
b += keyseg->length;
1237
1271
break;
1238
1272
}
1273
#ifndef DRIZZLED
1239
1274
case HA_KEYTYPE_INT24: {
1240
1275
int32 l_1 = sint3korr(a);
1241
1276
int32 l_2 = sint3korr(b);
1245
1280
b += keyseg->length;
1246
1281
break;
1247
1282
}
1283
#endif
1248
1284
case HA_KEYTYPE_UINT24: {
1249
1285
int32 l_1 = uint3korr(a);
1250
1286
int32 l_2 = uint3korr(b);
1254
1290
b += keyseg->length;
1255
1291
break;
1256
1292
}
1293
#ifndef DRIZZLED
1257
1294
case HA_KEYTYPE_FLOAT: {
1258
1295
float f_1, f_2;
1259
1296
1270
1307
b += keyseg->length;
1271
1308
break;
1272
1309
}
1310
#endif
1273
1311
case HA_KEYTYPE_DOUBLE: {
1274
1312
double d_1, d_2;
1275
1313
1286
1324
b += keyseg->length;
1287
1325
break;
1288
1326
}
1327
#ifndef DRIZZLED
1289
1328
case HA_KEYTYPE_NUM: {
1290
1329
/* Numeric key */
1291
1330
if (keyseg->flag & HA_SPACE_PACK) {
1339
1378
b += b_length;
1340
1379
break;
1341
1380
}
1381
#endif
1342
1382
#ifdef HAVE_LONG_LONG
1343
1383
case HA_KEYTYPE_LONGLONG: {
1344
1384
longlong ll_a = sint8korr(a);
1359
1399
break;
1360
1400
}
1361
1401
#endif
1402
#ifndef DRIZZLED
1362
1403
case HA_KEYTYPE_BIT:
1363
1404
/* TODO: What here? */
1364
1405
break;
1406
#endif
1365
1407
case HA_KEYTYPE_END: /* Ready */
1366
1408
goto end;
1367
1409
}
1410
1452
key_length = has_null + a_length + pack_len;
1411
1453
break;
1412
1454
}
1455
#ifndef DRIZZLED
1413
1456
case HA_KEYTYPE_INT8:
1414
1457
case HA_KEYTYPE_SHORT_INT:
1415
1458
case HA_KEYTYPE_USHORT_INT:
1459
case HA_KEYTYPE_INT24:
1460
case HA_KEYTYPE_FLOAT:
1461
#endif
1416
1462
case HA_KEYTYPE_LONG_INT:
1417
1463
case HA_KEYTYPE_ULONG_INT:
1418
case HA_KEYTYPE_INT24:
1419
1464
case HA_KEYTYPE_UINT24:
1420
case HA_KEYTYPE_FLOAT:
1421
1465
case HA_KEYTYPE_DOUBLE:
1422
1466
break;
1467
#ifndef DRIZZLED
1423
1468
case HA_KEYTYPE_NUM: {
1424
1469
/* Numeric key */
1425
1470
if (keyseg->flag & HA_SPACE_PACK) {
1428
1473
}
1429
1474
break;
1430
1475
}
1476
#endif
1431
1477
#ifdef HAVE_LONG_LONG
1432
1478
case HA_KEYTYPE_LONGLONG:
1433
1479
case HA_KEYTYPE_ULONGLONG:
1434
1480
break;
1435
1481
#endif
1482
#ifndef DRIZZLED
1436
1483
case HA_KEYTYPE_BIT:
1437
1484
/* TODO: What here? */
1438
1485
break;
1486
#endif
1439
1487
case HA_KEYTYPE_END: /* Ready */
1440
1488
break;
1441
1489
}
2151
2199
if (options & HA_OPTION_PACK_KEYS ||
2152
2200
(index->flags & (HA_PACK_KEY | HA_BINARY_PACK_KEY | HA_SPACE_PACK_USED)))
2153
2201
{
2154
if (key_part->length > 8 && (type == HA_KEYTYPE_TEXT || type == HA_KEYTYPE_NUM ||
2202
if (key_part->length > 8 && (type == HA_KEYTYPE_TEXT ||
2203
#ifndef DRIZZLED
2204
type == HA_KEYTYPE_NUM ||
2205
#endif
2155
2206
(type == HA_KEYTYPE_BINARY && !field->zero_pack())))
2156
2207
{
2157
2208
/* No blobs here */
2219
2270
else if (field->type() == MYSQL_TYPE_ENUM) {
2220
2271
switch (seg->length) {
2221
2272
case 2:
2273
#ifdef DRIZZLED
2274
ASSERT_NS(FALSE);
2275
#else
2222
2276
seg->type = HA_KEYTYPE_USHORT_INT;
2223
2277
break;
2278
#endif
2224
2279
case 3:
2225
2280
seg->type = HA_KEYTYPE_UINT24;
2226
2281
break;
2681
2736
if (!(my_tab = my_open_table(self, db, tab_path)))
2682
2737
return FAILED;
2683
2738
dic->dic_my_table = my_tab;
2739
#ifdef DRIZZLED
2740
dic->dic_def_ave_row_size = (xtWord8) my_tab->s->getAvgRowLength();
2741
#else
2684
2742
dic->dic_def_ave_row_size = (xtWord8) my_tab->s->avg_row_length;
2743
#endif
2685
2744
myxt_setup_dictionary(self, dic);
2686
2745
dic->dic_keys = (XTIndexPtr *) xt_calloc(self, sizeof(XTIndexPtr) * TS(my_tab)->keys);
2687
2746
for (uint i=0; i<TS(my_tab)->keys; i++)
2892
2951
2893
2952
xtPublic void myxt_static_convert_identifier(XTThreadPtr XT_UNUSED(self), MX_CHARSET_INFO *cs, char *from, char *to, size_t to_len)
2894
2953
{
2954
#ifdef DRIZZLED
2955
((void *)cs);
2956
xt_strcpy(to_len, to, from);
2957
#else
2895
2958
uint errors;
2896
2959
2897
2960
/*
2903
2966
xt_strcpy(to_len, to, from);
2904
2967
else
2905
2968
strconvert(cs, from, &my_charset_utf8_general_ci, to, to_len, &errors);
2969
#endif
2906
2970
}
2907
2971
2908
2972
// cs == current_thd->charset()
2909
2973
xtPublic char *myxt_convert_identifier(XTThreadPtr self, MX_CHARSET_INFO *cs, char *from)
2910
2974
{
2975
#ifdef DRIZZLED
2976
char *to = xt_dup_string(self, from);
2977
((void *)cs);
2978
#else
2911
2979
uint errors;
2912
2980
u_int len;
2913
2981
char *to;
2919
2987
to = (char *) xt_malloc(self, len);
2920
2988
strconvert(cs, from, &my_charset_utf8_general_ci, to, len, &errors);
2921
2989
}
2990
#endif
2922
2991
return to;
2923
2992
}
2924
2993
2969
3038
THD *thd = current_thd;
2970
3039
2971
3040
if (thd)
2972
return thd_charset(thd);
3041
return (MX_CHARSET_INFO *)thd_charset(thd);
2973
3042
}
2974
return &my_charset_utf8_general_ci;
3043
return (MX_CHARSET_INFO *)&my_charset_utf8_general_ci;
2975
3044
}
2976
3045
2977
3046
xtPublic void *myxt_create_thread()
3229
3298
my_bitmap_map *buf;
3230
3299
uint size_in_bytes = (((n_bits) + 31) / 32) * 4;
3231
3300
3232
buf = (my_bitmap_map *) xt_malloc(self, size_in_bytes);
3301
buf = (my_bitmap_map *) xt_malloc(self, size_in_bytes);
3302
3303
#ifdef DRIZZLED
3304
map->init(buf, n_bits);
3305
#else
3233
3306
map->bitmap= buf;
3234
3307
map->n_bits= n_bits;
3235
3308
create_last_word_mask(map);
3236
3309
bitmap_clear_all(map);
3310
#endif
3237
3311
}
3238
3312
3239
3313
static void myxt_bitmap_free(XTThreadPtr self, MX_BITMAP *map)
3240
3314
{
3315
#ifdef DRIZZLED
3316
my_bitmap_map *buf = map->getBitmap();
3317
if (buf)
3318
xt_free(self, buf);
3319
map->setBitmap(NULL);
3320
#else
3241
3321
if (map->bitmap) {
3242
3322
xt_free(self, map->bitmap);
3243
3323
map->bitmap = NULL;
3244
3324
}
3325
#endif
3245
3326
}
3246
3327
3247
3328
/*
Loggerhead is a web-based interface for Breezy
Version: 2.0.1