← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/cmpfunc.cc

  • Committer: Brian Aker
  • Date: 2011-02-22 06:12:02 UTC
  • mfrom: (2190.1.6 drizzle-build)
  • Revision ID: brian@tangent.org-20110222061202-k03czxykqy4x9hjs
List update, header fixes, multiple symbols, and David deletes some code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/cmpfunc.cc
3886
3886
 
3887
3887
void Item_cond::copy_andor_arguments(Session *session, Item_cond *item)
3888
3888
{
3889
 
  List<Item>::iterator li(item->list);
 
3889
  List<Item>::iterator li(item->list.begin());
3890
3890
  while (Item *it= li++)
3891
3891
    list.push_back(it->copy_andor_structure(session));
3892
3892
}
3896
3896
Item_cond::fix_fields(Session *session, Item **)
3897
3897
{
3898
3898
  assert(fixed == 0);
3899
 
  List<Item>::iterator li(list);
 
3899
  List<Item>::iterator li(list.begin());
3900
3900
  Item *item;
3901
3901
  void *orig_session_marker= session->session_marker;
3902
3902
  unsigned char buff[sizeof(char*)];                    // Max local vars in function
3972
3972
 
3973
3973
void Item_cond::fix_after_pullout(Select_Lex *new_parent, Item **)
3974
3974
{
3975
 
  List<Item>::iterator li(list);
 
3975
  List<Item>::iterator li(list.begin());
3976
3976
  Item *item;
3977
3977
 
3978
3978
  used_tables_cache=0;
4004
4004
 
4005
4005
bool Item_cond::walk(Item_processor processor, bool walk_subquery, unsigned char *arg)
4006
4006
{
4007
 
  List<Item>::iterator li(list);
 
4007
  List<Item>::iterator li(list.begin());
4008
4008
  Item *item;
4009
4009
  while ((item= li++))
4010
4010
    if (item->walk(processor, walk_subquery, arg))
4033
4033
 
4034
4034
Item *Item_cond::transform(Item_transformer transformer, unsigned char *arg)
4035
4035
{
4036
 
  List<Item>::iterator li(list);
 
4036
  List<Item>::iterator li(list.begin());
4037
4037
  Item *item;
4038
4038
  while ((item= li++))
4039
4039
  {
4084
4084
  if (!(this->*analyzer)(arg_p))
4085
4085
    return 0;
4086
4086
 
4087
 
  List<Item>::iterator li(list);
 
4087
  List<Item>::iterator li(list.begin());
4088
4088
  Item *item;
4089
4089
  while ((item= li++))
4090
4090
  {
4103
4103
void Item_cond::traverse_cond(Cond_traverser traverser,
4104
4104
                              void *arg, traverse_order order)
4105
4105
{
4106
 
  List<Item>::iterator li(list);
 
4106
  List<Item>::iterator li(list.begin());
4107
4107
  Item *item;
4108
4108
 
4109
4109
  switch (order) {
4144
4144
void Item_cond::split_sum_func(Session *session, Item **ref_pointer_array,
4145
4145
                               List<Item> &fields)
4146
4146
{
4147
 
  List<Item>::iterator li(list);
 
4147
  List<Item>::iterator li(list.begin());
4148
4148
  Item *item;
4149
4149
  while ((item= li++))
4150
4150
    item->split_sum_func(session, ref_pointer_array,
4161
4161
 
4162
4162
void Item_cond::update_used_tables()
4163
4163
{
4164
 
  List<Item>::iterator li(list);
 
4164
  List<Item>::iterator li(list.begin());
4165
4165
  Item *item;
4166
4166
 
4167
4167
  used_tables_cache=0;
4178
4178
void Item_cond::print(String *str, enum_query_type query_type)
4179
4179
{
4180
4180
  str->append('(');
4181
 
  List<Item>::iterator li(list);
 
4181
  List<Item>::iterator li(list.begin());
4182
4182
  Item *item;
4183
4183
  if ((item=li++))
4184
4184
    item->print(str, query_type);
4195
4195
 
4196
4196
void Item_cond::neg_arguments(Session *session)
4197
4197
{
4198
 
  List<Item>::iterator li(list);
 
4198
  List<Item>::iterator li(list.begin());
4199
4199
  Item *item;
4200
4200
  while ((item= li++))          /* Apply not transformation to the arguments */
4201
4201
  {
4233
4233
int64_t Item_cond_and::val_int()
4234
4234
{
4235
4235
  assert(fixed == 1);
4236
 
  List<Item>::iterator li(list);
 
4236
  List<Item>::iterator li(list.begin());
4237
4237
  Item *item;
4238
4238
  null_value= 0;
4239
4239
  while ((item=li++))
4251
4251
int64_t Item_cond_or::val_int()
4252
4252
{
4253
4253
  assert(fixed == 1);
4254
 
  List<Item>::iterator li(list);
 
4254
  List<Item>::iterator li(list.begin());
4255
4255
  Item *item;
4256
4256
  null_value=0;
4257
4257
  while ((item=li++))
4651
4651
 
4652
4652
bool Item_func_like::turboBM_matches(const char* text, int text_len) const
4653
4653
{
4654
 
  register int bcShift;
4655
 
  register int turboShift;
 
4654
  int bcShift;
 
4655
  int turboShift;
4656
4656
  int shift = pattern_len;
4657
4657
  int j     = 0;
4658
4658
  int u     = 0;
4666
4666
  {
4667
4667
    while (j <= tlmpl)
4668
4668
    {
4669
 
      register int i= plm1;
 
4669
      int i= plm1;
4670
4670
      while (i >= 0 && pattern[i] == text[i + j])
4671
4671
      {
4672
4672
        i--;
4676
4676
      if (i < 0)
4677
4677
        return 1;
4678
4678
 
4679
 
      register const int v = plm1 - i;
 
4679
      const int v = plm1 - i;
4680
4680
      turboShift = u - v;
4681
4681
      bcShift    = bmBc[(uint32_t) (unsigned char) text[i + j]] - plm1 + i;
4682
4682
      shift      = (turboShift > bcShift) ? turboShift : bcShift;
4697
4697
  {
4698
4698
    while (j <= tlmpl)
4699
4699
    {
4700
 
      register int i = plm1;
 
4700
      int i = plm1;
4701
4701
      while (i >= 0 && likeconv(cs,pattern[i]) == likeconv(cs,text[i + j]))
4702
4702
      {
4703
4703
        i--;
4708
4708
      if (i < 0)
4709
4709
        return 1;
4710
4710
 
4711
 
      register const int v= plm1 - i;
 
4711
      const int v= plm1 - i;
4712
4712
      turboShift= u - v;
4713
4713
      bcShift= bmBc[(uint32_t) likeconv(cs, text[i + j])] - plm1 + i;
4714
4714
      shift= (turboShift > bcShift) ? turboShift : bcShift;
4749
4749
int64_t Item_cond_xor::val_int()
4750
4750
{
4751
4751
  assert(fixed == 1);
4752
 
  List<Item>::iterator li(list);
 
4752
  List<Item>::iterator li(list.begin());
4753
4753
  Item *item;
4754
4754
  int result=0;
4755
4755
  null_value=0;
4929
4929
  : item::function::Boolean(), eval_item(0), cond_false(0)
4930
4930
{
4931
4931
  const_item_cache= false;
4932
 
  List<Item_field>::iterator li(item_equal->fields);
 
4932
  List<Item_field>::iterator li(item_equal->fields.begin());
4933
4933
  Item_field *item;
4934
4934
  while ((item= li++))
4935
4935
  {
4981
4981
 
4982
4982
bool Item_equal::contains(Field *field)
4983
4983
{
4984
 
  List<Item_field>::iterator it(fields);
 
4984
  List<Item_field>::iterator it(fields.begin());
4985
4985
  Item_field *item;
4986
4986
  while ((item= it++))
4987
4987
  {
5040
5040
void Item_equal::sort(Item_field_cmpfunc cmp, void *arg)
5041
5041
{
5042
5042
  bool swap;
5043
 
  List<Item_field>::iterator it(fields);
 
5043
  List<Item_field>::iterator it(fields.begin());
5044
5044
  do
5045
5045
  {
5046
5046
    Item_field *item1= it++;
5081
5081
 
5082
5082
void Item_equal::update_const()
5083
5083
{
5084
 
  List<Item_field>::iterator it(fields);
 
5084
  List<Item_field>::iterator it(fields.begin());
5085
5085
  Item *item;
5086
5086
  while ((item= it++))
5087
5087
  {
5095
5095
 
5096
5096
bool Item_equal::fix_fields(Session *, Item **)
5097
5097
{
5098
 
  List<Item_field>::iterator li(fields);
 
5098
  List<Item_field>::iterator li(fields.begin());
5099
5099
  Item *item;
5100
5100
  not_null_tables_cache= used_tables_cache= 0;
5101
5101
  const_item_cache= false;
5115
5115
 
5116
5116
void Item_equal::update_used_tables()
5117
5117
{
5118
 
  List<Item_field>::iterator li(fields);
 
5118
  List<Item_field>::iterator li(fields.begin());
5119
5119
  Item *item;
5120
5120
  not_null_tables_cache= used_tables_cache= 0;
5121
5121
  if ((const_item_cache= cond_false))
5133
5133
  Item_field *item_field;
5134
5134
  if (cond_false)
5135
5135
    return 0;
5136
 
  List<Item_field>::iterator it(fields);
 
5136
  List<Item_field>::iterator it(fields.begin());
5137
5137
  Item *item= const_item ? const_item : it++;
5138
5138
  eval_item->store_value(item);
5139
5139
  if ((null_value= item->null_value))
5159
5159
 
5160
5160
bool Item_equal::walk(Item_processor processor, bool walk_subquery, unsigned char *arg)
5161
5161
{
5162
 
  List<Item_field>::iterator it(fields);
 
5162
  List<Item_field>::iterator it(fields.begin());
5163
5163
  Item *item;
5164
5164
  while ((item= it++))
5165
5165
  {
5171
5171
 
5172
5172
Item *Item_equal::transform(Item_transformer transformer, unsigned char *arg)
5173
5173
{
5174
 
  List<Item_field>::iterator it(fields);
 
5174
  List<Item_field>::iterator it(fields.begin());
5175
5175
  Item *item;
5176
5176
  while ((item= it++))
5177
5177
  {
5195
5195
{
5196
5196
  str->append(func_name());
5197
5197
  str->append('(');
5198
 
  List<Item_field>::iterator it(fields);
 
5198
  List<Item_field>::iterator it(fields.begin());
5199
5199
  Item *item;
5200
5200
  if (const_item)
5201
5201
    const_item->print(str, query_type);