← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/logging_stats/stats_schema.cc

  • Committer: Monty Taylor
  • Date: 2010-04-22 02:46:23 UTC
  • mto: (1497.3.4 enable-dtrace)
  • mto: This revision was merged to the branch mainline in revision 1527.
  • Revision ID: mordred@inaugust.com-20100422024623-4urw8fi8eraci08p
https://launchpad.net/bugs/561683
Don't overwrite the pandora_vc_revinfo file if we don't have new
authoratative information.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/logging_stats/stats_schema.cc
27
27
 * THE POSSIBILITY OF SUCH DAMAGE.
28
28
 */
29
29
 
30
 
/**
31
 
 * @details
32
 
 *
33
 
 * This class defines the following DATA_DICTIONARY tables:
34
 
 *
35
 
 * drizzle> describe GLOBAL_STATEMENTS;
36
 
 * +----------------+---------+-------+---------+-----------------+-----------+
37
 
 * | Field          | Type    | Null  | Default | Default_is_NULL | On_Update |
38
 
 * +----------------+---------+-------+---------+-----------------+-----------+
39
 
 * | VARIABLE_NAME  | VARCHAR | FALSE |         | FALSE           |           |
40
 
 * | VARIABLE_VALUE | BIGINT  | FALSE |         | FALSE           |           |
41
 
 * +----------------+---------+-------+---------+-----------------+-----------+
42
 
 *
43
 
 * drizzle> describe SESSION_STATEMENTS;
44
 
 * +----------------+---------+-------+---------+-----------------+-----------+
45
 
 * | Field          | Type    | Null  | Default | Default_is_NULL | On_Update |
46
 
 * +----------------+---------+-------+---------+-----------------+-----------+
47
 
 * | VARIABLE_NAME  | VARCHAR | FALSE |         | FALSE           |           |
48
 
 * | VARIABLE_VALUE | BIGINT  | FALSE |         | FALSE           |           |
49
 
 * +----------------+---------+-------+---------+-----------------+-----------+
50
 
 *
51
 
 * drizzle> describe CURRENT_SQL_COMMANDS;
52
 
 * +----------------+---------+-------+---------+-----------------+-----------+
53
 
 * | Field          | Type    | Null  | Default | Default_is_NULL | On_Update |
54
 
 * +----------------+---------+-------+---------+-----------------+-----------+
55
 
 * | USER           | VARCHAR | FALSE |         | FALSE           |           |
56
 
 * | IP             | VARCHAR | FALSE |         | FALSE           |           |
57
 
 * | COUNT_SELECT   | BIGINT  | FALSE |         | FALSE           |           |
58
 
 * | COUNT_DELETE   | BIGINT  | FALSE |         | FALSE           |           |
59
 
 * | COUNT_UPDATE   | BIGINT  | FALSE |         | FALSE           |           |
60
 
 * | COUNT_INSERT   | BIGINT  | FALSE |         | FALSE           |           |
61
 
 * | COUNT_ROLLBACK | BIGINT  | FALSE |         | FALSE           |           |
62
 
 * | COUNT_COMMIT   | BIGINT  | FALSE |         | FALSE           |           |
63
 
 * | COUNT_CREATE   | BIGINT  | FALSE |         | FALSE           |           |
64
 
 * | COUNT_ALTER    | BIGINT  | FALSE |         | FALSE           |           |
65
 
 * | COUNT_DROP     | BIGINT  | FALSE |         | FALSE           |           |
66
 
 * | COUNT_ADMIN    | BIGINT  | FALSE |         | FALSE           |           |
67
 
 * +----------------+---------+-------+---------+-----------------+-----------+
68
 
 *
69
 
 * drizzle> describe CUMULATIVE_SQL_COMMANDS;
70
 
 * +----------------+---------+-------+---------+-----------------+-----------+
71
 
 * | Field          | Type    | Null  | Default | Default_is_NULL | On_Update |
72
 
 * +----------------+---------+-------+---------+-----------------+-----------+
73
 
 * | USER           | VARCHAR | FALSE |         | FALSE           |           |
74
 
 * | COUNT_SELECT   | BIGINT  | FALSE |         | FALSE           |           |
75
 
 * | COUNT_DELETE   | BIGINT  | FALSE |         | FALSE           |           |
76
 
 * | COUNT_UPDATE   | BIGINT  | FALSE |         | FALSE           |           |
77
 
 * | COUNT_INSERT   | BIGINT  | FALSE |         | FALSE           |           |
78
 
 * | COUNT_ROLLBACK | BIGINT  | FALSE |         | FALSE           |           |
79
 
 * | COUNT_COMMIT   | BIGINT  | FALSE |         | FALSE           |           |
80
 
 * | COUNT_CREATE   | BIGINT  | FALSE |         | FALSE           |           |
81
 
 * | COUNT_ALTER    | BIGINT  | FALSE |         | FALSE           |           |
82
 
 * | COUNT_DROP     | BIGINT  | FALSE |         | FALSE           |           |
83
 
 * | COUNT_ADMIN    | BIGINT  | FALSE |         | FALSE           |           |
84
 
 * +----------------+---------+-------+---------+-----------------+-----------+
85
 
 *
86
 
 * drizzle> describe CUMULATIVE_USER_STATS;
87
 
 * +---------------------+---------+-------+---------+-----------------+-----------+
88
 
 * | Field               | Type    | Null  | Default | Default_is_NULL | On_Update |
89
 
 * +---------------------+---------+-------+---------+-----------------+-----------+
90
 
 * | USER                | VARCHAR | FALSE |         | FALSE           |           | 
91
 
 * | BYTES_RECEIVED      | VARCHAR | FALSE |         | FALSE           |           | 
92
 
 * | BYTES_SENT          | VARCHAR | FALSE |         | FALSE           |           | 
93
 
 * | DENIED_CONNECTIONS  | VARCHAR | FALSE |         | FALSE           |           | 
94
 
 * | LOST_CONNECTIONS    | VARCHAR | FALSE |         | FALSE           |           | 
95
 
 * | ACCESS_DENIED       | VARCHAR | FALSE |         | FALSE           |           | 
96
 
 * | CONNECTED_TIME_SEC  | VARCHAR | FALSE |         | FALSE           |           | 
97
 
 * | EXECUTION_TIME_NSEC | VARCHAR | FALSE |         | FALSE           |           | 
98
 
 * | ROWS_FETCHED        | VARCHAR | FALSE |         | FALSE           |           | 
99
 
 * | ROWS_UPDATED        | VARCHAR | FALSE |         | FALSE           |           | 
100
 
 * | ROWS_DELETED        | VARCHAR | FALSE |         | FALSE           |           | 
101
 
 * | ROWS_INSERTED       | VARCHAR | FALSE |         | FALSE           |           | 
102
 
 * +---------------------+---------+-------+---------+-----------------+-----------+
103
 
 *
104
 
 */
