← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/logging_stats/stats_schema.cc

Merge Joe, plus I updated the tests.

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
52
52
 * +----------------+---------+-------+---------+-----------------+-----------+
53
53
 * | Field          | Type    | Null  | Default | Default_is_NULL | On_Update |
54
54
 * +----------------+---------+-------+---------+-----------------+-----------+
55
 
 * | USERNAME       | VARCHAR | FALSE |         | FALSE           |           |
 
55
 * | USER           | VARCHAR | FALSE |         | FALSE           |           |
56
56
 * | IP             | VARCHAR | FALSE |         | FALSE           |           |
57
57
 * | COUNT_SELECT   | BIGINT  | FALSE |         | FALSE           |           |
58
58
 * | COUNT_DELETE   | BIGINT  | FALSE |         | FALSE           |           |
70
70
 * +----------------+---------+-------+---------+-----------------+-----------+
71
71
 * | Field          | Type    | Null  | Default | Default_is_NULL | On_Update |
72
72
 * +----------------+---------+-------+---------+-----------------+-----------+
73
 
 * | USERNAME       | VARCHAR | FALSE |         | FALSE           |           |
 
73
 * | USER           | VARCHAR | FALSE |         | FALSE           |           |
74
74
 * | COUNT_SELECT   | BIGINT  | FALSE |         | FALSE           |           |
75
75
 * | COUNT_DELETE   | BIGINT  | FALSE |         | FALSE           |           |
76
76
 * | COUNT_UPDATE   | BIGINT  | FALSE |         | FALSE           |           |
87
87
 * +---------------------+---------+-------+---------+-----------------+-----------+
88
88
 * | Field               | Type    | Null  | Default | Default_is_NULL | On_Update |
89
89
 * +---------------------+---------+-------+---------+-----------------+-----------+
90
 
 * | USERNAME            | VARCHAR | FALSE |         | FALSE           |           | 
 
90
 * | USER                | VARCHAR | FALSE |         | FALSE           |           | 
91
91
 * | BYTES_RECEIVED      | VARCHAR | FALSE |         | FALSE           |           | 
92
92
 * | BYTES_SENT          | VARCHAR | FALSE |         | FALSE           |           | 
93
93
 * | DENIED_CONNECTIONS  | VARCHAR | FALSE |         | FALSE           |           | 
103
103
 *
104
104
 */
105
105
 
106
 
#include "config.h"
 
106
#include <config.h>
107
107
 
108
108
#include "stats_schema.h"
109
109
 
121
121
  add_field("VARIABLE_VALUE", 1024);
122
122
}
123
123
 
124
 
SessionStatementsTool::Generator::Generator(Field **arg, LoggingStats *in_logging_stats) :
 
124
SessionStatementsTool::Generator::Generator(Field **arg, LoggingStats *logging_stats) :
125
125
  plugin::TableFunction::Generator(arg)
