← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/info_schema/key_column_usage.cc

  • Committer: Monty Taylor
  • Date: 2010-03-11 18:27:20 UTC
  • mfrom: (1333 staging)
  • mto: This revision was merged to the branch mainline in revision 1348.
  • Revision ID: mordred@inaugust.com-20100311182720-hd1h87y6cb1b1mp0
Merged trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/info_schema/key_column_usage.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
 
 *   key column usage I_S table methods.
24
 
 */
25
 
 
26
 
#include "config.h"
27
 
#include "drizzled/session.h"
28
 
#include "drizzled/show.h"
29
 
#include "drizzled/global_charset_info.h"
30
 
 
31
 
 
32
 
#include "helper_methods.h"
33
 
#include "key_column_usage.h"
34
 
 
35
 
#include <vector>
36
 
 
37
 
using namespace drizzled;
38
 
using namespace std;
39
 
 
40
 
/*
41
 
 * Vectors of columns for the key column usage I_S table.
42
 
 */
43
 
static vector<const plugin::ColumnInfo *> *columns= NULL;
44
 
 
45
 
/*
46
 
 * Methods for the key column usage I_S table.
47
 
 */
48
 
static plugin::InfoSchemaMethods *methods= NULL;
49
 
 
50
 
/*
51
 
 * key column usage I_S table.
52
 
 */
53
 
static plugin::InfoSchemaTable *key_col_table= NULL;
54
 
 
55
 
/**
56
 
 * Populate the vectors of columns for the I_S table.
57
 
 *
58
 
 * @return a pointer to a std::vector of Columns.
59
 
 */
60
 
vector<const plugin::ColumnInfo *> *KeyColumnUsageIS::createColumns()
61
 
{
62
 
  if (columns == NULL)
63
 
  {
64
 
    columns= new vector<const plugin::ColumnInfo *>;
65
 
  }
66
 
  else
67
 
  {
68
 
    clearColumns(*columns);
69
 
  }
70
 
 
71
 
  columns->push_back(new plugin::ColumnInfo("CONSTRAINT_CATALOG",
72
 
                                            FN_REFLEN,
73
 
                                            DRIZZLE_TYPE_VARCHAR,
74
 
                                            0,
75
 
                                            1,
76
 
                                            ""));
77
 
 
78
 
  columns->push_back(new plugin::ColumnInfo("CONSTRAINT_SCHEMA",
79
 
                                            NAME_CHAR_LEN,
80
 
                                            DRIZZLE_TYPE_VARCHAR,
81
 
                                            0,
82
 
                                            0,
83
 
                                            ""));
84
 
 
85
 
  columns->push_back(new plugin::ColumnInfo("CONSTRAINT_NAME",
86
 
                                            NAME_CHAR_LEN,
87
 
                                            DRIZZLE_TYPE_VARCHAR,
88
 
                                            0,
89
 
                                            0,
90
 
                                            ""));
91
 
 
92
 
  columns->push_back(new plugin::ColumnInfo("TABLE_CATALOG",
93
 
                                            FN_REFLEN,
94
 
                                            DRIZZLE_TYPE_VARCHAR,
95
 
                                            0,
96
 
                                            1,
97
 
                                            ""));
98
 
 
99
 
  columns->push_back(new plugin::ColumnInfo("TABLE_SCHEMA",
100
 
                                            NAME_CHAR_LEN,
101
 
                                            DRIZZLE_TYPE_VARCHAR,
102
 
                                            0,
103
 
                                            0,
104
 
                                            ""));
105
 
 
106
 
  columns->push_back(new plugin::ColumnInfo("TABLE_NAME",
107
 
                                            NAME_CHAR_LEN,
108
 
                                            DRIZZLE_TYPE_VARCHAR,
109
 
                                            0,
110
 
                                            0,
111
 
                                            ""));
112
 
 
113
 
  columns->push_back(new plugin::ColumnInfo("COLUMN_NAME",
114
 
                                            NAME_CHAR_LEN,
115
 
                                            DRIZZLE_TYPE_VARCHAR,
116
 
                                            0,
117
 
                                            0,
118
 
                                            ""));
119
 
 
120
 
  columns->push_back(new plugin::ColumnInfo("ORDINAL_POSITION",
121
 
                                            10,
122
 
                                            DRIZZLE_TYPE_LONGLONG,
123
 
                                            0,
124
 
                                            0,
125
 
                                            ""));
126
 
 
127
 
  columns->push_back(new plugin::ColumnInfo("POSITION_IN_UNIQUE_CONSTRAINT",
128
 
                                            10,
129
 
                                            DRIZZLE_TYPE_LONGLONG,
130
 
                                            0,
131
 
                                            1,
132
 
                                            ""));
133
 
 
134
 
  columns->push_back(new plugin::ColumnInfo("REFERENCED_TABLE_SCHEMA",
135
 
                                            NAME_CHAR_LEN,
136
 
                                            DRIZZLE_TYPE_VARCHAR,
137
 
                                            0,
138
 
                                            1,
139
 
                                            ""));
140
 
 
141
 
  columns->push_back(new plugin::ColumnInfo("REFERENCED_TABLE_NAME",
142
 
                                            NAME_CHAR_LEN,
143
 
                                            DRIZZLE_TYPE_VARCHAR,
144
 
                                            0,
145
 
                                            1,
146
 
                                            ""));
147
 
 
148
 
  columns->push_back(new plugin::ColumnInfo("REFERENCED_COLUMN_NAME",
149
 
                                            NAME_CHAR_LEN,
150
 
                                            DRIZZLE_TYPE_VARCHAR,
151
 
                                            0,
152
 
                                            1,
153
 
                                            ""));
154
 
 
155
 
  return columns;
156
 
}
157
 
 
158
 