105
 
 
106
 
#include "config.h"
107
 
 
 
30
#include <config.h>          
108
31
#include "stats_schema.h"
109
32
 
110
 
#include <sstream>
111
 
 
112
33
using namespace drizzled;
113
34
using namespace plugin;
114
35
using namespace std;
115
36
 
116
 
SessionStatementsTool::SessionStatementsTool(LoggingStats *in_logging_stats) :
117
 
  plugin::TableFunction("DATA_DICTIONARY", "SESSION_STATEMENTS")
118
 
{
119
 
  logging_stats= in_logging_stats;
120
 
  add_field("VARIABLE_NAME");
121
 
  add_field("VARIABLE_VALUE", 1024);
122
 
}
123
 
 
124
 
SessionStatementsTool::Generator::Generator(Field **arg, LoggingStats *in_logging_stats) :
125
 
  plugin::TableFunction::Generator(arg)
126
 
{
127
 
  count= 0;
128
 
 
129
 
  /* Set user_commands */
130
 
  Scoreboard *current_scoreboard= in_logging_stats->getCurrentScoreboard();
131
 
 
132
 
  uint32_t bucket_number= current_scoreboard->getBucketNumber(&getSession());
133
 
 
134
 
  std::vector<ScoreboardSlot* > *scoreboard_vector=
135
 
     current_scoreboard->getVectorOfScoreboardVectors()->at(bucket_number);
136
 
 
137
 
  std::vector<ScoreboardSlot *>::iterator scoreboard_vector_it= scoreboard_vector->begin();
138
 
  std::vector<ScoreboardSlot *>::iterator scoreboard_vector_end= scoreboard_vector->end();
139
 
 
140
 
  ScoreboardSlot *scoreboard_slot= NULL;
141
 
  for (std::vector<ScoreboardSlot *>::iterator it= scoreboard_vector->begin();
142
 
       it != scoreboard_vector->end(); ++it)
143
 
  {
144
 
    scoreboard_slot= *it;
145
 
    if (scoreboard_slot->getSessionId() == getSession().getSessionId())
146
 
    {
147
 
      break;
148
 
    }
149
 
  }
150
 
 
151
 
  user_commands= NULL;
152
 
 
153
 
  if (scoreboard_slot != NULL)
154
 
  {
155
 
    user_commands= scoreboard_slot->getUserCommands();
156
 
  }
157
 
}
158
 
 
159
 
