← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/result.cc

  • Committer: Mark Atwood
  • Date: 2011-11-30 07:06:47 UTC
  • mfrom: (2463.1.6 drizzle-include)
  • Revision ID: me@mark.atwood.name-20111130070647-ixp7oalp70hkbt6l
merge lp:~brianaker/drizzle/libdrizzle-2.0-not-install

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-2.0/result.cc
46
46
 * Common definitions
47
47
 */
48
48
 
49
 
drizzle_result_st *drizzle_result_create(drizzle_con_st *con,
50
 
                                         drizzle_result_st *result)
 
49
drizzle_result_st *drizzle_result_create(drizzle_con_st *con)
 
50
{
 
51
  return drizzle_result_create_with(con, NULL);
 
52
}
 
53
 
 
54
drizzle_result_st *drizzle_result_create_with(drizzle_con_st *con,
 
55
                                              drizzle_result_st *result)
51
56
{
52
57
  if (result == NULL)
53
58
  {
58
63
      return NULL;
59
64
    }
60
65
 
61
 
    result->options|= DRIZZLE_RESULT_ALLOCATED;
 
66
    result->_options.is_allocated= true;
62
67
  }
63
68
  else
64
69
  {
93
98
    result->row_list= NULL;
94
99
    result->field_sizes= NULL;
95
100
    result->field_sizes_list= NULL;
 
101
 
 
102
    result->_options.is_allocated= false;
96
103
  }
97
104
 
98
105
  result->con= con;
108
115
}
109
116
 
110
117
drizzle_result_st *drizzle_result_clone(drizzle_con_st *con,
111
 
                                        drizzle_result_st *result,
112
 
                                        drizzle_result_st *from)
 
118
                                        drizzle_result_st *source)
113
119
{
114
 
  result= drizzle_result_create(con, result);
 
120
  drizzle_result_st *result= drizzle_result_create(con);
115
121
  if (result == NULL)
116
122
  {
117
123
    return NULL;
118
124
  }
119
125
 
120
 
  result->options|= from->options & ~DRIZZLE_RESULT_ALLOCATED;
 
126
  result->options= source->options;
121
127
 
122
 
  drizzle_result_set_info(result, from->info);
123
 
  result->error_code= from->error_code;
124
 
  drizzle_result_set_sqlstate(result, from->sqlstate);
125
 
  result->warning_count= from->warning_count;
126
 
  result->insert_id= from->insert_id;
127
 
  result->affected_rows= from->affected_rows;
128
 
  result->column_count= from->column_count;
129
 
  result->row_count= from->row_count;
 
128
  drizzle_result_set_info(result, source->info);
 
129
  result->error_code= source->error_code;
 
130
  drizzle_result_set_sqlstate(result, source->sqlstate);
 
131
  result->warning_count= source->warning_count;
 
132
  result->insert_id= source->insert_id;
 
133
  result->affected_rows= source->affected_rows;
 
134
  result->column_count= source->column_count;
 
135
  result->row_count= source->row_count;
130
136
 
131
137
  return result;
132
138
}
134
140
void drizzle_result_free(drizzle_result_st *result)
135
141
{
136
142
  drizzle_column_st *column;
137
 
  uint64_t x;
138
143
 
139
144
  if (result == NULL)
140
145
  {
150
155
 
151
156
  if (result->options & DRIZZLE_RESULT_BUFFER_ROW)
152
157
  {
153
 
    for (x= 0; x < result->row_count; x++)
154
 
      drizzle_row_free(result, result->row_list->at(static_cast<size_t>(x)));
 
158
    for (size_t x= 0; x < result->row_count; x++)
 
159
    {
 
160
      drizzle_row_free(result, result->row_list->at(x));
 
161
    }
155
162
 
156
163
    delete result->row_list;
157
164
    delete result->field_sizes_list;
163
170
    if (result->con->result_list == result)
164
171
      result->con->result_list= result->next;
165
172
  }
 
173
 
166
174
  if (result->prev)
167
175
    result->prev->next= result->next;
 
176
 
168
177
  if (result->next)
169
178
    result->next->prev= result->prev;
170
179
 
171
 
  if (result->options & DRIZZLE_RESULT_ALLOCATED)
 
180
  if (result->_options.is_allocated)
 
181
  {
172
182
    delete result;
 
183
  }
173
184
}
174
185
 
175
186
void drizzle_result_free_all(drizzle_con_st *con)
312
323
 
313
324
  if (drizzle_state_none(con))
314
325
  {
315
 
    con->result= drizzle_result_create(con, result);
 
326
    con->result= drizzle_result_create_with(con, result);
316
327
    if (con->result == NULL)
317
328
    {
318
329
      *ret_ptr= DRIZZLE_RETURN_MEMORY;