← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/row.cc

  • Committer: Brian Aker
  • Date: 2010-12-18 18:24:57 UTC
  • mfrom: (1999.6.3 trunk)
  • Revision ID: brian@tangent.org-20101218182457-yi1wd0so2hml1k1w
Merge in Lee's copyright header fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/row.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
 
 
16
 
#include <drizzled/server_includes.h>
 
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
15
 
 
16
#include "config.h"
 
17
#include <drizzled/error.h>
 
18
#include <drizzled/session.h>
 
19
 
 
20
#include <drizzled/item/row.h>
 
21
 
 
22
namespace drizzled
 
23
{
17
24
 
18
25
/**
19
26
  Row items used for comparing rows and IN operations on rows:
35
42
 
36
43
  //TODO: think placing 2-3 component items in item (as it done for function)
37
44
  if ((arg_count= arg.elements))
38
 
    items= (Item**) sql_alloc(sizeof(Item*)*arg_count);
 
45
    items= (Item**) memory::sql_alloc(sizeof(Item*)*arg_count);
39
46
  else
40
47
    items= 0;
41
48
  List_iterator<Item> li(arg);
42
 
  uint i= 0;
 
49
  uint32_t i= 0;
43
50
  Item *item;
44
51
  while ((item= li++))
45
52
  {
46
53
    items[i]= item;
47
 
    i++;    
 
54
    i++;
48
55
  }
49
56
}
50
57
 
51
 
void Item_row::illegal_method_call(const char *method __attribute__((unused)))
 
58
void Item_row::illegal_method_call(const char *)
52
59
{
53
60
  assert(0);
54
61
  my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
55
62
  return;
56
63
}
57
64
 
58
 
bool Item_row::fix_fields(THD *thd, Item **ref __attribute__((unused)))
 
65
bool Item_row::fix_fields(Session *session, Item **)
59
66
{
60
67
  assert(fixed == 0);
61
68
  null_value= 0;
63
70
  Item **arg, **arg_end;
64
71
  for (arg= items, arg_end= items+arg_count; arg != arg_end ; arg++)
65
72
  {
66
 
    if ((*arg)->fix_fields(thd, arg))
 
73
    if ((*arg)->fix_fields(session, arg))
67
74
      return true;
68
75
    // we can't assign 'item' before, because fix_fields() can change arg
69
76
    Item *item= *arg;
99
106
}
100
107
 
101
108
 
102
 
void Item_row::split_sum_func(THD *thd, Item **ref_pointer_array,
 
109
void Item_row::split_sum_func(Session *session, Item **ref_pointer_array,
103
110
                              List<Item> &fields)
104
111
{
105
112
  Item **arg, **arg_end;
106
113
  for (arg= items, arg_end= items+arg_count; arg != arg_end ; arg++)
107
 
    (*arg)->split_sum_func2(thd, ref_pointer_array, fields, arg, true);
 
114
    (*arg)->split_sum_func(session, ref_pointer_array, fields, arg, true);
108
115
}
109
116
 
110
117
 
112
119
{
113
120
  used_tables_cache= 0;
114
121
  const_item_cache= 1;
115
 
  for (uint i= 0; i < arg_count; i++)
 
122
  for (uint32_t i= 0; i < arg_count; i++)
116
123
  {
117
124
    items[i]->update_used_tables();
118
125
    used_tables_cache|= items[i]->used_tables();
120
127
  }
121
128
}
122
129
 
123
 
void Item_row::fix_after_pullout(st_select_lex *new_parent,
124
 
                                 Item **ref __attribute__((unused)))
 
130
void Item_row::fix_after_pullout(Select_Lex *new_parent, Item **)
125
131
{
126
132
  used_tables_cache= 0;
127
133
  const_item_cache= 1;
128
 
  for (uint i= 0; i < arg_count; i++)
 
134
  for (uint32_t i= 0; i < arg_count; i++)
129
135
  {
130
136
    items[i]->fix_after_pullout(new_parent, &items[i]);
131
137
    used_tables_cache|= items[i]->used_tables();
133
139
  }
134
140
}
135
141
 
136
 
bool Item_row::check_cols(uint c)
 
142
bool Item_row::check_cols(uint32_t c)
137
143
{
138
144
  if (c != arg_count)
139
145
  {
146
152
void Item_row::print(String *str, enum_query_type query_type)
147
153
{
148
154
  str->append('(');
149
 
  for (uint i= 0; i < arg_count; i++)
 
155
  for (uint32_t i= 0; i < arg_count; i++)
150
156
  {
151
157
    if (i)
152
158
      str->append(',');
156
162
}
157
163
 
158
164
 
159
 
bool Item_row::walk(Item_processor processor, bool walk_subquery, uchar *arg)
 
165
bool Item_row::walk(Item_processor processor, bool walk_subquery, unsigned char *arg)
160
166
{
161
 
  for (uint i= 0; i < arg_count; i++)
 
167
  for (uint32_t i= 0; i < arg_count; i++)
162
168
  {
163
169
    if (items[i]->walk(processor, walk_subquery, arg))
164
170
      return 1;
167
173
}
168
174
 
169
175
 
170
 
Item *Item_row::transform(Item_transformer transformer, uchar *arg)
 
176
Item *Item_row::transform(Item_transformer transformer, unsigned char *arg)
171
177
{
172
 
  for (uint i= 0; i < arg_count; i++)
 
178
  for (uint32_t i= 0; i < arg_count; i++)
173
179
  {
174
180
    Item *new_item= items[i]->transform(transformer, arg);
175
181
    if (!new_item)
176
182
      return 0;
177
183
 
178
184
    /*
179
 
      THD::change_item_tree() should be called only if the tree was
 
185
      Session::change_item_tree() should be called only if the tree was
180
186
      really transformed, i.e. when a new item has been created.
181
187
      Otherwise we'll be allocating a lot of unnecessary memory for
182
188
      change records at each execution.
183
189
    */
184
190
    if (items[i] != new_item)
185
 
      current_thd->change_item_tree(&items[i], new_item);
 
191
      current_session->change_item_tree(&items[i], new_item);
186
192
  }
187
193
  return (this->*transformer)(arg);
188
194
}
189
195
 
190
196
void Item_row::bring_value()
191
197
{
192
 
  for (uint i= 0; i < arg_count; i++)
 
198
  for (uint32_t i= 0; i < arg_count; i++)
193
199
    items[i]->bring_value();
194
200
}
 
201
 
 
202
} /* namespace drizzled */