~drizzle-trunk/drizzle/development : revision 438.1.13

27

28

/* functions defined in this file */

29

30

static char **make_char_array(char **old_pos, register uint fields,

31

uint length, myf my_flag);

32

static uchar *read_buffpek_from_file(IO_CACHE *buffer_file, uint count,

30

static char **make_char_array(char **old_pos, register uint32_t fields,

31

uint32_t length, myf my_flag);

32

static uchar *read_buffpek_from_file(IO_CACHE *buffer_file, uint32_t count,

33

uchar *buf);

34

static ha_rows find_all_keys(SORTPARAM *param,SQL_SELECT *select,

35

uchar * *sort_keys, IO_CACHE *buffer_file,

36

IO_CACHE *tempfile,IO_CACHE *indexfile);

37

static int write_keys(SORTPARAM *param,uchar * *sort_keys,

38

uint count, IO_CACHE *buffer_file, IO_CACHE *tempfile);

38

uint32_t count, IO_CACHE *buffer_file, IO_CACHE *tempfile);

39

static void make_sortkey(SORTPARAM *param,uchar *to, uchar *ref_pos);

40

static void register_used_fields(SORTPARAM *param);

41

static int merge_index(SORTPARAM *param,uchar *sort_buffer,

42

BUFFPEK *buffpek,

43

uint maxbuffer,IO_CACHE *tempfile,

43

uint32_t maxbuffer,IO_CACHE *tempfile,

44

IO_CACHE *outfile);

45

