← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/info_schema/schemata.cc

  • Committer: Brian Aker
  • Date: 2010-02-14 02:02:48 UTC
  • mfrom: (1273.13.64 fix_is)
  • Revision ID: brian@gaz-20100214020248-bhovaejhz9fmer3q
Merge in data_dictionary.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/info_schema/schemata.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
 
 *   schemata I_S table methods.
24
 
 */
25
 
 
26
 
#include "config.h"
27
 
#include "drizzled/session.h"
28
 
#include "drizzled/show.h"
29
 
#include "drizzled/join_table.h"
30
 
#include "drizzled/sql_table.h"
31
 
#include "drizzled/db.h"
32
 
#include "helper_methods.h"
33
 
#include "schemata.h"
34
 
 
35
 
#ifdef HAVE_SYS_STAT_H
36
 
# include <sys/stat.h>
37
 
#endif
38
 
 
39
 
#include <vector>
40
 
 
41
 
using namespace drizzled;
42
 
using namespace std;
43
 
 
44
 
/*
45
 
 * Vectors of columns for the schemata I_S table.
46
 
 */
47
 
static vector<const plugin::ColumnInfo *> *columns= NULL;
48
 
 
49
 
/*
50
 
 * Methods for the schemata I_S table.
51
 
 */
52
 
static plugin::InfoSchemaMethods *methods= NULL;
53
 
 
54
 
/*
55
 
 * schemata I_S table.
56
 
 */
57
 
static plugin::InfoSchemaTable *sch_table= NULL;
58
 
 
59
 
/**
60
 
 * Populate the vectors of columns for the I_S table.
61
 
 *
62
 
 * @return a pointer to a std::vector of Columns.
63
 
 */
64
 
vector<const plugin::ColumnInfo *> *SchemataIS::createColumns()
65
 
{
66
 
  if (columns == NULL)
67
 
  {
68
 
    columns= new vector<const plugin::ColumnInfo *>;
69
 
  }
70
 
  else
71
 
  {
72
 
    clearColumns(*columns);
73
 
  }
74
 
 
75
 
  columns->push_back(new plugin::ColumnInfo("CATALOG_NAME",
76
 
                                            FN_REFLEN,
77
 
                                            DRIZZLE_TYPE_VARCHAR,
78
 
                                            0, 
79
 
                                            1, 
80
 
                                            ""));
81
 
 
82
 
  columns->push_back(new plugin::ColumnInfo("SCHEMA_NAME",
83
 
                                            NAME_CHAR_LEN,
84
 
                                            DRIZZLE_TYPE_VARCHAR,
85
 
                                            0, 
86
 
                                            0, 
87
 
                                            "Database"));
88
 
 
89
 
  columns->push_back(new plugin::ColumnInfo("DEFAULT_CHARACTER_SET_NAME",
90
 
                                            64, 
91
 
                                            DRIZZLE_TYPE_VARCHAR, 
92
 
                                            0, 
93
 
                                            0, 
94
 
                                            ""));
95
 
 
96
 
  columns->push_back(new plugin::ColumnInfo("DEFAULT_COLLATION_NAME",
97
 
                                            64, 
98
 
                                            DRIZZLE_TYPE_VARCHAR, 
99
 
                                            0, 
100
 
                                            0, 
101
 
                                            ""));
102
 
 
103
 
  columns->push_back(new plugin::ColumnInfo("SQL_PATH",
104
 
                                            FN_REFLEN,
105
 
                                            DRIZZLE_TYPE_VARCHAR,
106
 
                                            0, 
107
 
                                            1, 
108
 
                                            ""));
109
 
 
110
 
  return columns;
111
 
}
112
 
 
113
 
/**
114
 
 * Initialize the I_S table.
115
 
 *
116
 
 * @return a pointer to an I_S table
117
 
 */
118
 
plugin::InfoSchemaTable *SchemataIS::getTable()
119
 
{
120
 
  columns= createColumns();
121
 
 
122
 
  if (methods == NULL)
123
 
  {
124
 
    methods= new SchemataISMethods();
125
 
  }
126
 
 
127
 
  if (sch_table == NULL)
128
 
  {
129
 
    sch_table= new plugin::InfoSchemaTable("SCHEMATA",
130
 
                                           *columns,
131
 
                                           1, -1, false, false, 0,
132
 
                                           methods);
133
 
  }
134
 
 
135
 
  return sch_table;
136
 
}
137
 
 
138
 
/**
139
 
 * Delete memory allocated for the table, columns and methods.
140
 
 */
141
 
void SchemataIS::cleanup()
142
 
{
143
 
  clearColumns(*columns);
144
 
  delete sch_table;
145
 
  delete methods;
146
 
  delete columns;
147
 
}
148
 
 
149
 
static bool store_schema_schemata(Session *, 
150
 
                                  Table *table, 
151
 
                                  LEX_STRING *db_name,
152
 
                                  const CHARSET_INFO * const cs,
153
 
                                  plugin::InfoSchemaTable *schema_table)
154
 
