← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/cmpfunc.cc

  • Committer: Padraig O'Sullivan
  • Date: 2009-08-08 04:22:33 UTC
  • mto: (1115.3.4 captain)
  • mto: This revision was merged to the branch mainline in revision 1117.
  • Revision ID: osullivan.padraig@gmail.com-20090808042233-q0z88zc490z3f3r7
Renamed the Command class to be Statement. Renamed the command directory to
statement and also the command header file to statement. Updated various
source files to reflect this renaming.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/cmpfunc.cc
21
21
  This file defines all compare functions
22
22
*/
23
23
 
24
 
#include "config.h"
 
24
#include "drizzled/server_includes.h"
25
25
#include "drizzled/sql_select.h"
26
26
#include "drizzled/error.h"
27
27
#include "drizzled/temporal.h"
30
30
#include "drizzled/item/cache_int.h"
31
31
#include "drizzled/item/int_with_ref.h"
32
32
#include "drizzled/check_stack_overrun.h"
33
 
#include "drizzled/time_functions.h"
34
 
#include "drizzled/internal/my_sys.h"
35
 
#include <math.h>
 
33
 
36
34
#include <algorithm>
37
35
 
38
36
using namespace std;
39
37
 
40
 
namespace drizzled
41
 
{
42
 
 
43
 
extern const double log_10[309];
44
38
 
45
39
static Eq_creator eq_creator;
46
40
static Ne_creator ne_creator;
209
203
    collect_cmp_types()
210
204
      items             Array of items to collect types from
211
205
      nitems            Number of items in the array
212
 
      skip_nulls        Don't collect types of NULL items if TRUE
213
206
 
214
207
  DESCRIPTION
215
208
    This function collects different result types for comparison of the first
220
213
    Bitmap of collected types - otherwise
221
214
*/
222
215
 
223
 
static uint32_t collect_cmp_types(Item **items, uint32_t nitems, bool skip_nulls= false)
 
216
static uint32_t collect_cmp_types(Item **items, uint32_t nitems)
224
217
{
225
218
  uint32_t i;
226
219
  uint32_t found_types;
229
222
  found_types= 0;
230
223
  for (i= 1; i < nitems ; i++)
231
224
  {
232
 
    if (skip_nulls && items[i]->type() == Item::NULL_ITEM)
233
 
      continue; // Skip NULL constant items
234
225
    if ((left_result == ROW_RESULT ||
235
226
         items[i]->result_type() == ROW_RESULT) &&
236
227
        cmp_row_type(items[0], items[i]))
238
229
    found_types|= 1<< (uint32_t)item_cmp_type(left_result,
239
230
                                           items[i]->result_type());
240
231
  }
241
 
  /*
242
 
   Even if all right-hand items are NULLs and we are skipping them all, we need
243
 
   at least one type bit in the found_type bitmask.
244
 
  */
245
 
  if (skip_nulls && !found_types)
246
 
    found_types= 1 << (uint)left_result;
247
232
  return found_types;
248
233
}
249
234
 
819
804
      String *str_val;
820
805
      String tmp;
821
806
      /* DateTime used to pick up as many string conversion possibilities as possible. */
822
 
      DateTime temporal;
 
807
      drizzled::DateTime temporal;
823
808
 
824
809
      str_val= str_arg->val_str(&tmp);
825
810
      if (! str_val)
1062
1047
  /* Compare values. */
1063
1048
  if (is_nulls_eq)
1064
1049
    return (a_value == b_value);
1065
 
  return (a_value < b_value) ? -1 : ((a_value > b_value) ? 1 : 0);
 
1050
  return a_value < b_value ? -1 : (a_value > b_value ? 1 : 0);
1066
1051
}
1067
1052
 
1068
1053
 
1802
1787
 
1803
1788
    if (not_null_consts &&
1804
1789
        (intervals=
1805
 
          (interval_range*) memory::sql_alloc(sizeof(interval_range) * (rows - 1))))
 
1790
          (interval_range*) sql_alloc(sizeof(interval_range) * (rows - 1))))
