← Back to branch summary

~posulliv/drizzle/optimizer-style-cleanup

« back to all changes in this revision

Viewing changes to plugin/status_dictionary/status.cc

  • Committer: Padraig O'Sullivan
  • Date: 2010-03-15 14:05:26 UTC
  • mfrom: (1237.9.99 staging)
  • Revision ID: osullivan.padraig@gmail.com-20100315140526-opbgwdwn6tfecdkq
Merge from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/status_dictionary/status.cc
38
38
  option_type(global ? OPT_GLOBAL : OPT_SESSION)
39
39
{
40
40
  add_field("VARIABLE_NAME");
41
 
  add_field("VARIABLE_VALUE", 16300);
 
41
  add_field("VARIABLE_VALUE", 1024);
42
42
}
43
43
 
44
44
StateTool::Generator::Generator(Field **arg, sql_var_t option_arg,
103
103
      variables++;
104
104
      continue;
105
105
    }
106
 
    else if (var->type != SHOW_ARRAY)
107
 
    {
108
 
      fill(variables->name, var->value, var->type);
109
 
    }
110
 
    else
111
 
    {
112
 
      variables++;
113
 
      continue;
114
 
    }
 
106
 
 
107
    fill(variables->name, var->value, var->type);
115
108
 
116
109
    variables++;
117
110
 
122
115
}
123
116
 
124
117
 
125
 
void StateTool::Generator::fill(const char *name, char *value, SHOW_TYPE show_type)
 
118
extern drizzled::KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
 
119
void StateTool::Generator::fill(const std::string &name, char *value, SHOW_TYPE show_type)
126
120
{
127
 
  MY_ALIGNED_BYTE_ARRAY(buff_data, SHOW_VAR_FUNC_BUFF_SIZE, int64_t);
128
 
  char * const buff= (char *) &buff_data;
129
121
  Session *session= current_session;
130
 
  const char *pos, *end;                  // We assign a lot of const's
131
122
  struct system_status_var *status_var;
 
123
  std::ostringstream oss;
 
124
 
 
125
 
 
126
  std::string return_value;
132
127
 
133
128
  /* Scope represents if the status should be session or global */
134
129
  status_var= getStatus();
142
137
                                                 &null_lex_str);
143
138
  }
144
139
 
145
 
  pos= end= buff;
146
140
  /*
147
141
    note that value may be == buff. All SHOW_xxx code below
148
142
    should still work in this case
152
146
    value= ((char *) status_var + (ulong) value);
153
147
    /* fall through */
154
148
  case SHOW_DOUBLE:
155
 
    /* 6 is the default precision for '%f' in sprintf() */
156
 
    end= buff + internal::my_fcvt(*(double *) value, 6, buff, NULL);
 
149
    oss.precision(6);
 
150
    oss << *(double *) value;
 
151
    return_value= oss.str();
157
152
    break;
158
153
  case SHOW_LONG_STATUS:
159
154
    value= ((char *) status_var + (ulong) value);
160
155
    /* fall through */
161
156
  case SHOW_LONG:
162
 
    end= internal::int10_to_str(*(long*) value, buff, 10);
 
157
    oss << *(int64_t*) value;
 
158
    return_value= oss.str();
163
159
    break;
164
160
  case SHOW_LONGLONG_STATUS:
165
161
    value= ((char *) status_var + (uint64_t) value);
166
162
    /* fall through */
167
163
  case SHOW_LONGLONG:
168
 
    end= internal::int64_t10_to_str(*(int64_t*) value, buff, 10);
 
164
    oss << *(int64_t*) value;
 
165
    return_value= oss.str();
169
166
    break;
170
167
  case SHOW_SIZE:
171
 
    {
172
 
      stringstream ss (stringstream::in);
173
 
      ss << *(size_t*) value;
174
 
 
175
 
      string str= ss.str();
176
 
      strncpy(buff, str.c_str(), str.length());
177
 
      end= buff+ str.length();
178
 
    }
 
168
    oss << *(size_t*) value;
 
169
    return_value= oss.str();
179
170
    break;
180
171
  case SHOW_HA_ROWS:
181
 
    end= internal::int64_t10_to_str((int64_t) *(ha_rows*) value, buff, 10);
 
172
    oss << (int64_t) *(ha_rows*) value;
 
173
    return_value= oss.str();
182
174
    break;
183
175
  case SHOW_BOOL:
184
 
    end+= sprintf(buff,"%s", *(bool*) value ? "ON" : "OFF");
185
 
    break;
186
176
  case SHOW_MY_BOOL:
187
 
    end+= sprintf(buff,"%s", *(bool*) value ? "ON" : "OFF");
 
177
    return_value= *(bool*) value ? "ON" : "OFF";
188
178
    break;
189
179
  case SHOW_INT:
190
180
  case SHOW_INT_NOFLUSH: // the difference lies in refresh_status()
191
 
    end= internal::int10_to_str((long) *(uint32_t*) value, buff, 10);
 
181
    oss << (long) *(uint32_t*) value;
 
182
    return_value= oss.str();
192
183
    break;
193
184
  case SHOW_CHAR:
194
185
    {
195
 
      if (!(pos= value))
196
 
        pos= "";
197
 
      end= strchr(pos, '\0');
 
186
      if (value)
 
187
        return_value= value;
198
188
      break;
199
189
    }
200
190
  case SHOW_CHAR_PTR:
201
191
    {
202
 
      if (!(pos= *(char**) value))
203
 
        pos= "";
204
 
      end= strchr(pos, '\0');
 
192
      if (*(char**) value)
 
193
        return_value= *(char**) value;
 
194
 
205
195
      break;
206
196
    }
207
197
  case SHOW_KEY_CACHE_LONG:
 
198
    value= (char*) dflt_key_cache + (unsigned long)value;
 
199
    oss << *(long*) value;
 
200
    return_value= oss.str();
 
201
    break;
208
202
  case SHOW_KEY_CACHE_LONGLONG:
209
 
    pos= "not supported";
210
 
    end= pos + sizeof("not supported");
 
203
    value= (char*) dflt_key_cache + (unsigned long)value;
 
204
    oss << *(int64_t*) value;
 
205
    return_value= oss.str();
 
206
    break;
211
207
  case SHOW_UNDEF:
212
208
    break;                                        // Return empty string
213
209
  case SHOW_SYS:                                  // Cannot happen
217
213
  }
218
214
  pthread_mutex_unlock(&LOCK_global_system_variables);
219
215
  push(name);
220
 
  if (end - pos)
221
 
    push(pos, (uint32_t) (end - pos));
 
216
  if (return_value.length())
 
217
    push(return_value);
222
218
  else 
223
 
    push();
 
219
    push(" ");
224
220
}