126
126
{
127
127
  count= 0;
128
128
 
129
129
  /* Set user_commands */
130
 
  Scoreboard *current_scoreboard= in_logging_stats->getCurrentScoreboard();
 
130
  Scoreboard *current_scoreboard= logging_stats->getCurrentScoreboard();
131
131
 
132
132
  uint32_t bucket_number= current_scoreboard->getBucketNumber(&getSession());
133
133
 
134
 
  std::vector<ScoreboardSlot* > *scoreboard_vector=
 
134
  vector<ScoreboardSlot* > *scoreboard_vector=
135
135
     current_scoreboard->getVectorOfScoreboardVectors()->at(bucket_number);
136
136
 
137
 
  std::vector<ScoreboardSlot *>::iterator scoreboard_vector_it= scoreboard_vector->begin();
138
 
  std::vector<ScoreboardSlot *>::iterator scoreboard_vector_end= scoreboard_vector->end();
 
137
  vector<ScoreboardSlot *>::iterator scoreboard_vector_it= scoreboard_vector->begin();
 
138
  vector<ScoreboardSlot *>::iterator scoreboard_vector_end= scoreboard_vector->end();
139
139
 
140
140
  ScoreboardSlot *scoreboard_slot= NULL;
141
 
  for (std::vector<ScoreboardSlot *>::iterator it= scoreboard_vector->begin();
 
141
  for (vector<ScoreboardSlot *>::iterator it= scoreboard_vector->begin();
142
142
       it != scoreboard_vector->end(); ++it)
143
143
  {
144
144
    scoreboard_slot= *it;
187
187
  add_field("VARIABLE_VALUE", 1024);
188
188
}
189
189
 
190
 
GlobalStatementsTool::Generator::Generator(Field **arg, LoggingStats *in_logging_stats) :
 
190
GlobalStatementsTool::Generator::Generator(Field **arg, LoggingStats *logging_stats) :
191
191
  plugin::TableFunction::Generator(arg)
192
192
{
193
193
  count= 0;
194
194
  /* add the current scoreboard and the saved global statements */
195
195
  global_stats_to_display= new GlobalStats();
196
 
  CumulativeStats *cumulativeStats= in_logging_stats->getCumulativeStats();
197
 
  cumulativeStats->sumCurrentScoreboard(in_logging_stats->getCurrentScoreboard(), 
 
196
  CumulativeStats *cumulativeStats= logging_stats->getCumulativeStats();
 
197
  cumulativeStats->sumCurrentScoreboard(logging_stats->getCurrentScoreboard(), 
198
198
                                        NULL, global_stats_to_display->getUserCommands());
199
 
  global_stats_to_display->merge(in_logging_stats->getCumulativeStats()->getGlobalStats()); 
 
199
  global_stats_to_display->merge(logging_stats->getCumulativeStats()->getGlobalStats()); 
200
200
}
201
201
 
202
202
GlobalStatementsTool::Generator::~Generator()
226
226
{
227
227
  outer_logging_stats= logging_stats;
228
228
 
229
 
  add_field("USERNAME");
 
229
  add_field("USER");
230
230
  add_field("IP");
231
231
 
232
232
  uint32_t number_commands= UserCommands::getUserCounts();
260
260
 
261
261
void CurrentCommandsTool::Generator::setVectorIteratorsAndLock(uint32_t bucket_number)
262
262
{
263
 
  std::vector<ScoreboardSlot* > *scoreboard_vector= 
 
263
  vector<ScoreboardSlot* > *scoreboard_vector= 
264
264
    current_scoreboard->getVectorOfScoreboardVectors()->at(bucket_number); 
265
265
 
266
266
  current_lock= current_scoreboard->getVectorOfScoreboardLocks()->at(bucket_number);
267
267
 
268
268
  scoreboard_vector_it= scoreboard_vector->begin();
269
269
  scoreboard_vector_end= scoreboard_vector->end();
270
 
  current_lock->lock_shared();
 
270
  pthread_rwlock_rdlock(current_lock);
271
271
}
272
272
 
273
273
bool CurrentCommandsTool::Generator::populate()
302
302
    }
303
303
    
304
304
    ++vector_of_scoreboard_vectors_it;
305
 
    current_lock->unlock_shared();
 
305
    pthread_rwlock_unlock(current_lock); 
306
306
    ++current_bucket;
307
307
    if (vector_of_scoreboard_vectors_it != vector_of_scoreboard_vectors_end)
308
308
    {
318
318
{
319
319
  outer_logging_stats= logging_stats;
320
320
 
321
 
  add_field("USERNAME");
 
321
  add_field("USER");
322
322
 
323
323
  uint32_t number_commands= UserCommands::getUserCounts();
324
324
 
384
384
{
385
385
  outer_logging_stats= logging_stats;
386
386
 
387
 
  add_field("USERNAME");
 
387
  add_field("USER");
388
388
  add_field("BYTES_RECEIVED");
389
389
  add_field("BYTES_SENT");
390
390
  add_field("DENIED_CONNECTIONS");
454
454
 
455
455
  return false;
456
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
 
}