← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/my_handler.cc

  • Committer: Brian Aker
  • Date: 2009-10-07 16:29:08 UTC
  • mfrom: (1161.1.7 fix-key_type)
  • Revision ID: brian@gaz-20091007162908-dkbo2z385i7kiyvn
Merge Stewart.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/my_handler.cc
142
142
               uint32_t *diff_pos)
143
143
{
144
144
  int flag;
145
 
  int16_t s_1,s_2;
146
145
  int32_t l_1,l_2;
147
146
  uint32_t u_1,u_2;
148
 
  float f_1,f_2;
149
147
  double d_1,d_2;
150
148
  uint32_t next_key_length;
151
149
  unsigned char *orig_b= b;
221
219
      }
222
220
      break;
223
221
    case HA_KEYTYPE_BINARY:
224
 
    case HA_KEYTYPE_BIT:
225
222
      if (keyseg->flag & HA_SPACE_PACK)
226
223
      {
227
224
        int a_length,b_length,pack_length;
289
286
        b+=b_length;
290
287
        break;
291
288
      }
292
 
    case HA_KEYTYPE_INT8:
293
 
    {
294
 
      int i_1= (int) *((signed char*) a);
295
 
      int i_2= (int) *((signed char*) b);
296
 
      if (piks && (flag = CMP_NUM(i_1,i_2)))
297
 
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
298
 
      a= end;
299
 
      b++;
300
 
      break;
301
 
    }
302
 
    case HA_KEYTYPE_SHORT_INT:
303
 
      s_1= mi_sint2korr(a);
304
 
      s_2= mi_sint2korr(b);
305
 
      if (piks && (flag = CMP_NUM(s_1,s_2)))
306
 
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
307
 
      a=  end;
308
 
      b+= 2; /* sizeof(short int); */
309
 
      break;
310
 
    case HA_KEYTYPE_USHORT_INT:
311
 
      {
312
 
        uint16_t us_1,us_2;
313
 
        us_1= mi_sint2korr(a);
314
 
        us_2= mi_sint2korr(b);
315
 
        if (piks && (flag = CMP_NUM(us_1,us_2)))
316
 
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
317
 
        a=  end;
318
 
        b+=2; /* sizeof(short int); */
319
 
        break;
320
 
      }
321
289
    case HA_KEYTYPE_LONG_INT:
322
290
      l_1= mi_sint4korr(a);
323
291
      l_2= mi_sint4korr(b);
334
302
      a=  end;
335
303
      b+= 4; /* sizeof(long int); */
336
304
      break;
337
 
    case HA_KEYTYPE_INT24:
338
 
      l_1=mi_sint3korr(a);
339
 
      l_2=mi_sint3korr(b);
340
 
      if (piks && (flag = CMP_NUM(l_1,l_2)))
341
 
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
342
 
      a=  end;
343
 
      b+= 3;
344
 
      break;
345
305
    case HA_KEYTYPE_UINT24:
346
306
      l_1=mi_uint3korr(a);
347
307
      l_2=mi_uint3korr(b);
350
310
      a=  end;
351
311
      b+= 3;
352
312
      break;
353
 
    case HA_KEYTYPE_FLOAT:
354
 
      mi_float4get(f_1,a);
355
 
      mi_float4get(f_2,b);
356
 
      /*
357
 
        The following may give a compiler warning about floating point
358
 
        comparison not being safe, but this is ok in this context as
359
 
        we are bascily doing sorting
360
 
      */
361
 
      if (piks && (flag = CMP_NUM(f_1,f_2)))
362
 
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
363
 
      a=  end;
364
 
      b+= 4; /* sizeof(float); */
365
 
      break;
366
313
    case HA_KEYTYPE_DOUBLE:
367
314
      mi_float8get(d_1,a);
368
315
      mi_float8get(d_2,b);
376
323
      a=  end;
377
324
      b+= 8;  /* sizeof(double); */
378
325
      break;