bool SessionStatementsTool::Generator::populate()
160
 
{
161
 
  if (user_commands == NULL)
162
 
  {
163
 
    return false;
164
 
  } 
165
 
 
166
 
  uint32_t number_identifiers= UserCommands::getStatusVarsCount();
167
 
 
168
 
  if (count == number_identifiers)
169
 
  {
170
 
    return false;
171
 
  }
172
 
 
173
 
  push(UserCommands::COM_STATUS_VARS[count]);
174
 
  ostringstream oss;
175
 
  oss << user_commands->getCount(count);
176
 
  push(oss.str()); 
177
 
 
178
 
  ++count;
179
 
  return true;
180
 
}
181
 
 
182
 
GlobalStatementsTool::GlobalStatementsTool(LoggingStats *in_logging_stats) :
183
 
  plugin::TableFunction("DATA_DICTIONARY", "GLOBAL_STATEMENTS")
184
 
{   
185
 
  logging_stats= in_logging_stats;
186
 
  add_field("VARIABLE_NAME");
187
 
  add_field("VARIABLE_VALUE", 1024);
188
 
}
189
 
 
190
 
GlobalStatementsTool::Generator::Generator(Field **arg, LoggingStats *in_logging_stats) :
191
 
  plugin::TableFunction::Generator(arg)
192
 
{
193
 
  count= 0;
194
 
  /* add the current scoreboard and the saved global statements */
195
 
  global_stats_to_display= new GlobalStats();
196
 
  CumulativeStats *cumulativeStats= in_logging_stats->getCumulativeStats();
197
 
  cumulativeStats->sumCurrentScoreboard(in_logging_stats->getCurrentScoreboard(), 
198
 
                                        NULL, global_stats_to_display->getUserCommands());
199
 
  global_stats_to_display->merge(in_logging_stats->getCumulativeStats()->getGlobalStats()); 
200
 
}
201
 
 
202
 
GlobalStatementsTool::Generator::~Generator()
203
 
{
204
 
  delete global_stats_to_display;
205
 
}
206
 
 
207
 
bool GlobalStatementsTool::Generator::populate()
208
 
{
209
 
  uint32_t number_identifiers= UserCommands::getStatusVarsCount(); 
210
 
  if (count == number_identifiers)
211
 
  {
212
 
    return false;
213
 
  }
214
 
 
215
 
  push(UserCommands::COM_STATUS_VARS[count]);
216
 
  ostringstream oss;
217
 
  oss << global_stats_to_display->getUserCommands()->getCount(count);
218
 
  push(oss.str());
219
 
 
220
 
  ++count;
221
 
  return true;
222
 
}
223
 
 
224
 
CurrentCommandsTool::CurrentCommandsTool(LoggingStats *logging_stats) :
 
37
CurrentCommandsTool::CurrentCommandsTool(LoggingStats *in_logging_stats) :
225
38
  plugin::TableFunction("DATA_DICTIONARY", "CURRENT_SQL_COMMANDS")
226
39
{
227
 
  outer_logging_stats= logging_stats;
 
40
  logging_stats= in_logging_stats;
228
41
 
229
42
  add_field("USER");
230
43
  add_field("IP");
231
 
 
232
 
  uint32_t number_commands= UserCommands::getUserCounts();
233
 
 
234
 
  for (uint32_t j= 0; j < number_commands; ++j)
235
 
  {
236
 
    add_field(UserCommands::USER_COUNTS[j], TableFunction::NUMBER);
237
 
  } 
 
44
  add_field("COUNT_SELECT", TableFunction::NUMBER);
 
45
  add_field("COUNT_DELETE", TableFunction::NUMBER);
 
46
  add_field("COUNT_UPDATE", TableFunction::NUMBER);
 
47
  add_field("COUNT_INSERT", TableFunction::NUMBER);
 
48
  add_field("COUNT_ROLLBACK", TableFunction::NUMBER);
 
49
  add_field("COUNT_COMMIT", TableFunction::NUMBER);
 
50
  add_field("COUNT_CREATE", TableFunction::NUMBER);
 
51
  add_field("COUNT_ALTER", TableFunction::NUMBER);
 
52
  add_field("COUNT_DROP", TableFunction::NUMBER);
 
53
  add_field("COUNT_ADMIN", TableFunction::NUMBER);
238
54
}
239
55
 