static bool save_index(SORTPARAM *param,uchar **sort_keys, uint count,

45

static bool save_index(SORTPARAM *param,uchar **sort_keys, uint32_t count,

46

filesort_info_st *table_sort);

47

static uint suffix_length(uint32_t string_length);

48

static uint sortlength(THD *thd, SORT_FIELD *sortorder, uint s_length,

47

static uint32_t suffix_length(uint32_t string_length);

48

static uint32_t sortlength(THD *thd, SORT_FIELD *sortorder, uint32_t s_length,

49

bool *multi_byte_charset);

50

static SORT_ADDON_FIELD *get_addon_fields(THD *thd, Field **ptabfield,

51

uint sortlength, uint *plength);

51

uint32_t sortlength, uint32_t *plength);

52

static void unpack_addon_fields(struct st_sort_addon_field *addon_field,

53

uchar *buff);

54

/**

87

examined_rows will be set to number of examined rows

88

*/

89

90

ha_rows filesort(THD *thd, Table *table, SORT_FIELD *sortorder, uint s_length,

90

ha_rows filesort(THD *thd, Table *table, SORT_FIELD *sortorder, uint32_t s_length,

91

SQL_SELECT *select, ha_rows max_rows,

92

bool sort_positions, ha_rows *examined_rows)

93

{

94

int error;

95

uint32_t memavl, min_sort_memory;

96

uint maxbuffer;

96

uint32_t maxbuffer;

97

BUFFPEK *buffpek;

98

ha_rows records= HA_POS_ERROR;

99

uchar **sort_keys= 0;

198

goto err;

199

200

memavl= thd->variables.sortbuff_size;

201

min_sort_memory= cmax((uint)MIN_SORT_MEMORY, param.sort_length*MERGEBUFF2);

201

min_sort_memory= cmax((uint32_t)MIN_SORT_MEMORY, param.sort_length*MERGEBUFF2);

202

while (memavl >= min_sort_memory)

203

{

204

uint32_t old_memavl;

205

uint32_t keys= memavl/(param.rec_length+sizeof(char*));

206

param.keys=(uint) cmin(records+1, keys);

206

param.keys=(uint32_t) cmin(records+1, keys);

207

if ((table_sort.sort_keys=

208

(uchar **) make_char_array((char **) table_sort.sort_keys,

209

param.keys, param.rec_length, MYF(0))))

229

&tempfile, selected_records_file)) ==

230

HA_POS_ERROR)

231

goto err;

232

maxbuffer= (uint) (my_b_tell(&buffpek_pointers)/sizeof(*buffpek));

232

maxbuffer= (uint32_t) (my_b_tell(&buffpek_pointers)/sizeof(*buffpek));

233

234

if (maxbuffer == 0) // The whole set is in memory

235

{

236

if (save_index(&param,sort_keys,(uint) records, &table_sort))

236

if (save_index(&param,sort_keys,(uint32_t) records, &table_sort))

237

goto err;

238

}

239

else

349

350

/** Make a array of string pointers. */

351

352

static char **make_char_array(char **old_pos, register uint fields,

353

uint length, myf my_flag)

352

static char **make_char_array(char **old_pos, register uint32_t fields,

353

uint32_t length, myf my_flag)

354

{

355

register char **pos;

356

char *char_pos;

357

358

if (old_pos ||

359

(old_pos= (char**) my_malloc((uint) fields*(length+sizeof(char*)),

359

(old_pos= (char**) my_malloc((uint32_t) fields*(length+sizeof(char*)),

360

my_flag)))

361

{

362

pos=old_pos; char_pos=((char*) (pos+fields)) -length;

369

370

/** Read 'count' number of buffer pointers into memory. */

371

372

static uchar *read_buffpek_from_file(IO_CACHE *buffpek_pointers, uint count,

372

static uchar *read_buffpek_from_file(IO_CACHE *buffpek_pointers, uint32_t count,

373

uchar *buf)

374

{

375

uint32_t length= sizeof(BUFFPEK)*count;

434

IO_CACHE *tempfile, IO_CACHE *indexfile)

435

{

436

int error,flag,quick_select;

437

uint idx,indexpos,ref_length;

437

uint32_t idx,indexpos,ref_length;

438

uchar *ref_pos,*next_pos,ref_buff[MAX_REFLENGTH];

439

my_off_t record;

440

Table *sort_form;

609

*/

610

611

static int

612

write_keys(SORTPARAM *param, register uchar **sort_keys, uint count,

612

write_keys(SORTPARAM *param, register uchar **sort_keys, uint32_t count,

613

IO_CACHE *buffpek_pointers, IO_CACHE *tempfile)

614

{

615

size_t sort_length, rec_length;

618

619

sort_length= param->sort_length;

620

rec_length= param->rec_length;

621

my_string_ptr_sort((uchar*) sort_keys, (uint) count, sort_length);

621

my_string_ptr_sort((uchar*) sort_keys, (uint32_t) count, sort_length);

622

if (!my_b_inited(tempfile) &&

623

open_cached_file(tempfile, mysql_tmpdir, TEMP_PREFIX, DISK_BUFFER_SIZE,

624

MYF(MY_WME)))

628

goto err;

629

buffpek.file_pos= my_b_tell(tempfile);

630

if ((ha_rows) count > param->max_rows)

631

count=(uint) param->max_rows; /* purecov: inspected */

631

count=(uint32_t) param->max_rows; /* purecov: inspected */

632

buffpek.count=(ha_rows) count;

633

for (end=sort_keys+count ; sort_keys != end ; sort_keys++)

634

if (my_b_write(tempfile, (uchar*) *sort_keys, (uint) rec_length))

634

if (my_b_write(tempfile, (uchar*) *sort_keys, (uint32_t) rec_length))

635

goto err;

636

if (my_b_write(buffpek_pointers, (uchar*) &buffpek, sizeof(buffpek)))

637

goto err;

646

Store length as suffix in high-byte-first order.

647

*/

648

649

static inline void store_length(uchar *to, uint length, uint pack_length)

649

static inline void store_length(uchar *to, uint32_t length, uint32_t pack_length)

650

{

651

switch (pack_length) {

652

case 1:

672

{

673

register Field *field;

674

register SORT_FIELD *sort_field;

675

register uint length;

675

register uint32_t length;

676

677

for (sort_field=param->local_sortorder ;

678

sort_field != param->end ;

707

const CHARSET_INFO * const cs=item->collation.collation;

708

char fill_char= ((cs->state & MY_CS_BINSORT) ? (char) 0 : ' ');

709

int diff;

710

uint sort_field_length;

710

uint32_t sort_field_length;

711

712

if (maybe_null)

713

*to++=1;

749

if (sort_field->need_strxnfrm)

750

{

751

char *from=(char*) res->ptr();

752

uint tmp_length;

752

uint32_t tmp_length;

753

if ((uchar*) from == to)

754

{

755

set_if_smaller(length,sort_field->length);

889

{

890

#ifdef HAVE_purify

891

uchar *end= field->pack(to, field->ptr);

892

uint length= (uint) ((to + addonf->length) - end);

892

uint32_t length= (uint32_t) ((to + addonf->length) - end);

893

assert((int) length >= 0);

894

if (length)

895

memset(end, 0, length);

951

}

952

953

954

static bool save_index(SORTPARAM *param, uchar **sort_keys, uint count,

954

static bool save_index(SORTPARAM *param, uchar **sort_keys, uint32_t count,

955

filesort_info_st *table_sort)

956

{

957

uint offset,res_length;

957

uint32_t offset,res_length;

958

uchar *to;

959

960

my_string_ptr_sort((uchar*) sort_keys, (uint) count, param->sort_length);

960

my_string_ptr_sort((uchar*) sort_keys, (uint32_t) count, param->sort_length);

961

res_length= param->res_length;

962

offset= param->rec_length-res_length;

963

if ((ha_rows) count > param->max_rows)

964

count=(uint) param->max_rows;

964

count=(uint32_t) param->max_rows;

965

if (!(to= table_sort->record_pointers=

966

(uchar*) my_malloc(res_length*count, MYF(MY_WME))))

967

return(1); /* purecov: inspected */

977

/** Merge buffers to make < MERGEBUFF2 buffers. */

978

979

int merge_many_buff(SORTPARAM *param, uchar *sort_buffer,

980

BUFFPEK *buffpek, uint *maxbuffer, IO_CACHE *t_file)

980

BUFFPEK *buffpek, uint32_t *maxbuffer, IO_CACHE *t_file)

981

{

982

register uint i;

982

register uint32_t i;

983

IO_CACHE t_file2,*from_file,*to_file,*temp;

984

BUFFPEK *lastbuff;

985

1012

temp=from_file; from_file=to_file; to_file=temp;

1013

setup_io_cache(from_file);

1014

setup_io_cache(to_file);

1015

*maxbuffer= (uint) (lastbuff-buffpek)-1;

1015

*maxbuffer= (uint32_t) (lastbuff-buffpek)-1;

1016

}

1017

cleanup:

1018

close_cached_file(to_file); // This holds old result

1030

Read data to buffer.

1031

1032

@retval

1033

(uint)-1 if something goes wrong

1033

(uint32_t)-1 if something goes wrong

1034

*/

1035

1036

uint read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek,

1037

uint rec_length)

1036

uint32_t read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek,

1037

uint32_t rec_length)

1038

{

1039

register uint count;

1040

uint length;

1039

register uint32_t count;

1040

uint32_t length;

1041

1042

if ((count=(uint) cmin((ha_rows) buffpek->max_keys,buffpek->count)))

1042

if ((count=(uint32_t) cmin((ha_rows) buffpek->max_keys,buffpek->count)))

1043

{

1044

if (pread(fromfile->file,(uchar*) buffpek->base, (length= rec_length*count),buffpek->file_pos) == 0)

1045

return((uint) -1); /* purecov: inspected */

1045

return((uint32_t) -1); /* purecov: inspected */

1046

buffpek->key=buffpek->base;

1047

buffpek->file_pos+= length; /* New filepos */

1048

buffpek->count-= count;

1063

@param[in] key_length key length

1064

*/

1065

1066

void reuse_freed_buff(QUEUE *queue, BUFFPEK *reuse, uint key_length)

1066

void reuse_freed_buff(QUEUE *queue, BUFFPEK *reuse, uint32_t key_length)

1067

{

1068

uchar *reuse_end= reuse->base + reuse->max_keys * key_length;

1069

for (uint i= 0; i < queue->elements; ++i)

1069

for (uint32_t i= 0; i < queue->elements; ++i)

1070

{

1071

BUFFPEK *bp= (BUFFPEK *) queue_element(queue, i);

1072

if (bp->base + bp->max_keys * key_length == reuse->base)

1109

int flag)

1110

{

1111

int error;

1112

uint rec_length,res_length,offset;

1112

uint32_t rec_length,res_length,offset;

1113

size_t sort_length;

1114

uint32_t maxcount;

1115

ha_rows max_rows,org_max_rows;

1134

res_length= param->res_length;

1135

sort_length= param->sort_length;

1136

offset= rec_length-res_length;

1137

maxcount= (uint32_t) (param->keys/((uint) (Tb-Fb) +1));

1137

maxcount= (uint32_t) (param->keys/((uint32_t) (Tb-Fb) +1));

1138

to_start_filepos= my_b_tell(to_file);

1139

strpos= (uchar*) sort_buffer;

1140

org_max_rows=max_rows= param->max_rows;

1152

cmp= get_ptr_compare(sort_length);

1153

first_cmp_arg= (void*) &sort_length;

1154

}

1155

if (init_queue(&queue, (uint) (Tb-Fb)+1, offsetof(BUFFPEK,key), 0,

1155

if (init_queue(&queue, (uint32_t) (Tb-Fb)+1, offsetof(BUFFPEK,key), 0,

1156

(queue_compare) cmp, first_cmp_arg))

1157

return(1); /* purecov: inspected */

1158

for (buffpek= Fb ; buffpek <= Tb ; buffpek++)

1159

{

1160

buffpek->base= strpos;

1161

buffpek->max_keys= maxcount;

1162

strpos+= (uint) (error= (int) read_to_buffer(from_file, buffpek,

1162

strpos+= (uint32_t) (error= (int) read_to_buffer(from_file, buffpek,

1163

rec_length));

1164

if (error == -1)

1165

goto err; /* purecov: inspected */

1269

{

1270

if ((ha_rows) buffpek->mem_count > max_rows)

1271

{ /* Don't write too many records */

1272

buffpek->mem_count= (uint) max_rows;

1272

buffpek->mem_count= (uint32_t) max_rows;

1273

buffpek->count= 0; /* Don't read more */

1274

}

1275

max_rows-= buffpek->mem_count;

1311

/* Do a merge to output-file (save only positions) */

1312

1313

static int merge_index(SORTPARAM *param, uchar *sort_buffer,

1314

BUFFPEK *buffpek, uint maxbuffer,

1314

BUFFPEK *buffpek, uint32_t maxbuffer,

1315

IO_CACHE *tempfile, IO_CACHE *outfile)

1316

{

1317

if (merge_buffers(param,tempfile,outfile,sort_buffer,buffpek,buffpek,

1321

} /* merge_index */

1322

1323

1324

static uint suffix_length(uint32_t string_length)

1324

static uint32_t suffix_length(uint32_t string_length)

1325

{

1326

if (string_length < 256)

1327

return 1;

1352

Total length of sort buffer in bytes

1353

*/

1354

1355

static uint

1356

sortlength(THD *thd, SORT_FIELD *sortorder, uint s_length,

1355

static uint32_t

1356

sortlength(THD *thd, SORT_FIELD *sortorder, uint32_t s_length,

1357

bool *multi_byte_charset)

1358

{

1359

register uint length;

1359

register uint32_t length;

1360

const CHARSET_INFO *cs;

1361

*multi_byte_charset= 0;

1362

1462

*/

1463

1464

static SORT_ADDON_FIELD *

1465

get_addon_fields(THD *thd, Field **ptabfield, uint sortlength, uint *plength)

1465

get_addon_fields(THD *thd, Field **ptabfield, uint32_t sortlength, uint32_t *plength)

1466

{

1467

Field **pfield;

1468

Field *field;

1469

SORT_ADDON_FIELD *addonf;

1470

uint length= 0;

1471

uint fields= 0;

1472

uint null_fields= 0;

1470

uint32_t length= 0;

1471

uint32_t fields= 0;

1472

uint32_t null_fields= 0;

1473

MY_BITMAP *read_set= (*ptabfield)->table->read_set;

1474

1475

/*

1599

#endif

1600

if (tmp[0] & 128) /* Negative */

1601

{ /* make complement */

1602

uint i;

1602

uint32_t i;

1603

for (i=0 ; i < sizeof(nr); i++)

1604

tmp[i]=tmp[i] ^ (uchar) 255;

1605

}

1606

else

1607

{ /* Set high and move exponent one up */

1608

ushort exp_part=(((ushort) tmp[0] << 8) | (ushort) tmp[1] |

1609

(ushort) 32768);

1610

exp_part+= (ushort) 1 << (16-1-DBL_EXP_DIG);

1608

uint16_t exp_part=(((uint16_t) tmp[0] << 8) | (uint16_t) tmp[1] |

1609

(uint16_t) 32768);

1610

exp_part+= (uint16_t) 1 << (16-1-DBL_EXP_DIG);

1611

tmp[0]= (uchar) (exp_part >> 8);

1612

tmp[1]= (uchar) exp_part;

1613

}