← 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: Jay Pipes
  • Date: 2010-04-08 16:27:25 UTC
  • mfrom: (1405.6.10 replication-pairs)
  • mto: This revision was merged to the branch mainline in revision 1457.
  • Revision ID: jpipes@serialcoder-20100408162725-sugbgn38oxjqclq2
Merge trunk and replication-pairs with conflict resolution

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/logging_stats/stats_schema.cc
34
34
using namespace plugin;
35
35
using namespace std;
36
36
 
37
 
CommandsTool::CommandsTool(LoggingStats *logging_stats) :
38
 
  plugin::TableFunction("DATA_DICTIONARY", "SQL_COMMANDS_BY_USER")
 
37
CurrentCommandsTool::CurrentCommandsTool(LoggingStats *in_logging_stats) :
 
38
  plugin::TableFunction("DATA_DICTIONARY", "CURRENT_SQL_COMMANDS")
39
39
{
40
 
  outer_logging_stats= logging_stats;  
 
40
  logging_stats= in_logging_stats;
41
41
 
42
42
  add_field("USER");
43
43
  add_field("IP");
53
53
  add_field("COUNT_ADMIN", TableFunction::NUMBER);
54
54
}
55
55
 
56
 
CommandsTool::Generator::Generator(Field **arg, LoggingStats *in_logging_stats) :
57
 
  plugin::TableFunction::Generator(arg)
58
 
{
59
 
  pthread_rwlock_rdlock(&LOCK_scoreboard);
 
56
CurrentCommandsTool::Generator::Generator(Field **arg, LoggingStats *logging_stats) :
 
57
  plugin::TableFunction::Generator(arg)
 
58
{
 
59
  isEnabled= logging_stats->isEnabled();
 
60
 
 
61
  if (isEnabled == false)
 
62
  {
 
63
    return;
 
64
  }
 
65
 
 
66
  current_scoreboard= logging_stats->getCurrentScoreboard();
 
67
  current_bucket= 0;
 
68
 
 
69
  vector_of_scoreboard_vectors_it= current_scoreboard->getVectorOfScoreboardVectors()->begin();
 
70
  vector_of_scoreboard_vectors_end= current_scoreboard->getVectorOfScoreboardVectors()->end();
 
71
 
 
72
  setVectorIteratorsAndLock(current_bucket);
 
73
}
 
74
 
 
75
void CurrentCommandsTool::Generator::setVectorIteratorsAndLock(uint32_t bucket_number)
 
76
{
 
77
  vector<ScoreboardSlot* > *scoreboard_vector= 
 
78
    current_scoreboard->getVectorOfScoreboardVectors()->at(bucket_number); 
 
79
 
 
80
  current_lock= current_scoreboard->getVectorOfScoreboardLocks()->at(bucket_number);
 
81
 
 
82
  scoreboard_vector_it= scoreboard_vector->begin();
 
83
  scoreboard_vector_end= scoreboard_vector->end();
 
84
  pthread_rwlock_rdlock(current_lock);
 
85
}
 
86
 
 
87
bool CurrentCommandsTool::Generator::populate()
 
88
{
 
89
  if (isEnabled == false)
 
90
  {
 
91
    return false;
 
92
  }
 
93
 
 
94
  while (vector_of_scoreboard_vectors_it != vector_of_scoreboard_vectors_end)
 
95
  {
 
96
    while (scoreboard_vector_it != scoreboard_vector_end)
 
97
    {
 
98
      ScoreboardSlot *scoreboard_slot= *scoreboard_vector_it; 
 
99
      if (scoreboard_slot->isInUse())
 
100
      {
 
101
        UserCommands *user_commands= scoreboard_slot->getUserCommands();
 
102
        push(scoreboard_slot->getUser());
 
103
        push(scoreboard_slot->getIp());
 
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());
 
114
        ++scoreboard_vector_it;
 
115
        return true;
 
116
      }
 
117
      ++scoreboard_vector_it;
 
118
    }
 
119
    
 
120
    ++vector_of_scoreboard_vectors_it;
 
121
    pthread_rwlock_unlock(current_lock); 
 
122
    ++current_bucket;
 
123
    if (vector_of_scoreboard_vectors_it != vector_of_scoreboard_vectors_end)
 
124
    {
 
125
      setVectorIteratorsAndLock(current_bucket); 
 
126
    } 
 
127
  }
 
128
 
 
129
  return false;
 
130
}
 
131
 
 
132
CumulativeCommandsTool::CumulativeCommandsTool(LoggingStats *logging_stats) :
 
133
  plugin::TableFunction("DATA_DICTIONARY", "CUMULATIVE_SQL_COMMANDS")
 
134
{
 
135
  outer_logging_stats= logging_stats;
 
136
 
 
137
  add_field("USER");
 
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);
 
148
}
 
149
 
 
150
CumulativeCommandsTool::Generator::Generator(Field **arg, LoggingStats *in_logging_stats) :
 
151
  plugin::TableFunction::Generator(arg)
 
152
{
60
153
  logging_stats= in_logging_stats;
 
154
  record_number= 0;
61
155
 
62
156
  if (logging_stats->isEnabled())
63
157
  {
64
 
    record_number= 0;
65
 
  } 
66
 
  else 
 
158
    total_records= logging_stats->getCumulativeStatsByUserIndex();
 
159
  }
 
160
  else
67
161
  {
68
 
    record_number= logging_stats->getScoreBoardSize(); 
 
162
    total_records= 0; 
69
163
  }
70
164
}
71
165
 
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())
 
166
bool CumulativeCommandsTool::Generator::populate()
 
167
{
 
168
  if (record_number == total_records)
80
169
  {
81
170
    return false;
82
171
  }
83
 
  
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;
 
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;
 
189
  return true;
114
190
}