← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/info_schema/info_schema_plugin.cc

  • Committer: Padraig O'Sullivan
  • Date: 2009-06-20 03:05:30 UTC
  • mto: (1076.2.5 info-schema-plugin)
  • mto: This revision was merged to the branch mainline in revision 1073.
  • Revision ID: osullivan.padraig@gmail.com-20090620030530-d3tdkf9pbaoiv4i6
Created an I_S plugin. Extracted the PROCESSLIST table into this plugin and
removed any trace of it from show.cc

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/info_schema/info_schema_plugin.cc
 
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2009 Sun Microsystems
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; either version 2 of the License, or
 
9
 *  (at your option) any later version.
 
10
 *
 
11
 *  This program is distributed in the hope that it will be useful,
 
12
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 *  GNU General Public License for more details.
 
15
 *
 
16
 *  You should have received a copy of the GNU General Public License
 
17
 *  along with this program; if not, write to the Free Software
 
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
19
 */
 
20
 
 
21
/**
 
22
 * @file Implementation of the I_S tables.
 
23
 */
 
24
 
 
25
#include <drizzled/server_includes.h>
 
26
#include <drizzled/session.h>
 
27
#include <drizzled/show.h>
 
28
 
 
29
#include "info_schema_plugin.h"
 
30
 
 
31
#define LIST_PROCESS_HOST_LEN 64
 
32
 
 
33
using namespace std;
 
34
 
 
35
int ProcessListISMethods::fillTable(Session* session, TableList* tables, COND*)
 
36
{
 
37
  Table *table= tables->table;
 
38
  const CHARSET_INFO * const cs= system_charset_info;
 
39
  time_t now= time(NULL);
 
40
  size_t length;
 
41
 
 
42
  if (now == (time_t)-1)
 
43
    return 1;
 
44
 
 
45
  pthread_mutex_lock(&LOCK_thread_count);
 
46
 
 
47
  if (!session->killed)
 
48
  {
 
49
    Session* tmp;
 
50
 
 
51
    for (vector<Session*>::iterator it= session_list.begin(); it != session_list.end(); ++it)
 
52
    {
 
53
      tmp= *it;
 
54
      Security_context *tmp_sctx= &tmp->security_ctx;
 
55
      struct st_my_thread_var *mysys_var;
 
56
      const char *val;
 
57
 
 
58
      if (! tmp->protocol->isConnected())
 
59
        continue;
 
60
 
 
61
      table->restoreRecordAsDefault();
 
62
      /* ID */
 
63
      table->field[0]->store((int64_t) tmp->thread_id, true);
 
64
      /* USER */
 
65
      val= tmp_sctx->user.c_str() ? tmp_sctx->user.c_str() : "unauthenticated user";
 
66
      table->field[1]->store(val, strlen(val), cs);
 
67
      /* HOST */
 
68
      table->field[2]->store(tmp_sctx->ip.c_str(), strlen(tmp_sctx->ip.c_str()), cs);
 
69
      /* DB */
 
70
      if (tmp->db)
 
71
      {
 
72
        table->field[3]->store(tmp->db, strlen(tmp->db), cs);
 
73
        table->field[3]->set_notnull();
 
74
      }
 
75
 
 
76
      if ((mysys_var= tmp->mysys_var))
 
77
        pthread_mutex_lock(&mysys_var->mutex);
 
78
      /* COMMAND */
 
79
      if ((val= (char *) (tmp->killed == Session::KILL_CONNECTION? "Killed" : 0)))
 
80
        table->field[4]->store(val, strlen(val), cs);
 
81
      else
 
82
        table->field[4]->store(command_name[tmp->command].str,
 
83
                               command_name[tmp->command].length, cs);
 
84
      /* DRIZZLE_TIME */
 
85
      table->field[5]->store((uint32_t)(tmp->start_time ?
 
86
                                      now - tmp->start_time : 0), true);
 
87
      /* STATE */
 
88
      val= (char*) (tmp->protocol->isWriting() ?
 
89
                    "Writing to net" :
 
90
                    tmp->protocol->isReading() ?
 
91
                    (tmp->command == COM_SLEEP ?
 
92
                     NULL : "Reading from net") :
 
93
                    tmp->get_proc_info() ? tmp->get_proc_info() :
 
94
                    tmp->mysys_var &&
 
95
                    tmp->mysys_var->current_cond ?
 
96
                    "Waiting on cond" : NULL);
 
97
      if (val)
 
98
      {
 
99
        table->field[6]->store(val, strlen(val), cs);
 
100
        table->field[6]->set_notnull();
 
101
      }
 
102
 
 
103
      if (mysys_var)
 
104
        pthread_mutex_unlock(&mysys_var->mutex);
 
105
 
 
106
      length= strlen(tmp->process_list_info);
 
107
 
 
108
      if (length)
 
109
      {
 
110
        table->field[7]->store(tmp->process_list_info, length, cs);
 
111
        table->field[7]->set_notnull();
 
112
      }
 
113
 
 
114
      if (schema_table_store_record(session, table))
 
115
      {
 
116
        pthread_mutex_unlock(&LOCK_thread_count);
 
117
        return(1);
 
118
      }
 
119
    }
 
120
  }
 
121
 
 
122
  pthread_mutex_unlock(&LOCK_thread_count);
 
123
  return(0);
 
124
}
 
