← 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: Olaf van der Spek
  • Date: 2011-02-12 18:24:24 UTC
  • mto: (2167.1.2 build) (2172.1.4 build)
  • mto: This revision was merged to the branch mainline in revision 2168.
  • Revision ID: olafvdspek@gmail.com-20110212182424-kgnm9osi7qo97at2
casts

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/logging_stats/stats_schema.cc
1
1
/*
2
 
 * Copyright (c) 2010, Joseph Daly <skinny.moey@gmail.com>
 
2
 * Copyright (C) 2010 Joseph Daly <skinny.moey@gmail.com>
3
3
 * All rights reserved.
4
4
 *
5
5
 * Redistribution and use in source and binary forms, with or without
27
27
 * THE POSSIBILITY OF SUCH DAMAGE.
28
28
 */
29
29
 
30
 
#include <config.h>          
 
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
 * | USERNAME       | 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
 * | USERNAME       | 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
 * | USERNAME            | 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
 
31
108
#include "stats_schema.h"
32
109
 
 
110
#include <sstream>
 
111
 
33
112
using namespace drizzled;
34
113
using namespace plugin;
35
114
using namespace std;
36
115
 
37
 
CommandsTool::CommandsTool(LoggingStats *logging_stats) :
38
 
  plugin::TableFunction("DATA_DICTIONARY", "SQL_COMMANDS_BY_USER")
39
 
{
40
 
  outer_logging_stats= logging_stats;  
41
 
 
42
 
  add_field("USER");
 
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) :
 
225
  plugin::TableFunction("DATA_DICTIONARY", "CURRENT_SQL_COMMANDS")
 
226
{
 
227
  outer_logging_stats= logging_stats;
 
228
 
 
229
  add_field("USERNAME");
43
230
  add_field("IP");
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);
54
 
}
55
 
 
56
 
CommandsTool::Generator::Generator(Field **arg, LoggingStats *in_logging_stats) :
57
 
  plugin::TableFunction::Generator(arg)
58
 
{
59
 
  pthread_rwlock_rdlock(&LOCK_scoreboard);
60
 
  logging_stats= in_logging_stats;
61
 
 
62
 
  if (logging_stats->isEnabled())
 
231
 
 
232
  uint32_t number_commands= UserCommands::getUserCounts();
 
233
 
 
234
  for (uint32_t j= 0; j < number_commands; ++j)
63
235
  {
64
 
    record_number= 0;
 
236
    add_field(UserCommands::USER_COUNTS[j], TableFunction::NUMBER);
65
237
  } 
66
 
  else 
67
 
  {
68
 
    record_number= logging_stats->getScoreBoardSize(); 
69
 
  }
70
 
}
71
 
 
72
 
CommandsTool::Generator::~Generator()
73
 
{
74
 
  pthread_rwlock_unlock(&LOCK_scoreboard);
75
 
}
76
 
 
77
 
bool CommandsTool::Generator::populate()
78
 
{
79
 
  if (record_number == logging_stats->getScoreBoardSize())
80
 
  {
81
 
    return false;
82
 
  }
 
238
}
 
239
 
 
240
CurrentCommandsTool::Generator::Generator(Field **arg, LoggingStats *logging_stats) :
 
241
  plugin::TableFunction::Generator(arg)
 
242
{
 
243
  inner_logging_stats= logging_stats;
 
244
 
 
245
  isEnabled= inner_logging_stats->isEnabled();
 
246
 
 
247
  if (isEnabled == false)
 
248
  {
 
249
    return;
 
250
  }
 
251
 
 
252
  current_scoreboard= logging_stats->getCurrentScoreboard();
 
253
  current_bucket= 0;
 
254
 
 
255
  vector_of_scoreboard_vectors_it= current_scoreboard->getVectorOfScoreboardVectors()->begin();
 
256
  vector_of_scoreboard_vectors_end= current_scoreboard->getVectorOfScoreboardVectors()->end();
 
257
 
 
258
  setVectorIteratorsAndLock(current_bucket);
 
259
}
 
260
 
 
261
void CurrentCommandsTool::Generator::setVectorIteratorsAndLock(uint32_t bucket_number)
 