{
155
 
  table->restoreRecordAsDefault();
156
 
  table->setWriteSet(1);
157
 
  table->setWriteSet(2);
158
 
  table->setWriteSet(3);
159
 
  table->field[1]->store(db_name->str, db_name->length, system_charset_info);
160
 
  table->field[2]->store(cs->csname, strlen(cs->csname), system_charset_info);
161
 
  table->field[3]->store(cs->name, strlen(cs->name), system_charset_info);
162
 
  schema_table->addRow(table->record[0], table->s->reclength);
163
 
  return false;
164
 
}
165
 
 
166
 
int SchemataISMethods::fillTable(Session *session, 
167
 
                                 Table *table,
168
 
                                 plugin::InfoSchemaTable *schema_table)
169
 
{
170
 
  /*
171
 
    TODO: fill_schema_shemata() is called when new client is connected.
172
 
    Returning error status in this case leads to client hangup.
173
 
  */
174
 
 
175
 
  LOOKUP_FIELD_VALUES lookup_field_vals;
176
 
  vector<LEX_STRING*> db_names;
177
 
  bool with_i_schema;
178
 
  /* the WHERE condition */
179
 
  COND *cond= table->reginfo.join_tab->select_cond;
180
 
 
181
 
  if (get_lookup_field_values(session, 
182
 
                              cond, 
183
 
                              table->pos_in_table_list, 
184
 
                              &lookup_field_vals,
185
 
                              schema_table))
186
 
  {
187
 
    return 0;
188
 
  }
189
 
 
190
 
  if (make_db_list(session, 
191
 
                   db_names, 
192
 
                   &lookup_field_vals,
193
 
                   &with_i_schema))
194
 
  {
195
 
    return 1;
196
 
  }
197
 
 
198
 
  /*
199
 
    If we have lookup db value we should check that the database exists
200
 
  */
201
 
  if (lookup_field_vals.db_value.str && 
202
 
      ! lookup_field_vals.wild_db_value &&
203
 
      ! with_i_schema)
204
 
  {
205
 
    char path[FN_REFLEN+16];
206
 
    uint32_t path_len;
207
 
    struct stat stat_info;
208
 
    if (! lookup_field_vals.db_value.str[0])
209
 
    {
210
 
      return 0;
211
 
    }
212
 
 
213
 
    path_len= build_table_filename(path, 
214
 
                                   sizeof(path),
215
 
                                   lookup_field_vals.db_value.str, 
216
 
                                   "", 
217
 
                                   false);
218
 
    path[path_len-1]= 0;
219
 
    if (stat(path,&stat_info))
220
 
    {
221
 
      return 0;
222
 
    }
223
 
  }
224
 
 
225
 
  vector<LEX_STRING*>::iterator db_name= db_names.begin();
226
 
  while (db_name != db_names.end())
227
 
  {
228
 
    if (with_i_schema)       // information schema name is always first in list
229
 
    {
230
 
      if (store_schema_schemata(session, table, *db_name, system_charset_info, schema_table))
231
 
      {
232
 
        return 1;
233
 
      }
234
 
      with_i_schema= 0;
235
 
    }
236
 
    else
237
 
    {
238
 
      const CHARSET_INFO *cs= get_default_db_collation((*db_name)->str);
239
 
 
240
 
      if (store_schema_schemata(session, table, *db_name, cs, schema_table))
241
 
      {
242
 
        return 1;
243
 
      }
244
 
    }
245
 
    ++db_name;
246
 
  }
247
 
  return 0;
248
 
}
249
 
 
250
 
int SchemataISMethods::oldFormat(Session *session, drizzled::plugin::InfoSchemaTable *schema_table)
251
 
  const
252
 
{
253
 
  char tmp[128];
254
 
  LEX *lex= session->lex;
255
 
  Select_Lex *sel= lex->current_select;
256
 
  Name_resolution_context *context= &sel->context;
257
 
  const drizzled::plugin::InfoSchemaTable::Columns sch_columns= schema_table->getColumns();
258
 
 
259
 
  if (! sel->item_list.elements)
260
 
  {
261
 
    const drizzled::plugin::ColumnInfo *column= sch_columns[1];
262
 
    String buffer(tmp,sizeof(tmp), system_charset_info);
263
 
    Item_field *field= new Item_field(context,
264
 
                                      NULL, 
265
 
                                      NULL, 
266
 
                                      column->getName().c_str());
267
 
    if (! field || session->add_item_to_list(field))
268
 
    {
269
 
      return 1;
270
 
    }
271
 
    buffer.length(0);
272
 
    buffer.append(column->getOldName().c_str());
273
 
    if (lex->wild && lex->wild->ptr())
274
 
    {
275
 
      buffer.append(STRING_WITH_LEN(" ("));
276
 
      buffer.append(lex->wild->ptr());
277
 
      buffer.append(')');
278
 
    }
279
 
    field->set_name(buffer.ptr(), buffer.length(), system_charset_info);
280
 
  }
281
 
  return 0;
282
 
}
283