← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item_cmpfunc.cc

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item_cmpfunc.cc
26
26
#endif
27
27
 
28
28
#include "mysql_priv.h"
29
 
#include <m_ctype.h>
30
29
#include "sql_select.h"
31
30
 
32
31
static bool convert_constant_item(THD *, Item_field *, Item **);
757
756
      uint64_t value;
758
757
      bool error;
759
758
      String tmp, *str_val= 0;
760
 
      timestamp_type t_type= (date_arg->field_type() == MYSQL_TYPE_NEWDATE ?
 
759
      timestamp_type t_type= (date_arg->field_type() == DRIZZLE_TYPE_NEWDATE ?
761
760
                              MYSQL_TIMESTAMP_DATE : MYSQL_TIMESTAMP_DATETIME);
762
761
 
763
762
      str_val= str_arg->val_str(&tmp);
800
799
*/
801
800
 
802
801
uint64_t
803
 
get_time_value(THD *thd __attribute__((__unused__)),
 
802
get_time_value(THD *thd __attribute__((unused)),
804
803
               Item ***item_arg, Item **cache_arg,
805
 
               Item *warn_item __attribute__((__unused__)),
 
804
               Item *warn_item __attribute__((unused)),
806
805
               bool *is_null)
807
806
{
808
807
  uint64_t value;
878
877
    get_value_func= &get_datetime_value;
879
878
    return 0;
880
879
  }
881
 
  else if (type == STRING_RESULT && (*a)->field_type() == MYSQL_TYPE_TIME &&
882
 
           (*b)->field_type() == MYSQL_TYPE_TIME)
 
880
  else if (type == STRING_RESULT && (*a)->field_type() == DRIZZLE_TYPE_TIME &&
 
881
           (*b)->field_type() == DRIZZLE_TYPE_TIME)
883
882
  {
884
883
    /* Compare TIME values as integers. */
885
884
    thd= current_thd;
956
955
    *is_null= item->null_value;
957
956
    enum_field_types f_type= item->field_type();
958
957
    /*
959
 
      Item_date_add_interval may return MYSQL_TYPE_STRING as the result
 
958
      Item_date_add_interval may return DRIZZLE_TYPE_STRING as the result
960
959
      field type. To detect that the DATE value has been returned we
961
960
      compare it with 100000000L - any DATE value should be less than it.
962
961
      Don't shift cached DATETIME values up for the second time.
963
962
    */
964
 
    if (f_type == MYSQL_TYPE_NEWDATE ||
965
 
        (f_type != MYSQL_TYPE_DATETIME && value < 100000000L))
 
963
    if (f_type == DRIZZLE_TYPE_NEWDATE ||
 
964
        (f_type != DRIZZLE_TYPE_DATETIME && value < 100000000L))
966
965
      value*= 1000000L;
967
966
  }
968
967
  else
983
982
    bool error;
984
983
    enum_field_types f_type= warn_item->field_type();
985
984
    timestamp_type t_type= f_type ==
986
 
      MYSQL_TYPE_NEWDATE ? MYSQL_TIMESTAMP_DATE : MYSQL_TIMESTAMP_DATETIME;
 
985
      DRIZZLE_TYPE_NEWDATE ? MYSQL_TIMESTAMP_DATE : MYSQL_TIMESTAMP_DATETIME;
987
986
    value= get_date_from_str(thd, str, t_type, warn_item->name, &error);
988
987
    /*
989
988
      If str did not contain a valid date according to the current
999
998
  if (item->const_item() && cache_arg && (item->type() != Item::FUNC_ITEM ||
1000
999
      ((Item_func*)item)->functype() != Item_func::GUSERVAR_FUNC))
1001
1000
  {
1002
 
    Item_cache_int *cache= new Item_cache_int(MYSQL_TYPE_DATETIME);
 
1001
    Item_cache_int *cache= new Item_cache_int(DRIZZLE_TYPE_DATETIME);
1003
1002
    /* Mark the cache as non-const to prevent re-caching. */
1004
1003
    cache->set_used_tables(1);
1005
1004
    cache->store(item, value);
1462
1461
}
1463
1462
 
1464
1463
 
1465
 
bool Item_in_optimizer::fix_left(THD *thd, Item **ref __attribute__((__unused__)))
 
1464
bool Item_in_optimizer::fix_left(THD *thd, Item **ref __attribute__((unused)))
1466
1465
{
1467
1466
  if ((!args[0]->fixed && args[0]->fix_fields(thd, args)) ||
1468
1467
      (!cache && !(cache= Item_cache::get_cache(args[0]))))
2020
2019
        datetime_found= true;
2021
2020
        continue;
2022
2021
      }
2023
 
      if (args[i]->field_type() == MYSQL_TYPE_TIME &&
 
2022
      if (args[i]->field_type() == DRIZZLE_TYPE_TIME &&
2024
2023
          args[i]->result_as_int64_t())
2025
2024
        time_items_found++;
2026
2025
    }
2571
2570
           failed
2572
2571
*/
2573
2572
 
2574
 
Item *Item_func_case::find_item(String *str __attribute__((__unused__)))
 
2573
Item *Item_func_case::find_item(String *str __attribute__((unused)))
2575
2574
{
2576
2575
  uint value_added_map= 0;
2577
2576
 
3021
3020
    0           left argument is equal to the right argument.
3022
3021
    1           left argument is greater than the right argument.
3023
3022
*/
3024
 
int cmp_int64_t(void *cmp_arg __attribute__((__unused__)),
 
3023
int cmp_int64_t(void *cmp_arg __attribute__((unused)),
3025
3024
                 in_int64_t::packed_int64_t *a,
3026
3025
                 in_int64_t::packed_int64_t *b)
3027
3026
{
3046
3045
    return cmp_longs (a->val, b->val);
3047
3046
}
3048
3047
 
3049
 
static int cmp_double(void *cmp_arg __attribute__((__unused__)), double *a,double *b)
 
3048
static int cmp_double(void *cmp_arg __attribute__((unused)), double *a,double *b)
3050
3049
{
3051
3050
  return *a < *b ? -1 : *a == *b ? 0 : 1;
3052
3051
}
3053
3052
 
3054
 
static int cmp_row(void *cmp_arg __attribute__((__unused__)), cmp_item_row *a, cmp_item_row *b)
 
3053
static int cmp_row(void *cmp_arg __attribute__((unused)), cmp_item_row *a, cmp_item_row *b)
3055
3054
{
3056
3055
  return a->compare(b);
3057
3056
}
3058
3057
 
3059
3058
 
3060
 
static int cmp_decimal(void *cmp_arg __attribute__((__unused__)), my_decimal *a, my_decimal *b)
 
3059
static int cmp_decimal(void *cmp_arg __attribute__((unused)), my_decimal *a, my_decimal *b)
3061
3060
{
3062
3061
  /*
3063
3062
    We need call of fixing buffer pointer, because fast sort just copy
3134
3133
  return (uchar*) item->val_str(&tmp);
3135
3134
}
3136
3135
 
3137
 
in_row::in_row(uint elements, Item * item __attribute__((__unused__)))
 
3136
in_row::in_row(uint elements, Item * item __attribute__((unused)))
3138
3137
{
3139
3138
  base= (char*) new cmp_item_row[count= elements];
3140
3139
  size= sizeof(cmp_item_row);
3625
3624
            */
3626
3625
            if (!date_arg)
3627
3626
              date_arg= itm;
3628
 
            else if (itm->field_type() == MYSQL_TYPE_DATETIME)
 
3627
            else if (itm->field_type() == DRIZZLE_TYPE_DATETIME)
3629
3628
            {
3630
3629
              date_arg= itm;
3631
3630
              /* All arguments are already checked to have the STRING result. */
3889
3888
 
3890
3889
 
3891
3890
bool
3892
 
Item_cond::fix_fields(THD *thd, Item **ref __attribute__((__unused__)))
 
3891
Item_cond::fix_fields(THD *thd, Item **ref __attribute__((unused)))
3893
3892
{
3894
3893
  assert(fixed == 0);
3895
3894
  List_iterator<Item> li(list);
3966
3965
}
3967
3966
 
3968
3967
 
3969
 
void Item_cond::fix_after_pullout(st_select_lex *new_parent, Item **ref __attribute__((__unused__)))
 
3968
void Item_cond::fix_after_pullout(st_select_lex *new_parent, Item **ref __attribute__((unused)))
3970
3969
{
3971
3970
  List_iterator<Item> li(list);
3972
3971
  Item *item;
4464
4463
          Convert to "cs" if charset of escape differs.
4465
4464
        */
4466
4465
        CHARSET_INFO *cs= cmp.cmp_collation.collation;
4467
 
        uint32 unused;
 
4466
        uint32_t unused;
4468
4467
        if (escape_str->needs_conversion(escape_str->length(),
4469
4468
                                         escape_str->charset(), cs, &unused))
4470
4469
        {
4471
4470
          char ch;
4472
4471
          uint errors;
4473
 
          uint32 cnvlen= copy_and_convert(&ch, 1, cs, escape_str->ptr(),
 
4472
          uint32_t cnvlen= copy_and_convert(&ch, 1, cs, escape_str->ptr(),
4474
4473
                                          escape_str->length(),
4475
4474
                                          escape_str->charset(), &errors);
4476
4475
          escape= cnvlen ? ch : '\\';
4813
4812
    NULL if we cannot apply NOT transformation (see Item::neg_transformer()).
4814
4813
*/
4815
4814
 
4816
 
Item *Item_func_not::neg_transformer(THD *thd __attribute__((__unused__)))      /* NOT(x)  ->  x */
 
4815
Item *Item_func_not::neg_transformer(THD *thd __attribute__((unused)))  /* NOT(x)  ->  x */
4817
4816
{
4818
4817
  return args[0];
4819
4818
}
4820
4819
 
4821
4820
 
4822
 
Item *Item_bool_rowready_func2::neg_transformer(THD *thd __attribute__((__unused__)))
 
4821
Item *Item_bool_rowready_func2::neg_transformer(THD *thd __attribute__((unused)))
4823
4822
{
4824
4823
  Item *item= negated_item();
4825
4824
  return item;
4829
4828
/**
4830
4829
  a IS NULL  ->  a IS NOT NULL.
4831
4830
*/
4832
 
Item *Item_func_isnull::neg_transformer(THD *thd __attribute__((__unused__)))
 
4831
Item *Item_func_isnull::neg_transformer(THD *thd __attribute__((unused)))
4833
4832
{
4834
4833
  Item *item= new Item_func_isnotnull(args[0]);
4835
4834
  return item;
4839
4838
/**
4840
4839
  a IS NOT NULL  ->  a IS NULL.
4841
4840
*/
4842
 
Item *Item_func_isnotnull::neg_transformer(THD *thd __attribute__((__unused__)))
 
4841
Item *Item_func_isnotnull::neg_transformer(THD *thd __attribute__((unused)))
4843
4842
{
4844
4843
  Item *item= new Item_func_isnull(args[0]);
4845
4844
  return item;
4864
4863
}
4865
4864
 
4866
4865
 
4867
 
Item *Item_func_nop_all::neg_transformer(THD *thd __attribute__((__unused__)))
 
4866
Item *Item_func_nop_all::neg_transformer(THD *thd __attribute__((unused)))
4868
4867
{
4869
4868
  /* "NOT (e $cmp$ ANY (SELECT ...)) -> e $rev_cmp$" ALL (SELECT ...) */
4870
4869
  Item_func_not_all *new_item= new Item_func_not_all(args[0]);
4875
4874
  return new_item;
4876
4875
}
4877
4876
 
4878
 
Item *Item_func_not_all::neg_transformer(THD *thd __attribute__((__unused__)))
 
4877
Item *Item_func_not_all::neg_transformer(THD *thd __attribute__((unused)))
4879
4878
{
4880
4879
  /* "NOT (e $cmp$ ALL (SELECT ...)) -> e $rev_cmp$" ANY (SELECT ...) */
4881
4880
  Item_func_nop_all *new_item= new Item_func_nop_all(args[0]);
5115
5114
  }
5116
5115
}
5117
5116
 
5118
 
bool Item_equal::fix_fields(THD *thd __attribute__((__unused__)), Item **ref __attribute__((__unused__)))
 
5117
bool Item_equal::fix_fields(THD *thd __attribute__((unused)), Item **ref __attribute__((unused)))
5119
5118
{
5120
5119
  List_iterator_fast<Item_field> li(fields);
5121
5120
  Item *item;