← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/cmpfunc.cc

  • Committer: Monty Taylor
  • Date: 2011-02-12 21:49:59 UTC
  • mto: (2165.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 2166.
  • Revision ID: mordred@inaugust.com-20110212214959-bve8sh4hu761y48m
Updated the windows build to be able to build from the command line and not to show warnings on strncpy.

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>
25
 
 
26
 
#include <drizzled/cached_item.h>
27
 
#include <drizzled/check_stack_overrun.h>
28
 
#include <drizzled/current_session.h>
29
 
#include <drizzled/error.h>
30
 
#include <drizzled/internal/my_sys.h>
31
 
#include <drizzled/item/cache_int.h>
32
 
#include <drizzled/item/cmpfunc.h>
33
 
#include <drizzled/item/int_with_ref.h>
34
 
#include <drizzled/item/subselect.h>
35
 
#include <drizzled/session.h>
36
 
#include <drizzled/sql_select.h>
37
 
#include <drizzled/temporal.h>
38
 
#include <drizzled/time_functions.h>
39
 
 
 
24
#include "config.h"
 
25
#include "drizzled/sql_select.h"
 
26
#include "drizzled/error.h"
 
27
#include "drizzled/temporal.h"
 
28
#include "drizzled/item/cmpfunc.h"
 
29
#include "drizzled/cached_item.h"
 
30
#include "drizzled/item/cache_int.h"
 
31
#include "drizzled/item/int_with_ref.h"
 
32
#include "drizzled/check_stack_overrun.h"
 
33
#include "drizzled/time_functions.h"
 
34
#include "drizzled/internal/my_sys.h"
40
35
#include <math.h>
41
36
#include <algorithm>
42
37
 
572
567
  set_cmp_func();
573
568
}
574
569
 
575
 
Arg_comparator::Arg_comparator():
576
 
  session(current_session),
577
 
  a_cache(0),
578
 
  b_cache(0)
579
 
{}
580
 
 
581
 
Arg_comparator::Arg_comparator(Item **a1, Item **a2):
582
 
  a(a1),
583
 
  b(a2),
584
 
  session(current_session),
585
 
  a_cache(0),
586
 
  b_cache(0)
587
 
{}
588
570
 
589
571
int Arg_comparator::set_compare_func(Item_bool_func2 *item, Item_result type)
590
572
{
1997
1979
  if (Item_func_opt_neg::fix_fields(session, ref))
1998
1980
    return 1;
1999
1981
 
2000
 
  session->getLex()->current_select->between_count++;
 
1982
  session->lex->current_select->between_count++;
2001
1983
 
2002
1984
  /* not_null_tables_cache == union(T1(e),T1(e1),T1(e2)) */
2003
1985
  if (pred_level && !negated)
3217
3199
  return (unsigned char*) &tmp;
3218
3200
}
3219
3201
 
3220
 
in_datetime::in_datetime(Item *warn_item_arg, uint32_t elements) :
3221
 
  in_int64_t(elements),
3222
 
  session(current_session),
3223
 
  warn_item(warn_item_arg),
3224
 
  lval_cache(0)
3225
 
{}
3226
 
 
3227
3202
void in_datetime::set(uint32_t pos, Item *item)
3228
3203
{
3229
3204
  Item **tmp_item= &item;
3886
3861
 
3887
3862
void Item_cond::copy_andor_arguments(Session *session, Item_cond *item)
3888
3863
{
3889
 
  List<Item>::iterator li(item->list.begin());
 
3864
  List_iterator_fast<Item> li(item->list);
3890
3865
  while (Item *it= li++)
3891
3866
    list.push_back(it->copy_andor_structure(session));
3892
3867
}
3896
3871
Item_cond::fix_fields(Session *session, Item **)
3897
3872
{
3898
3873
  assert(fixed == 0);
3899
 
  List<Item>::iterator li(list.begin());
 
3874
  List_iterator<Item> li(list);
3900
3875
  Item *item;
3901
3876
  void *orig_session_marker= session->session_marker;
3902
3877
  unsigned char buff[sizeof(char*)];                    // Max local vars in function
3936
3911
           !((Item_cond*) item)->list.is_empty())
3937
3912
    {                                           // Identical function
3938
3913
      li.replace(((Item_cond*) item)->list);
3939
 
      ((Item_cond*) item)->list.clear();
 
3914
      ((Item_cond*) item)->list.empty();
3940
3915
      item= *li.ref();                          // new current item
3941
3916
    }
3942
3917
    if (abort_on_null)
3962
3937
    if (item->maybe_null)
3963
3938
      maybe_null=1;
3964
3939
  }
3965
 
  session->getLex()->current_select->cond_count+= list.elements;
 
3940
  session->lex->current_select->cond_count+= list.elements;
3966
3941
  session->session_marker= orig_session_marker;
3967
3942
  fix_length_and_dec();
3968
3943
  fixed= 1;
3972
3947
 