240
56
CurrentCommandsTool::Generator::Generator(Field **arg, LoggingStats *logging_stats) :
241
57
  plugin::TableFunction::Generator(arg)
242
58
{
243
 
  inner_logging_stats= logging_stats;
244
 
 
245
 
  isEnabled= inner_logging_stats->isEnabled();
 
59
  isEnabled= logging_stats->isEnabled();
246
60
 
247
61
  if (isEnabled == false)
248
62
  {
260
74
 
261
75
void CurrentCommandsTool::Generator::setVectorIteratorsAndLock(uint32_t bucket_number)
262
76
{
263
 
  std::vector<ScoreboardSlot* > *scoreboard_vector= 
 
77
  vector<ScoreboardSlot* > *scoreboard_vector= 
264
78
    current_scoreboard->getVectorOfScoreboardVectors()->at(bucket_number); 
265
79
 
266
80
  current_lock= current_scoreboard->getVectorOfScoreboardLocks()->at(bucket_number);
267
81
 
268
82
  scoreboard_vector_it= scoreboard_vector->begin();
269
83
  scoreboard_vector_end= scoreboard_vector->end();
270
 
  current_lock->lock_shared();
 
84
  pthread_rwlock_rdlock(current_lock);
271
85
}
272
86
 
273
87
bool CurrentCommandsTool::Generator::populate()
287
101
        UserCommands *user_commands= scoreboard_slot->getUserCommands();
288
102
        push(scoreboard_slot->getUser());
289
103
        push(scoreboard_slot->getIp());
290
 
 
291
 
        uint32_t number_commands= UserCommands::getUserCounts(); 
292
 
 
293
 
        for (uint32_t j= 0; j < number_commands; ++j)
294
 
        {
295
 
          push(user_commands->getUserCount(j));
296
 
        }
297
 
 
 
104
        push(user_commands->getSelectCount());
 
105
        push(user_commands->getDeleteCount());
 
106
        push(user_commands->getUpdateCount());
 
107
        push(user_commands->getInsertCount());
 
108
        push(user_commands->getRollbackCount());
 
109
        push(user_commands->getCommitCount());
 
110
        push(user_commands->getCreateCount());
 
111
        push(user_commands->getAlterCount());
 
112
        push(user_commands->getDropCount());
 
113
        push(user_commands->getAdminCount());
298
114
        ++scoreboard_vector_it;
299
115
        return true;
300
116
      }
302
118
    }
303
119
    
304
120
    ++vector_of_scoreboard_vectors_it;
305
 
    current_lock->unlock_shared();
 
121
    pthread_rwlock_unlock(current_lock); 
306
122
    ++current_bucket;
307
123
    if (vector_of_scoreboard_vectors_it != vector_of_scoreboard_vectors_end)
308
124
    {
319
135
  outer_logging_stats= logging_stats;
320
136
 
321
137
  add_field("USER");
322
 
 
323
 
  uint32_t number_commands= UserCommands::getUserCounts();
324
 
 
325
 
  for (uint32_t j= 0; j < number_commands; ++j)
326
 
  {
327
 
    add_field(UserCommands::USER_COUNTS[j], TableFunction::NUMBER);
328
 
  }
 
138
  add_field("COUNT_SELECT", TableFunction::NUMBER);
 
139
  add_field("COUNT_DELETE", TableFunction::NUMBER);
 
140
  add_field("COUNT_UPDATE", TableFunction::NUMBER);
 
141
  add_field("COUNT_INSERT", TableFunction::NUMBER);
 
142
  add_field("COUNT_ROLLBACK", TableFunction::NUMBER);
 
143
  add_field("COUNT_COMMIT", TableFunction::NUMBER);
 
144
  add_field("COUNT_CREATE", TableFunction::NUMBER);
 
145
  add_field("COUNT_ALTER", TableFunction::NUMBER);
 
146
  add_field("COUNT_DROP", TableFunction::NUMBER);
 
147
  add_field("COUNT_ADMIN", TableFunction::NUMBER);
329
148
}
330
149
 
331
 
CumulativeCommandsTool::Generator::Generator(Field **arg, LoggingStats *logging_stats) :
 
