← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/info_schema/status.cc

  • Committer: Brian Aker
  • Date: 2009-11-18 23:28:30 UTC
  • mfrom: (1215.2.25 is-split)
  • Revision ID: brian@gaz-20091118232830-v28y7o26squz3c9c
Merge of Padraig

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/info_schema/status.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 
 
23
 *   status I_S table methods.
 
24
 */
 
25
 
 
26
#include "drizzled/server_includes.h"
 
27
#include "drizzled/session.h"
 
28
#include "drizzled/show.h"
 
29
#include "drizzled/tztime.h"
 
30
 
 
31
#include "helper_methods.h"
 
32
#include "status.h"
 
33
 
 
34
#include <vector>
 
35
 
 
36
using namespace drizzled;
 
37
using namespace std;
 
38
 
 
39
/*
 
40
 * Vectors of columns for the status I_S tables.
 
41
 */
 
42
vector<const plugin::ColumnInfo *> *status_columns= NULL;
 
43
 
 
44
/*
 
45
 * Methods for the status related I_S tables.
 
46
 */
 
47
static plugin::InfoSchemaMethods *methods= NULL;
 
48
 
 
49
/*
 
50
 * status I_S tables.
 
51
 */
 
52
static plugin::InfoSchemaTable *glob_status_table= NULL;
 
53
static plugin::InfoSchemaTable *sess_status_table= NULL;
 
54
static plugin::InfoSchemaTable *status_table= NULL;
 
55
 
 
56
/**
 
57
 * Populate the vectors of columns for the I_S table.
 
58
 *
 
59
 * @return a pointer to a std::vector of Columns.
 
60
 */
 
61
vector<const plugin::ColumnInfo *> *GlobalStatusIS::createColumns()
 
62
{
 
63
  if (status_columns == NULL)
 
64
  {
 
65
    status_columns= new vector<const plugin::ColumnInfo *>;
 
66
  }
 
67
  else
 
68
  {
 
69
    clearColumns(*status_columns);
 
70
  }
 
71
 
 
72
  status_columns->push_back(new plugin::ColumnInfo("VARIABLE_NAME",
 
73
                                                   64,
 
74
                                                   DRIZZLE_TYPE_VARCHAR,
 
75
                                                   0,
 
76
                                                   0,
 
77
                                                   "Variable_name",
 
78
                                                   SKIP_OPEN_TABLE));
 
79
 
 
80
  status_columns->push_back(new plugin::ColumnInfo("VARIABLE_VALUE",
 
81
                                                   16300,
 
82
                                                   DRIZZLE_TYPE_VARCHAR,
 
83
                                                   0,
 
84
                                                   1,
 
85
                                                   "Value",
 
86
                                                   SKIP_OPEN_TABLE));
 
87
 
 
88
  return status_columns;
 
89
}
 
90
 
 
91
/**
 
92
 * Initialize the I_S table.
 
93
 *
 
94
 * @return a pointer to an I_S table
 
95
 */
 
96
plugin::InfoSchemaTable *GlobalStatusIS::getTable()
 
97
{
 
98
  status_columns= createColumns();
 
99
 
 
100
  if (methods == NULL)
 
101
  {
 
102
    methods= new StatusISMethods();
 
103
  }
 
104
 
 
105
  if (glob_status_table == NULL)
 
106
  {
 
107
    glob_status_table= new plugin::InfoSchemaTable("GLOBAL_STATUS",
 
108
                                                   *status_columns,
 
109
                                                   -1, -1, false, false,
 
110
                                                   0, 
 
111
                                                   methods);
 
112
  }
 
113
 
 
114
  return glob_status_table;
 
115
}
 
116
 
 
117
/**
 
118
 * Delete memory allocated for the table, columns and methods.
 
119
 */
 
120
void GlobalStatusIS::cleanup()
 
121
{
 
122
  clearColumns(*status_columns);
 
123
  delete glob_status_table;
 
124
  delete methods;
 
125
  delete status_columns;
 
126
}
 
127
 
 
128
/**
 
129
 * Initialize the I_S table.
 
130
 *
 
131
 * @return a pointer to an I_S table
 
132
 */
 
133
plugin::InfoSchemaTable *SessionStatusIS::getTable()
 
134
{
 
135
  if (sess_status_table == NULL)
 
136
  {
 
137
    sess_status_table= new plugin::InfoSchemaTable("SESSION_STATUS",
 
138
                                                   *status_columns,
 
139
                                                   -1, -1, false, false,
 
140
                                                   0, 
 
141
                                                   methods);
 
142
  }
 
143
 
 
144
  return sess_status_table;
 
145
}
 
146
 
 
147
/**
 
148
 * Delete memory allocated for the table, columns and methods.
 
149
 */
 
150
void SessionStatusIS::cleanup()
 
151
{
 
152
  delete sess_status_table;
 
153
}
 
154
 
 
155
/**
 
156
 * Initialize the I_S table.
 
157
 *
 
158
 * @return a pointer to an I_S table
 
159
 */
 
160
plugin::InfoSchemaTable *StatusIS::getTable()
 
161
{
 
162
  if (status_table == NULL)
 
163
  {
 
164
    status_table= new plugin::InfoSchemaTable("STATUS",
 
165
                                              *status_columns,
 
166
                                              -1, -1, true, false, 0,
 
167
                                              methods);
 
168
  }
 
169
 
 
170
  return status_table;
 
171
}
 
172
 
 
173
/**
 
174
 * Delete memory allocated for the table, columns and methods.
 
175
 */
 
176
void StatusIS::cleanup()
 
177
{
 
178
  delete status_table;
 
179
}
 
180
 
 
181
int StatusISMethods::fillTable(Session *session, TableList *tables)
 
182
{
 
183
  LEX *lex= session->lex;
 
184
  const char *wild= lex->wild ? lex->wild->ptr() : NULL;
 
185
  int res= 0;
 
186
  STATUS_VAR *tmp1, tmp;
 
187
  const string schema_table_name= tables->schema_table->getTableName();
 
188
  enum enum_var_type option_type;
 
189
  bool upper_case_names= (schema_table_name.compare("STATUS") != 0);
 
190
 
 
191
  if (schema_table_name.compare("STATUS") == 0)
 
192
  {
 
193
    option_type= lex->option_type;
 
194
    if (option_type == OPT_GLOBAL)
 
195
    {
 
196
      tmp1= &tmp;
 
197
    }
 
198
    else
 
199
    {
 
200
      tmp1= session->initial_status_var;
 
201
    }
 
202
  }
 
203
  else if (schema_table_name.compare("GLOBAL_STATUS") == 0)
 
204
  {
 
205
    option_type= OPT_GLOBAL;
 
206
    tmp1= &tmp;
 
207
  }
 
208
  else
 
209
  {
 
210
    option_type= OPT_SESSION;
 
211
    tmp1= &session->status_var;
 
212
  }
 
213
 
 
214
  pthread_mutex_lock(&LOCK_status);
 
215
  if (option_type == OPT_GLOBAL)
 
216
  {
 
217
    calc_sum_of_all_status(&tmp);
 
218
  }
 
219
  res= show_status_array(session, wild,
 
220
                         getFrontOfStatusVars(),
 
221
                         option_type, tmp1, "", tables->table,
 
222
                         upper_case_names);
 
223
  pthread_mutex_unlock(&LOCK_status);
 
224
  return res;
 
225
}
 
226