262
{
 
263
  std::vector<ScoreboardSlot* > *scoreboard_vector= 
 
264
    current_scoreboard->getVectorOfScoreboardVectors()->at(bucket_number); 
 
265
 
 
266
  current_lock= current_scoreboard->getVectorOfScoreboardLocks()->at(bucket_number);
 
267
 
 
268
  scoreboard_vector_it= scoreboard_vector->begin();
 
269
  scoreboard_vector_end= scoreboard_vector->end();
 
270
  current_lock->lock_shared();
 
271
}
 
272
 
 
273
bool CurrentCommandsTool::Generator::populate()
 
274
{
 
275
  if (isEnabled == false)
 
276
  {
 
277
    return false;
 
278
  }
 
279
 
 
280
  while (vector_of_scoreboard_vectors_it != vector_of_scoreboard_vectors_end)
 
281
  {
 
282
    while (scoreboard_vector_it != scoreboard_vector_end)
 
283
    {
 
284
      ScoreboardSlot *scoreboard_slot= *scoreboard_vector_it; 
 
285
      if (scoreboard_slot->isInUse())
 
286
      {
 
287
        UserCommands *user_commands= scoreboard_slot->getUserCommands();
 
288
        push(scoreboard_slot->getUser());
 
289
        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
 
 
298
        ++scoreboard_vector_it;
 
299
        return true;
 
300
      }
 
301
      ++scoreboard_vector_it;
 
302
    }
 
303
    
 
304
    ++vector_of_scoreboard_vectors_it;
 
305
    current_lock->unlock_shared();
 
306
    ++current_bucket;
 
307
    if (vector_of_scoreboard_vectors_it != vector_of_scoreboard_vectors_end)
 
308
    {
 
309
      setVectorIteratorsAndLock(current_bucket); 
 
310
    } 
 
311
  }
 
312
 
 
313
  return false;
 
314
}
 
315
 
 
316
CumulativeCommandsTool::CumulativeCommandsTool(LoggingStats *logging_stats) :
 
317
  plugin::TableFunction("DATA_DICTIONARY", "CUMULATIVE_SQL_COMMANDS")
 
318
{
 
319
  outer_logging_stats= logging_stats;
 
320
 
 
321
  add_field("USERNAME");
 
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
  }
 
329
}
 
330
 
 
331
CumulativeCommandsTool::Generator::Generator(Field **arg, LoggingStats *logging_stats) :
 
332
  plugin::TableFunction::Generator(arg)
 
333
{
 
334
  inner_logging_stats= logging_stats;
 
335
  record_number= 0;
 
336
 
 
337
  if (inner_logging_stats->isEnabled())
 
338
  {
 
339
    last_valid_index= inner_logging_stats->getCumulativeStats()->getCumulativeStatsLastValidIndex();
 
340
  }
 
341
  else
 
342
  {
 
343
    last_valid_index= INVALID_INDEX; 
 
344
  }
 
345
}
 
346
 
 
347
bool CumulativeCommandsTool::Generator::populate()
 
348
{
 
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("USERNAME");
 
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()); 
83
490
  
84
 
  ScoreBoardSlot *score_board_slots= logging_stats->getScoreBoardSlots();
85
 
 
86
 
  while (record_number < logging_stats->getScoreBoardSize())
87
 
  {
88
 
    ScoreBoardSlot *score_board_slot= &score_board_slots[record_number];
89
 
    if (score_board_slot->isInUse())
90
 
    {
91
 
      UserCommands *user_commands= score_board_slot->getUserCommands();
92
 
      push(score_board_slot->getUser());
93
 
      push(score_board_slot->getIp());
94
 
      push(user_commands->getSelectCount());
95
 
      push(user_commands->getDeleteCount());
96
 
      push(user_commands->getUpdateCount());
97
 
      push(user_commands->getInsertCount());
98
 
      push(user_commands->getRollbackCount());
99
 
      push(user_commands->getCommitCount());
100
 
      push(user_commands->getCreateCount());
101
 
      push(user_commands->getAlterCount());
102
 
      push(user_commands->getDropCount());
103
 
      push(user_commands->getAdminCount());
104
 
      record_number++;
105
 
      return true;
106
 
    }
107
 
    else 
108
 
    {
109
 
      record_number++;
110
 
    }
111
 
  }
112
 
 
113
 
  return false;
 
491
  is_last_record= true;
 
492
 
 
493
  return true;
114
494
}