1806
1791
    {
1807
1792
      if (use_decimal_comparison)
1808
1793
      {
2103
2088
  {
2104
2089
    int64_t value=args[0]->val_int(), a, b;
2105
2090
    if ((null_value=args[0]->null_value))
2106
 
      return 0;
 
2091
      return 0;                                 /* purecov: inspected */
2107
2092
    a=args[1]->val_int();
2108
2093
    b=args[2]->val_int();
2109
2094
    if (!args[1]->null_value && !args[2]->null_value)
2124
2109
    my_decimal dec_buf, *dec= args[0]->val_decimal(&dec_buf),
2125
2110
               a_buf, *a_dec, b_buf, *b_dec;
2126
2111
    if ((null_value=args[0]->null_value))
2127
 
      return 0;
 
2112
      return 0;                                 /* purecov: inspected */
2128
2113
    a_dec= args[1]->val_decimal(&a_buf);
2129
2114
    b_dec= args[2]->val_decimal(&b_buf);
2130
2115
    if (!args[1]->null_value && !args[2]->null_value)
2141
2126
  {
2142
2127
    double value= args[0]->val_real(),a,b;
2143
2128
    if ((null_value=args[0]->null_value))
2144
 
      return 0;
 
2129
      return 0;                                 /* purecov: inspected */
2145
2130
    a= args[1]->val_real();
2146
2131
    b= args[2]->val_real();
2147
2132
    if (!args[1]->null_value && !args[2]->null_value)
2721
2706
  Item **agg;
2722
2707
  uint32_t nagg;
2723
2708
  uint32_t found_types= 0;
2724
 
  if (!(agg= (Item**) memory::sql_alloc(sizeof(Item*)*(ncases+1))))
 
2709
  if (!(agg= (Item**) sql_alloc(sizeof(Item*)*(ncases+1))))
2725
2710
    return;
2726
2711
 
2727
2712
  /*
3064
3049
}
3065
3050
 
3066
3051
 
3067
 
void in_vector::sort()
3068
 
{
3069
 
  internal::my_qsort2(base,used_count,size,compare, (void *) collation);
3070
 
}
3071
 
 
3072
 
 
3073
3052
int in_vector::find(Item *item)
3074
3053
{
3075
3054
  unsigned char *result=get_value(item);
3101
3080
{
3102
3081
  if (base)
3103
3082
  {
3104
 
    // base was allocated with help of memory::sql_alloc => following is OK
 
3083
    // base was allocated with help of sql_alloc => following is OK
3105
3084
    for (uint32_t i=0 ; i < count ; i++)
3106
3085
      ((String*) base)[i].free();
3107
3086
  }
3223
3202
{
3224
3203
  tmp= item->val_real();
3225
3204
  if (item->null_value)
3226
 
    return 0;
 
3205
    return 0;                                   /* purecov: inspected */
3227
3206
  return (unsigned char*) &tmp;
3228
3207
}
3229
3208
 
3351
3330
    return;
3352
3331
  }
3353
3332
  n= tmpl->n;
3354
 
  if ((comparators= (cmp_item **) memory::sql_alloc(sizeof(cmp_item *)*n)))
 
3333
  if ((comparators= (cmp_item **) sql_alloc(sizeof(cmp_item *)*n)))
3355
3334
  {
3356
3335
    item->bring_value();
3357
3336
    item->null_value= 0;
3546
3525
  uint32_t type_cnt= 0, i;
3547
3526
  Item_result cmp_type= STRING_RESULT;
3548
3527
  left_result_type= args[0]->result_type();
3549
 
  if (!(found_types= collect_cmp_types(args, arg_count, true)))
 
3528
  if (!(found_types= collect_cmp_types(args, arg_count)))
3550
3529
    return;
3551
3530
 
3552
3531
  for (arg= args + 1, arg_end= args + arg_count; arg != arg_end ; arg++)
3723
3702
      uint32_t j=0;
3724
3703
      for (uint32_t arg_num=1 ; arg_num < arg_count ; arg_num++)
3725
3704
      {
 
3705
        array->set(j,args[arg_num]);
3726
3706
        if (!args[arg_num]->null_value)                 // Skip NULL values
3727
 
        {
3728
 
          array->set(j,args[arg_num]);
3729
3707
          j++;
3730
 
        }
3731
3708
        else
3732
3709
          have_null= 1;
3733
3710
      }
3906
3883
    if ((!item->fixed &&
3907
3884
         item->fix_fields(session, li.ref())) ||
3908
3885
        (item= *li.ref())->check_cols(1))
3909
 
      return true;
 
3886
      return true; /* purecov: inspected */
3910
3887
    used_tables_cache|=     item->used_tables();
3911
3888
    if (item->const_item())
3912
3889
      and_tables_cache= (table_map) 0;
4357
4334
                    res->ptr(),res->ptr()+res->length(),
4358
4335
                    res2->ptr(),res2->ptr()+res2->length(),
4359
4336
                    make_escape_code(cmp.cmp_collation.collation, escape),
4360
 
                    internal::wild_one,internal::wild_many) ? 0 : 1;
 
4337
                    wild_one,wild_many) ? 0 : 1;
4361
4338
}
4362
4339
 
4363
4340
 
4374
4351
    if (!res2)
4375
4352
      return OPTIMIZE_NONE;
4376
4353
 
4377
 
    if (*res2->ptr() != internal::wild_many)
 
4354
    if (*res2->ptr() != wild_many)
4378
4355
    {
4379
 
      if (args[0]->result_type() != STRING_RESULT || *res2->ptr() != internal::wild_one)
 
4356
      if (args[0]->result_type() != STRING_RESULT || *res2->ptr() != wild_one)
4380
4357
        return OPTIMIZE_OP;
4381
4358
    }
4382
4359
  }
4404
4381
    String *escape_str= escape_item->val_str(&tmp_value1);
4405
4382
    if (escape_str)
4406
4383
    {
4407
 
      escape= (char *)memory::sql_alloc(escape_str->length());
 
4384
      escape= (char *)sql_alloc(escape_str->length());
4408
4385
      strcpy(escape, escape_str->ptr()); 
4409
4386
    }
4410
4387
    else
4411
4388
    {
4412
 
      escape= (char *)memory::sql_alloc(1);
 
4389
      escape= (char *)sql_alloc(1);
4413
4390
      strcpy(escape, "\\");
4414
4391
    } 
4415
4392
   
4432
4409
      */
4433
4410
 
4434
4411
      if (len > MIN_TURBOBM_PATTERN_LEN + 2 &&
4435
 
          *first == internal::wild_many &&
4436
 
          *last  == internal::wild_many)
 
4412
          *first == wild_many &&
 
4413
          *last  == wild_many)
4437
4414
      {
4438
4415
        const char* tmp = first + 1;
4439
 
        for (; *tmp != internal::wild_many && *tmp != internal::wild_one; tmp++)
 
4416
        for (; *tmp != wild_many && *tmp != wild_one; tmp++)
4440
4417
        {
4441
4418
          if (escape == tmp)
4442
4419
            break;
5171
5148
  str->append(')');
5172
5149
}
5173
5150
 
5174
 
} /* namespace drizzled */