125
 
 
126
/*
 
127
 * The various fields for the PROCESSLIST I_S table.
 
128
 */
 
129
static FieldInfo processlist_fields_info[]=
 
130
{
 
131
  FieldInfo("ID", 4, DRIZZLE_TYPE_LONGLONG, 
 
132
            0, 0, "Id", SKIP_OPEN_TABLE),
 
133
  FieldInfo("USER", 16, DRIZZLE_TYPE_VARCHAR, 
 
134
            0, 0, "User", SKIP_OPEN_TABLE),
 
135
  FieldInfo("HOST", LIST_PROCESS_HOST_LEN,  DRIZZLE_TYPE_VARCHAR, 
 
136
            0, 0, "Host", SKIP_OPEN_TABLE),
 
137
  FieldInfo("DB", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 
 
138
            0, 1, "Db", SKIP_OPEN_TABLE),
 
139
  FieldInfo("COMMAND", 16, DRIZZLE_TYPE_VARCHAR, 
 
140
            0, 0, "Command", SKIP_OPEN_TABLE),
 
141
  FieldInfo("TIME", 7, DRIZZLE_TYPE_LONGLONG, 
 
142
            0, 0, "Time", SKIP_OPEN_TABLE),
 
143
  FieldInfo("STATE", 64, DRIZZLE_TYPE_VARCHAR, 
 
144
            0, 1, "State", SKIP_OPEN_TABLE),
 
145
  FieldInfo("INFO", PROCESS_LIST_INFO_WIDTH, DRIZZLE_TYPE_VARCHAR, 
 
146
            0, 1, "Info", SKIP_OPEN_TABLE),
 
147
  FieldInfo()
 
148
};
 
149
 
 
150
/*
 
151
 * List of methods for various I_S tables.
 
152
 */
 
153
static InfoSchemaMethods *processlist_methods= NULL;
 
154
 
 
155
/*
 
156
 * List of I_S tables.
 
157
 */
 
158
static InfoSchemaTable *processlist_table= NULL;
 
159
 
 
160
/**
 
161
 * Initialize the methods for each I_S table.
 
162
 *
 
163
 * @return false on success; true on failure
 
164
 */
 
165
bool initTableMethods()
 
166
{
 
167
  processlist_methods= new ProcessListISMethods();
 
168
 
 
169
  return false;
 
170
}
 
171
 
 
172
/**
 
173
 * Delete memory allocated for the I_S table methods.
 
174
 */
 
175
void cleanupTableMethods()
 
176
{
 
177
  delete processlist_methods;
 
178
}
 
179
 
 
180
/**
 
181
 * Initialize the I_S tables.
 
182
 *
 
183
 * @return false on success; true on failure
 
184
 */
 
185
bool initTables()
 
186
{
 
187
 
 
188
  processlist_table= new InfoSchemaTable("PROCESSLIST",
 
189
                                         processlist_fields_info,
 
190
                                         -1, -1, false, false, 0,
 
191
                                         processlist_methods);
 
192
 
 
193
  return false;
 
194
}
 
195
 
 
196
/**
 
197
 * Delete memory allocated for the I_S tables.
 
198
 */
 
199
void cleanupTables()
 
200
{
 
201
  delete processlist_table;
 
202
}
 
203
 
 
204
/**
 
205
 * Initialize the I_S plugin.
 
206
 *
 
207
 * @param[in] registry the PluginRegistry singleton
 
208
 * @return 0 on success; 1 on failure.
 
209
 */
 
210
int infoSchemaInit(PluginRegistry& registry)
 
211
{
 
212
  if (initTableMethods())
 
213
  {
 
214
    return 1;
 
215
  }
 
216
 
 
217
  if (initTables())
 
218
  {
 
219
    return 1;
 
220
  }
 
221
 
 
222
  registry.add(processlist_table);
 
223
 
 
224
  return 0;
 
225
}
 
226
 
 
227
/**
 
228
 * Clean up the I_S plugin.
 
229
 *
 
230
 * @param[in] registry the PluginRegistry singleton
 
231
 * @return 0 on success; 1 on failure
 
232
 */
 
233
int infoSchemaDone(PluginRegistry& registry)
 
234
{
 
235
  registry.remove(processlist_table);
 
236
 
 
237
  cleanupTableMethods();
 
238
  cleanupTables();
 
239
 
 
240
  return 0;
 
241
}
 
242
 
 
243
drizzle_declare_plugin(info_schema)
 
244
{
 
245
  "info_schema",
 
246
  "0.1",
 
247
  "Padraig O'Sullivan",
 
248
  "I_S plugin",
 
249
  PLUGIN_LICENSE_GPL,
 
250
  infoSchemaInit,
 
251
  infoSchemaDone,
 
252
  NULL,
 
253
  NULL,
 
254
  NULL
 
255
}
 
256
drizzle_declare_plugin_end;