150
CumulativeCommandsTool::Generator::Generator(Field **arg, LoggingStats *in_logging_stats) :
332
151
  plugin::TableFunction::Generator(arg)
333
152
{
334
 
  inner_logging_stats= logging_stats;
 
153
  logging_stats= in_logging_stats;
335
154
  record_number= 0;
336
155
 
337
 
  if (inner_logging_stats->isEnabled())
 
156
  if (logging_stats->isEnabled())
338
157
  {
339
 
    last_valid_index= inner_logging_stats->getCumulativeStats()->getCumulativeStatsLastValidIndex();
 
158
    total_records= logging_stats->getCumulativeStatsByUserIndex();
340
159
  }
341
160
  else
342
161
  {
343
 
    last_valid_index= INVALID_INDEX; 
 
162
    total_records= 0; 
344
163
  }
345
164
}
346
165
 
347
166
bool CumulativeCommandsTool::Generator::populate()
348
167
{
349
 
  if ((record_number > last_valid_index) || (last_valid_index == INVALID_INDEX))
350
 
  {
351
 
    return false;
352
 
  }
353
 
 
354
 
  while (record_number <= last_valid_index)
355
 
  {
356
 
    ScoreboardSlot *cumulative_scoreboard_slot= 
357
 
      inner_logging_stats->getCumulativeStats()->getCumulativeStatsByUserVector()->at(record_number);
358
 
 
359
 
    if (cumulative_scoreboard_slot->isInUse())
360
 
    {
361
 
      UserCommands *user_commands= cumulative_scoreboard_slot->getUserCommands(); 
362
 
      push(cumulative_scoreboard_slot->getUser());
363
 
 
364
 
      uint32_t number_commands= UserCommands::getUserCounts();
365
 
 
366
 
      for (uint32_t j= 0; j < number_commands; ++j)
367
 
      {
368
 
        push(user_commands->getUserCount(j));
369
 
      }
370
 
      ++record_number;
371
 
      return true;
372
 
    } 
373
 
    else 
374
 
    {
375
 
      ++record_number;
376
 
    }
377
 
  }
378
 
 
379
 
  return false;
380
 
}
381
 
 
382
 
CumulativeUserStatsTool::CumulativeUserStatsTool(LoggingStats *logging_stats) :
383
 
  plugin::TableFunction("DATA_DICTIONARY", "CUMULATIVE_USER_STATS")
384
 
{
385
 
  outer_logging_stats= logging_stats;
386
 
 
387
 
  add_field("USER");
388
 
  add_field("BYTES_RECEIVED");
389
 
  add_field("BYTES_SENT");
390
 
  add_field("DENIED_CONNECTIONS");
391
 
  add_field("LOST_CONNECTIONS");
392
 
  add_field("ACCESS_DENIED");
393
 
  add_field("CONNECTED_TIME_SEC");
394
 
  add_field("EXECUTION_TIME_NSEC");
395
 
  add_field("ROWS_FETCHED");
396
 
  add_field("ROWS_UPDATED");
397
 
  add_field("ROWS_DELETED");
398
 
  add_field("ROWS_INSERTED");
399
 
}
400
 
 
401
 
CumulativeUserStatsTool::Generator::Generator(Field **arg, LoggingStats *logging_stats) :
402
 
  plugin::TableFunction::Generator(arg)
403
 
{
404
 
  inner_logging_stats= logging_stats;
405
 
  record_number= 0;
406
 
 
407
 
  if (inner_logging_stats->isEnabled())
408
 
  {
409
 
    last_valid_index= inner_logging_stats->getCumulativeStats()->getCumulativeStatsLastValidIndex();
410
 
  }
411
 
  else
412
 
  {
413
 
    last_valid_index= INVALID_INDEX;
414
 
  }
415
 
}
416
 
 
417
 
bool CumulativeUserStatsTool::Generator::populate()
418
 