3973
3948
void Item_cond::fix_after_pullout(Select_Lex *new_parent, Item **)
3974
3949
{
3975
 
  List<Item>::iterator li(list.begin());
 
3950
  List_iterator<Item> li(list);
3976
3951
  Item *item;
3977
3952
 
3978
3953
  used_tables_cache=0;
4004
3979
 
4005
3980
bool Item_cond::walk(Item_processor processor, bool walk_subquery, unsigned char *arg)
4006
3981
{
4007
 
  List<Item>::iterator li(list.begin());
 
3982
  List_iterator_fast<Item> li(list);
4008
3983
  Item *item;
4009
3984
  while ((item= li++))
4010
3985
    if (item->walk(processor, walk_subquery, arg))
4033
4008
 
4034
4009
Item *Item_cond::transform(Item_transformer transformer, unsigned char *arg)
4035
4010
{
4036
 
  List<Item>::iterator li(list.begin());
 
4011
  List_iterator<Item> li(list);
4037
4012
  Item *item;
4038
4013
  while ((item= li++))
4039
4014
  {
4084
4059
  if (!(this->*analyzer)(arg_p))
4085
4060
    return 0;
4086
4061
 
4087
 
  List<Item>::iterator li(list.begin());
 
4062
  List_iterator<Item> li(list);
4088
4063
  Item *item;
4089
4064
  while ((item= li++))
4090
4065
  {
4103
4078
void Item_cond::traverse_cond(Cond_traverser traverser,
4104
4079
                              void *arg, traverse_order order)
4105
4080
{
4106
 
  List<Item>::iterator li(list.begin());
 
4081
  List_iterator<Item> li(list);
4107
4082
  Item *item;
4108
4083
 
4109
4084
  switch (order) {
4144
4119
void Item_cond::split_sum_func(Session *session, Item **ref_pointer_array,
4145
4120
                               List<Item> &fields)
4146
4121
{
4147
 
  List<Item>::iterator li(list.begin());
 
4122
  List_iterator<Item> li(list);
4148
4123
  Item *item;
4149
4124
  while ((item= li++))
4150
4125
    item->split_sum_func(session, ref_pointer_array,
4161
4136
 
4162
4137
void Item_cond::update_used_tables()
4163
4138
{
4164
 
  List<Item>::iterator li(list.begin());
 
4139
  List_iterator_fast<Item> li(list);
4165
4140
  Item *item;
4166
4141
 
4167
4142
  used_tables_cache=0;
4178
4153
void Item_cond::print(String *str, enum_query_type query_type)
4179
4154
{
4180
4155
  str->append('(');
4181
 
  List<Item>::iterator li(list.begin());
 
4156
  List_iterator_fast<Item> li(list);
4182
4157
  Item *item;
4183
4158
  if ((item=li++))
4184
4159
    item->print(str, query_type);
4195
4170
 
4196
4171
void Item_cond::neg_arguments(Session *session)
4197
4172
{
4198
 
  List<Item>::iterator li(list.begin());
 
4173
  List_iterator<Item> li(list);
4199
4174
  Item *item;
4200
4175
  while ((item= li++))          /* Apply not transformation to the arguments */
4201
4176
  {
4233
4208
int64_t Item_cond_and::val_int()
4234
4209
{
4235
4210
  assert(fixed == 1);
4236
 
  List<Item>::iterator li(list.begin());
 
4211
  List_iterator_fast<Item> li(list);
4237
4212
  Item *item;
4238
4213
  null_value= 0;
4239
4214
  while ((item=li++))
4251
4226
int64_t Item_cond_or::val_int()
4252
4227
{
4253
4228
  assert(fixed == 1);
4254
 
  List<Item>::iterator li(list.begin());
 
4229
  List_iterator_fast<Item> li(list);
4255
4230
  Item *item;
4256
4231
  null_value=0;
4257
4232
  while ((item=li++))
4651
4626
 
4652
4627
bool Item_func_like::turboBM_matches(const char* text, int text_len) const
4653
4628
{
4654
 
  int bcShift;
4655
 
  int turboShift;
 
4629
  register int bcShift;
 
4630
  register int turboShift;
4656
4631
  int shift = pattern_len;
4657
4632
  int j     = 0;
4658
4633
  int u     = 0;
4666
4641
  {
4667
4642
    while (j <= tlmpl)
4668
4643
    {
4669
 
      int i= plm1;
 
4644
      register int i= plm1;
4670
4645
      while (i >= 0 && pattern[i] == text[i + j])
4671
4646
      {
4672
4647
        i--;
4676
4651
      if (i < 0)
4677
4652
        return 1;
4678
4653
 
4679
 
      const int v = plm1 - i;
 
4654
      register const int v = plm1 - i;
4680
4655
      turboShift = u - v;
4681
4656
      bcShift    = bmBc[(uint32_t) (unsigned char) text[i + j]] - plm1 + i;
4682
4657
      shift      = (turboShift > bcShift) ? turboShift : bcShift;
4697
4672
  {
4698
4673
    while (j <= tlmpl)
4699
4674
    {
4700
 
      int i = plm1;
 
4675
      register int i = plm1;
4701
4676
      while (i >= 0 && likeconv(cs,pattern[i]) == likeconv(cs,text[i + j]))
4702
4677
      {
4703
4678
        i--;
4708
4683
      if (i < 0)
4709
4684
        return 1;
4710
4685
 
4711
 
      const int v= plm1 - i;
 
4686
      register const int v= plm1 - i;
4712
4687
      turboShift= u - v;
4713
4688
      bcShift= bmBc[(uint32_t) likeconv(cs, text[i + j])] - plm1 + i;
4714
4689
      shift= (turboShift > bcShift) ? turboShift : bcShift;
4749
4724
int64_t Item_cond_xor::val_int()
4750
4725
{
4751
4726
  assert(fixed == 1);
4752
 
  List<Item>::iterator li(list.begin());
 
4727
  List_iterator<Item> li(list);
4753
4728
  Item *item;
4754
4729
  int result=0;
4755
4730
  null_value=0;
4929
4904
  : item::function::Boolean(), eval_item(0), cond_false(0)
4930
4905
{
4931
4906
  const_item_cache= false;
4932
 
  List<Item_field>::iterator li(item_equal->fields.begin());
 
4907
  List_iterator_fast<Item_field> li(item_equal->fields);
4933
4908
  Item_field *item;
4934
4909
  while ((item= li++))
4935
4910
  {
4981
4956
 
4982
4957
bool Item_equal::contains(Field *field)
4983
4958
{
4984
 
  List<Item_field>::iterator it(fields.begin());
 
4959
  List_iterator_fast<Item_field> it(fields);
4985
4960
  Item_field *item;
4986
4961
  while ((item= it++))
4987
4962
  {
5040
5015
void Item_equal::sort(Item_field_cmpfunc cmp, void *arg)
5041
5016
{
5042
5017
  bool swap;
5043
 
  List<Item_field>::iterator it(fields.begin());
 
5018
  List_iterator<Item_field> it(fields);
5044
5019
  do
5045
5020
  {
5046
5021
    Item_field *item1= it++;
5064
5039
        ref1= ref2;
5065
5040
      }
5066
5041
    }
5067
 
    it= fields.begin();
 
5042
    it.rewind();
5068
5043
  } while (swap);
5069
5044
}
5070
5045
 
5081
5056
 
5082
5057
void Item_equal::update_const()
5083
5058
{
5084
 
  List<Item_field>::iterator it(fields.begin());
 
5059
  List_iterator<Item_field> it(fields);
5085
5060
  Item *item;
5086
5061
  while ((item= it++))
5087
5062
  {
5095
5070
 
5096
5071
bool Item_equal::fix_fields(Session *, Item **)
5097
5072
{
5098
 
  List<Item_field>::iterator li(fields.begin());
 
5073
  List_iterator_fast<Item_field> li(fields);
5099
5074
  Item *item;
5100
5075
  not_null_tables_cache= used_tables_cache= 0;
5101
5076
  const_item_cache= false;
5115
5090
 
5116
5091
void Item_equal::update_used_tables()
5117
5092
{
5118
 
  List<Item_field>::iterator li(fields.begin());
 
5093
  List_iterator_fast<Item_field> li(fields);
5119
5094
  Item *item;
5120
5095
  not_null_tables_cache= used_tables_cache= 0;
5121
5096
  if ((const_item_cache= cond_false))
5133
5108
  Item_field *item_field;
5134
5109
  if (cond_false)
5135
5110
    return 0;
5136
 
  List<Item_field>::iterator it(fields.begin());
 
5111
  List_iterator_fast<Item_field> it(fields);
5137
5112
  Item *item= const_item ? const_item : it++;
5138
5113
  eval_item->store_value(item);
5139
5114
  if ((null_value= item->null_value))
5159
5134
 
5160
5135
bool Item_equal::walk(Item_processor processor, bool walk_subquery, unsigned char *arg)
5161
5136
{
5162
 
  List<Item_field>::iterator it(fields.begin());
 
5137
  List_iterator_fast<Item_field> it(fields);
5163
5138
  Item *item;
5164
5139
  while ((item= it++))
5165
5140
  {
5171
5146
 
5172
5147
Item *Item_equal::transform(Item_transformer transformer, unsigned char *arg)
5173
5148
{
5174
 
  List<Item_field>::iterator it(fields.begin());
 
5149
  List_iterator<Item_field> it(fields);
5175
5150
  Item *item;
5176
5151
  while ((item= it++))
5177
5152
  {
5195
5170
{
5196
5171
  str->append(func_name());
5197
5172
  str->append('(');
5198
 
  List<Item_field>::iterator it(fields.begin());
 
5173
  List_iterator_fast<Item_field> it(fields);
5199
5174
  Item *item;
5200
5175
  if (const_item)
5201
5176
    const_item->print(str, query_type);
5213
5188
  str->append(')');
5214
5189
}
5215
5190
 
5216
 
cmp_item_datetime::cmp_item_datetime(Item *warn_item_arg) :
5217
 
  session(current_session),
5218
 
  warn_item(warn_item_arg),
5219
 
  lval_cache(0)
5220
 
{}
5221
 
 
5222
5191
} /* namespace drizzled */