/**
159
 
 * Initialize the I_S table.
160
 
 *
161
 
 * @return a pointer to an I_S table
162
 
 */
163
 
plugin::InfoSchemaTable *KeyColumnUsageIS::getTable()
164
 
{
165
 
  columns= createColumns();
166
 
 
167
 
  if (methods == NULL)
168
 
  {
169
 
    methods= new KeyColUsageISMethods();
170
 
  }
171
 
 
172
 
  if (key_col_table == NULL)
173
 
  {
174
 
    key_col_table= new plugin::InfoSchemaTable("KEY_COLUMN_USAGE",
175
 
                                               *columns,
176
 
                                               4, 5, false, true,
177
 
                                               0,
178
 
                                               methods);
179
 
  }
180
 
 
181
 
  return key_col_table;
182
 
}
183
 
 
184
 
/**
185
 
 * Delete memory allocated for the table, columns and methods.
186
 
 */
187
 
void KeyColumnUsageIS::cleanup()
188
 
{
189
 
  clearColumns(*columns);
190
 
  delete key_col_table;
191
 
  delete methods;
192
 
  delete columns;
193
 
}
194
 
 
195
 
int KeyColUsageISMethods::processTable(plugin::InfoSchemaTable *store_table,
196
 
                                       Session *session,
197
 
                                       TableList *tables,
198
 
                                       Table *table, bool res,
199
 
                                       LEX_STRING *db_name,
200
 
                                       LEX_STRING *table_name)
201
 
{
202
 
  if (res)
203
 
  {
204
 
    if (session->is_error())
205
 
      push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
206
 
                   session->main_da.sql_errno(), session->main_da.message());
207
 
    session->clear_error();
208
 
    return(0);
209
 
  }
210
 
  else
211
 
  {
212
 
    List<FOREIGN_KEY_INFO> f_key_list;
213
 
    Table *show_table= tables->table;
214
 
    KEY *key_info=show_table->key_info;
215
 
    uint32_t primary_key= show_table->s->primary_key;
216
 
    show_table->cursor->info(HA_STATUS_VARIABLE |
217
 
                             HA_STATUS_NO_LOCK |
218
 
                             HA_STATUS_TIME);
219
 
    for (uint32_t i=0 ; i < show_table->s->keys ; i++, key_info++)
220
 
    {
221
 
      if (i != primary_key && !(key_info->flags & HA_NOSAME))
222
 
      {
223
 
        continue;
224
 
      }
225
 
      uint32_t f_idx= 0;
226
 
      KEY_PART_INFO *key_part= key_info->key_part;
227
 
      for (uint32_t j=0 ; j < key_info->key_parts ; j++,key_part++)
228
 
      {
229
 
        if (key_part->field)
230
 
        {
231
 
          f_idx++;
232
 
          table->restoreRecordAsDefault();
233
 
          store_key_column_usage(table, db_name, table_name,
234
 
                                 key_info->name,
235
 
                                 strlen(key_info->name),
236
 
                                 key_part->field->field_name,
237
 
                                 strlen(key_part->field->field_name),
238
 
                                 (int64_t) f_idx);
239
 
          store_table->addRow(table->record[0],
240
 
                                       table->s->reclength);
241
 
        }
242
 
      }
243
 
    }
244
 
 
245
 
    show_table->cursor->get_foreign_key_list(session, &f_key_list);
246
 
    FOREIGN_KEY_INFO *f_key_info;
247
 
    List_iterator_fast<FOREIGN_KEY_INFO> fkey_it(f_key_list);
248
 
    while ((f_key_info= fkey_it++))
249
 
    {
250
 
      LEX_STRING *f_info;
251
 
      LEX_STRING *r_info;
252
 
      List_iterator_fast<LEX_STRING> it(f_key_info->foreign_fields),
253
 
        it1(f_key_info->referenced_fields);
254
 
      uint32_t f_idx= 0;
255
 
      while ((f_info= it++))
256
 
      {
257
 
        r_info= it1++;
258
 
        f_idx++;
259
 
        table->restoreRecordAsDefault();
260
 
        store_key_column_usage(table, db_name, table_name,
261
 
                               f_key_info->forein_id->str,
262
 
                               f_key_info->forein_id->length,
263
 
                               f_info->str, f_info->length,
264
 
                               (int64_t) f_idx);
265
 
        table->setWriteSet(8);
266
 
        table->setWriteSet(9);
267
 
        table->setWriteSet(10);
268
 
        table->setWriteSet(11);
269
 
        table->field[8]->store((int64_t) f_idx, true);
270
 
        table->field[8]->set_notnull();
271
 
        table->field[9]->store(f_key_info->referenced_db->str,
272
 
                               f_key_info->referenced_db->length,
273
 
                               system_charset_info);
274
 
        table->field[9]->set_notnull();
275
 
        table->field[10]->store(f_key_info->referenced_table->str,
276
 
                                f_key_info->referenced_table->length,
277
 
                                system_charset_info);
278
 
        table->field[10]->set_notnull();
279
 
        table->field[11]->store(r_info->str, r_info->length,
280
 
                                system_charset_info);
281
 
        table->field[11]->set_notnull();
282
 
        store_table->addRow(table->record[0], table->s->reclength);
283
 
      }
284
 
    }
285
 
  }
286
 
  return (res);
287
 
}