{
419
 
  if ((record_number > last_valid_index) || (last_valid_index == INVALID_INDEX))
420
 
  {
421
 
    return false;
422
 
  }
423
 
 
424
 
  while (record_number <= last_valid_index)
425
 
  {
426
 
    ScoreboardSlot *cumulative_scoreboard_slot=
427
 
      inner_logging_stats->getCumulativeStats()->getCumulativeStatsByUserVector()->at(record_number);
428
 
 
429
 
    if (cumulative_scoreboard_slot->isInUse())
430
 
    {
431
 
      StatusVars *status_vars= cumulative_scoreboard_slot->getStatusVars();
432
 
      push(cumulative_scoreboard_slot->getUser());
433
 
 
434
 
      push(status_vars->getStatusVarCounters()->bytes_received);
435
 
      push(status_vars->getStatusVarCounters()->bytes_sent);
436
 
      push(status_vars->getStatusVarCounters()->aborted_connects);
437
 
      push(status_vars->getStatusVarCounters()->aborted_threads);
438
 
      push(status_vars->getStatusVarCounters()->access_denied);
439
 
      push(status_vars->getStatusVarCounters()->connection_time);
440
 
      push(status_vars->getStatusVarCounters()->execution_time_nsec);
441
 
      push(status_vars->sent_row_count);
442
 
      push(status_vars->getStatusVarCounters()->updated_row_count);
443
 
      push(status_vars->getStatusVarCounters()->deleted_row_count);
444
 
      push(status_vars->getStatusVarCounters()->inserted_row_count);
445
 
 
446
 
      ++record_number;
447
 
      return true;
448
 
    }
449
 
    else
450
 
    {
451
 
      ++record_number;
452
 
    }
453
 
  }
454
 
 
455
 
  return false;
456
 
}
457
 
 
458
 
ScoreboardStatsTool::ScoreboardStatsTool(LoggingStats *logging_stats) :
459
 
  plugin::TableFunction("DATA_DICTIONARY", "SCOREBOARD_STATISTICS")
460
 
{
461
 
  outer_logging_stats= logging_stats;
462
 
 
463
 
  add_field("SCOREBOARD_SIZE", TableFunction::NUMBER);
464
 
  add_field("NUMBER_OF_RANGE_LOCKS", TableFunction::NUMBER);
465
 
  add_field("MAX_USERS_LOGGED", TableFunction::NUMBER);
466
 
  add_field("MEMORY_USAGE_BYTES", TableFunction::NUMBER);
467
 
}
468
 
 
469
 
ScoreboardStatsTool::Generator::Generator(Field **arg, LoggingStats *logging_stats) :
470
 
  plugin::TableFunction::Generator(arg)
471
 
{
472
 
  inner_logging_stats= logging_stats;
473
 
  is_last_record= false; 
474
 
}
475
 
 
476
 
bool ScoreboardStatsTool::Generator::populate()
477
 
{
478
 
  if (is_last_record)
479
 
  {
480
 
    return false;
481
 
  }
482
 
 
483
 
  Scoreboard *scoreboard= inner_logging_stats->getCurrentScoreboard();
484
 
  CumulativeStats *cumulativeStats= inner_logging_stats->getCumulativeStats();
485
 
 
486
 
  push(static_cast<uint64_t>(scoreboard->getNumberPerBucket() * scoreboard->getNumberBuckets()));
487
 
  push(static_cast<uint64_t>(scoreboard->getNumberBuckets()));
488
 
  push(static_cast<uint64_t>(cumulativeStats->getCumulativeStatsByUserMax()));
489
 
  push(cumulativeStats->getCumulativeSizeBytes() + scoreboard->getScoreboardSizeBytes()); 
490
 
  
491
 
  is_last_record= true;
492
 
 
 
168
  if (record_number == total_records)
 
169
  {
 
170
    return false;
 
171
  }
 
172
 
 
173
  ScoreboardSlot *cumulative_scoreboard_slot= 
 
174
    logging_stats->getCumulativeStatsByUserVector()->at(record_number);
 
175
 
 
176
  push(cumulative_scoreboard_slot->getUser());
 
177
  push(cumulative_scoreboard_slot->getUserCommands()->getSelectCount());
 
178
  push(cumulative_scoreboard_slot->getUserCommands()->getDeleteCount());
 
179
  push(cumulative_scoreboard_slot->getUserCommands()->getUpdateCount());
 
180
  push(cumulative_scoreboard_slot->getUserCommands()->getInsertCount());
 
181
  push(cumulative_scoreboard_slot->getUserCommands()->getRollbackCount());
 
182
  push(cumulative_scoreboard_slot->getUserCommands()->getCommitCount());
 
183
  push(cumulative_scoreboard_slot->getUserCommands()->getCreateCount());
 
184
  push(cumulative_scoreboard_slot->getUserCommands()->getAlterCount());
 
185
  push(cumulative_scoreboard_slot->getUserCommands()->getDropCount());
 
186
  push(cumulative_scoreboard_slot->getUserCommands()->getAdminCount());
 
187
 
 
188
  ++record_number;
493
189
  return true;
494
190
}