← 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: 2008-10-23 00:05:28 UTC
  • Revision ID: monty@inaugust.com-20081023000528-grdvrd8c4058nutm
Moved my_handler to myisam, which is where it actually belongs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/logging_stats/stats_schema.cc
1
 
/*
2
 
 * Copyright (c) 2010, Joseph Daly <skinny.moey@gmail.com>
3
 
 * All rights reserved.
4
 
 *
5
 
 * Redistribution and use in source and binary forms, with or without
6
 
 * modification, are permitted provided that the following conditions are met:
7
 
 *
8
 
 *   * Redistributions of source code must retain the above copyright notice,
9
 
 *     this list of conditions and the following disclaimer.
10
 
 *   * Redistributions in binary form must reproduce the above copyright notice,
11
 
 *     this list of conditions and the following disclaimer in the documentation
12
 
 *     and/or other materials provided with the distribution.
13
 
 *   * Neither the name of Joseph Daly nor the names of its contributors
14
 
 *     may be used to endorse or promote products derived from this software
15
 
 *     without specific prior written permission.
16
 
 *
17
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18
 
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
21
 
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22
 
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23
 
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24
 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25
 
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26
 
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
27
 
 * THE POSSIBILITY OF SUCH DAMAGE.
28
 
 */
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
 
 
108
 
#include "stats_schema.h"
109
 
 
110
 
#include <sstream>
111
 
 
112
 
using namespace drizzled;
113
 
using namespace plugin;
114
 
using namespace std;
115
 
 
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 *logging_stats) :
125
 
  plugin::TableFunction::Generator(arg)
126
 
{
127
 
  count= 0;
128
 
 
129
 
  /* Set user_commands */
130
 
  Scoreboard *current_scoreboard= logging_stats->getCurrentScoreboard();
131
 
 
132
 
  uint32_t bucket_number= current_scoreboard->getBucketNumber(&getSession());
133
 
 
134
 
  vector<ScoreboardSlot* > *scoreboard_vector=
135
 
     current_scoreboard->getVectorOfScoreboardVectors()->at(bucket_number);
136
 
 
137
 
  vector<ScoreboardSlot *>::iterator scoreboard_vector_it= scoreboard_vector->begin();
138
 
  vector<ScoreboardSlot *>::iterator scoreboard_vector_end= scoreboard_vector->end();
139
 
 
140
 
  ScoreboardSlot *scoreboard_slot= NULL;
141
 
  for (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 *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= logging_stats->getCumulativeStats();
197
 
  cumulativeStats->sumCurrentScoreboard(logging_stats->getCurrentScoreboard(), 
198
 
                                        NULL, global_stats_to_display->getUserCommands());
199
 
  global_stats_to_display->merge(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("USER");
230
 
  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
 
  } 
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
 
  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("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
 
  }
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("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
 
 
493
 
  return true;
494
 
}