379
 
    case HA_KEYTYPE_NUM:                                /* Numeric key */
380
 
    {
381
 
      int swap_flag= 0;
382
 
      int alength,blength;
383
 
 
384
 
      if (keyseg->flag & HA_REVERSE_SORT)
385
 
      {
386
 
        swap_variables(unsigned char*, a, b);
387
 
        swap_flag=1;                            /* Remember swap of a & b */
388
 
        end= a+ (int) (end-b);
389
 
      }
390
 
      if (keyseg->flag & HA_SPACE_PACK)
391
 
      {
392
 
        alength= *a++; blength= *b++;
393
 
        end=a+alength;
394
 
        next_key_length=key_length-blength-1;
395
 
      }
396
 
      else
397
 
      {
398
 
        alength= (int) (end-a);
399
 
        blength=keyseg->length;
400
 
        /* remove pre space from keys */
401
 
        for ( ; alength && *a == ' ' ; a++, alength--) ;
402
 
        for ( ; blength && *b == ' ' ; b++, blength--) ;
403
 
      }
404
 
      if (piks)
405
 
      {
406
 
        if (*a == '-')
407
 
        {
408
 
          if (*b != '-')
409
 
            return -1;
410
 
          a++; b++;
411
 
          swap_variables(unsigned char*, a, b);
412
 
          swap_variables(int, alength, blength);
413
 
          swap_flag=1-swap_flag;
414
 
          alength--; blength--;
415
 
          end=a+alength;
416
 
        }
417
 
        else if (*b == '-')
418
 
          return 1;
419
 
        while (alength && (*a == '+' || *a == '0'))
420
 
        {
421
 
          a++; alength--;
422
 
        }
423
 
        while (blength && (*b == '+' || *b == '0'))
424
 
        {
425
 
          b++; blength--;
426
 
        }
427
 
        if (alength != blength)
428
 
          return (alength < blength) ? -1 : 1;
429
 
        while (a < end)
430
 
          if (*a++ !=  *b++)
431
 
            return ((int) a[-1] - (int) b[-1]);
432
 
      }
433
 
      else
434
 
      {
435
 
        b+=(end-a);
436
 
        a=end;
437
 
      }
438
 
 
439
 
      if (swap_flag)                            /* Restore pointers */
440
 
        swap_variables(unsigned char*, a, b);
441
 
      break;
442
 
    }
443
326
    case HA_KEYTYPE_LONGLONG:
444
327
    {
445
328
      int64_t ll_a,ll_b;
528
411
    switch ((enum ha_base_keytype) keyseg->type) {
529
412
    case HA_KEYTYPE_TEXT:
530
413
    case HA_KEYTYPE_BINARY:
531
 
    case HA_KEYTYPE_BIT:
532
414
      if (keyseg->flag & HA_SPACE_PACK)
533
415
      {
534
416
        int a_length;
549
431
        a+= a_length;
550
432
        break;
551
433
      }
552
 
    case HA_KEYTYPE_NUM:
553
 
      if (keyseg->flag & HA_SPACE_PACK)
554
 
      {
555
 
        int alength= *a++;
556
 
        end= a+alength;
557
 
      }
558
 
      a= end;
559
 
      break;
560
 
    case HA_KEYTYPE_INT8:
561
 
    case HA_KEYTYPE_SHORT_INT:
562
 
    case HA_KEYTYPE_USHORT_INT:
563
434
    case HA_KEYTYPE_LONG_INT:
564
435
    case HA_KEYTYPE_ULONG_INT:
565
 
    case HA_KEYTYPE_INT24:
566
436
    case HA_KEYTYPE_UINT24:
567
437
    case HA_KEYTYPE_LONGLONG:
568
438
    case HA_KEYTYPE_ULONGLONG:
569
 
    case HA_KEYTYPE_FLOAT:
570
439
    case HA_KEYTYPE_DOUBLE:
571
440
      a= end;
572
441
      break;