← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/show.cc

  • Committer: Brian Aker
  • Date: 2010-05-27 01:25:56 UTC
  • mfrom: (1567.1.4 new-staging)
  • Revision ID: brian@gaz-20100527012556-5zgkirkl7swbigd6
Merge of Brian, Paul. PBXT compile issue, and test framework cleanup. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/show.cc
1
 
/* Copyright (C) 2000-2004 MySQL AB
2
 
 
3
 
   This program is free software; you can redistribute it and/or modify
4
 
   it under the terms of the GNU General Public License as published by
5
 
   the Free Software Foundation; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 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; version 2 of the License.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
18
 */
15
19
 
16
20
 
17
21
/* Function with list databases, tables or fields */
18
 
#include <drizzled/server_includes.h>
 
22
#include "config.h"
19
23
#include <drizzled/sql_select.h>
20
 
#include <drizzled/sql_show.h>
21
 
#include "repl_failsafe.h"
22
 
#include <mysys/my_dir.h>
23
 
 
24
 
#define STR_OR_NIL(S) ((S) ? (S) : "<nil>")
25
 
 
26
 
/* Match the values of enum ha_choice */
27
 
static const char *ha_choice_values[] = {"", "0", "1"};
28
 
 
29
 
static void store_key_options(THD *thd, String *packet, TABLE *table,
30
 
                              KEY *key_info);
31
 
 
32
 
 
33
 
 
34
 
int wild_case_compare(const CHARSET_INFO * const cs, const char *str,const char *wildstr)
 
24
#include <drizzled/show.h>
 
25
#include <drizzled/gettext.h>
 
26
#include <drizzled/util/convert.h>
 
27
#include <drizzled/error.h>
 
28
#include <drizzled/tztime.h>
 
29
#include <drizzled/data_home.h>
 
30
#include <drizzled/item/blob.h>
 
31
#include <drizzled/item/cmpfunc.h>
 
32
#include <drizzled/item/return_int.h>
 
33
#include <drizzled/item/empty_string.h>
 
34
#include <drizzled/item/return_date_time.h>
 
35
#include <drizzled/sql_base.h>
 
36
#include <drizzled/db.h>
 
37
#include <drizzled/field/timestamp.h>
 
38
#include <drizzled/field/decimal.h>
 
39
#include <drizzled/lock.h>
 
40
#include <drizzled/item/return_date_time.h>
 
41
#include <drizzled/item/empty_string.h>
 
42
#include "drizzled/session_list.h"
 
43
#include <drizzled/message/schema.pb.h>
 
44
#include <drizzled/plugin/client.h>
 
45
#include <drizzled/cached_directory.h>
 
46
#include "drizzled/sql_table.h"
 
47
#include "drizzled/global_charset_info.h"
 
48
#include "drizzled/pthread_globals.h"
 
49
#include "drizzled/internal/m_string.h"
 
50
#include "drizzled/internal/my_sys.h"
 
51
 
 
52
#include <sys/stat.h>
 
53
 
 
54
#include <string>
 
55
#include <iostream>
 
56
#include <sstream>
 
57
#include <vector>
 
58
#include <algorithm>
 
59
 
 
60
using namespace std;
 
61
 
 
62
namespace drizzled
 
63
{
 
64
 
 
65
inline const char *
 
66
str_or_nil(const char *str)
 
67
{
 
68
  return str ? str : "<nil>";
 
69
}
 
70
 
 
71
static void store_key_options(String *packet, Table *table, KeyInfo *key_info);
 
72
 
 
73
 
 
74
int wild_case_compare(const CHARSET_INFO * const cs, const char *str, const char *wildstr)
35
75
{
36
76
  register int flag;
 
77
 
37
78
  while (*wildstr)
38
79
  {
39
 
    while (*wildstr && *wildstr != wild_many && *wildstr != wild_one)
 
80
    while (*wildstr && *wildstr != internal::wild_many && *wildstr != internal::wild_one)
40
81
    {
41
 
      if (*wildstr == wild_prefix && wildstr[1])
 
82
      if (*wildstr == internal::wild_prefix && wildstr[1])
42
83
        wildstr++;
43
84
      if (my_toupper(cs, *wildstr++) != my_toupper(cs, *str++))
44
 
        return(1);
 
85
        return (1);
45
86
    }
46
87
    if (! *wildstr )
47
88
      return (*str != 0);
48
 
    if (*wildstr++ == wild_one)
 
89
    if (*wildstr++ == internal::wild_one)
49
90
    {
50
91
      if (! *str++)
51
92
        return (1);     /* One char; skip */
52
93
    }
53
94
    else
54
95
    {                                           /* Found '*' */
55
 
      if (!*wildstr)
56
 
        return(0);              /* '*' as last char: OK */
57
 
      flag=(*wildstr != wild_many && *wildstr != wild_one);
 
96
      if (! *wildstr)
 
97
        return (0);             /* '*' as last char: OK */
 
98
      flag=(*wildstr != internal::wild_many && *wildstr != internal::wild_one);
58
99
      do
59
100
      {
60
 
        if (flag)
61
 
        {
62
 
          char cmp;
63
 
          if ((cmp= *wildstr) == wild_prefix && wildstr[1])
64
 
            cmp=wildstr[1];
65
 
          cmp=my_toupper(cs, cmp);
66
 
          while (*str && my_toupper(cs, *str) != cmp)
67
 
            str++;
68
 
    if (!*str)
 
101
        if (flag)
 
102
        {
 
103
          char cmp;
 
104
          if ((cmp= *wildstr) == internal::wild_prefix && wildstr[1])
 
105
            cmp= wildstr[1];
 
106
          cmp= my_toupper(cs, cmp);
 
107
          while (*str && my_toupper(cs, *str) != cmp)
 
108
            str++;
 
109
          if (! *str)
 
110
            return (1);
 
111
        }
 
112
        if (wild_case_compare(cs, str, wildstr) == 0)
 
113
          return (0);
 
114
      } while (*str++);
69
115
      return (1);
70
 
        }
71
 
  if (wild_case_compare(cs, str,wildstr) == 0)
72
 
      return (0);
73
 
      } while (*str++);
74
 
      return(1);
75
116
    }
76
117
  }
 
118
 
77
119
  return (*str != '\0');
78
120
}
79
121
 
80
 
/***************************************************************************
81
 
** List all table types supported
82
 
***************************************************************************/
83
 
 
84
 
static bool show_plugins(THD *thd, plugin_ref plugin,
85
 
                            void *arg)
86
 
{
87
 
  TABLE *table= (TABLE*) arg;
88
 
  struct st_mysql_plugin *plug= plugin_decl(plugin);
89
 
  struct st_plugin_dl *plugin_dl= plugin_dlib(plugin);
90
 
  const CHARSET_INFO * const cs= system_charset_info;
91
 
 
92
 
  restore_record(table, s->default_values);
93
 
 
94
 
  table->field[0]->store(plugin_name(plugin)->str,
95
 
                         plugin_name(plugin)->length, cs);
96
 
 
97
 
  if (plug->version)
98
 
  {
99
 
    table->field[1]->store(plug->version, strlen(plug->version), cs);
100
 
    table->field[1]->set_notnull();
101
 
  }
102
 
  else
103
 
    table->field[1]->set_null();
104
 
 
105
 
  switch (plugin_state(plugin)) {
106
 
  /* case PLUGIN_IS_FREED: does not happen */
107
 
  case PLUGIN_IS_DELETED:
108
 
    table->field[2]->store(STRING_WITH_LEN("DELETED"), cs);
109
 
    break;
110
 
  case PLUGIN_IS_UNINITIALIZED:
111
 
    table->field[2]->store(STRING_WITH_LEN("INACTIVE"), cs);
112
 
    break;
113
 
  case PLUGIN_IS_READY:
114
 
    table->field[2]->store(STRING_WITH_LEN("ACTIVE"), cs);
115
 
    break;
116
 
  default:
117
 
    assert(0);
118
 
  }
119
 
 
120
 
  table->field[3]->store(plugin_type_names[plug->type].str,
121
 
                         plugin_type_names[plug->type].length,
122
 
                         cs);
123
 
 
124
 
  if (plugin_dl)
125
 
  {
126
 
    table->field[4]->store(plugin_dl->dl.str, plugin_dl->dl.length, cs);
127
 
    table->field[4]->set_notnull();
128
 
  }
129
 
  else
130
 
  {
131
 
    table->field[4]->set_null();
132
 
  }
133
 
 
134
 
  if (plug->author)
135
 
  {
136
 
    table->field[5]->store(plug->author, strlen(plug->author), cs);
137
 
    table->field[5]->set_notnull();
138
 
  }
139
 
  else
140
 
    table->field[5]->set_null();
141
 
 
142
 
  if (plug->descr)
143
 
  {
144
 
    table->field[6]->store(plug->descr, strlen(plug->descr), cs);
145
 
    table->field[6]->set_notnull();
146
 
  }
147
 
  else
148
 
    table->field[6]->set_null();
149
 
 
150
 
  switch (plug->license) {
151
 
  case PLUGIN_LICENSE_GPL:
152
 
    table->field[7]->store(PLUGIN_LICENSE_GPL_STRING, 
153
 
                           strlen(PLUGIN_LICENSE_GPL_STRING), cs);
154
 
    break;
155
 
  case PLUGIN_LICENSE_BSD:
156
 
    table->field[7]->store(PLUGIN_LICENSE_BSD_STRING, 
157
 
                           strlen(PLUGIN_LICENSE_BSD_STRING), cs);
158
 
    break;
159
 
  default:
160
 
    table->field[7]->store(PLUGIN_LICENSE_PROPRIETARY_STRING, 
161
 
                           strlen(PLUGIN_LICENSE_PROPRIETARY_STRING), cs);
162
 
    break;
163
 
  }
164
 
  table->field[7]->set_notnull();
165
 
 
166
 
  return schema_table_store_record(thd, table);
167
 
}
168
 
 
169
 
 
170
 
int fill_plugins(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((unused)))
171
 
{
172
 
  TABLE *table= tables->table;
173
 
 
174
 
  if (plugin_foreach_with_mask(thd, show_plugins, DRIZZLE_ANY_PLUGIN,
175
 
                               ~PLUGIN_IS_FREED, table))
176
 
    return(1);
177
 
 
178
 
  return(0);
179
 
}
180
 
 
181
 
 
182
 
/*
183
 
  find_files() - find files in a given directory.
184
 
 
185
 
  SYNOPSIS
186
 
    find_files()
187
 
    thd                 thread handler
188
 
    files               put found files in this list
189
 
    db                  database name to set in TABLE_LIST structure
190
 
    path                path to database
191
 
    wild                filter for found files
192
 
    dir                 read databases in path if true, read .frm files in
193
 
                        database otherwise
194
 
 
195
 
  RETURN
196
 
    FIND_FILES_OK       success
197
 
    FIND_FILES_OOM      out of memory error
198
 
    FIND_FILES_DIR      no such directory, or directory can't be read
199
 
*/
200
 
 
201
 
 
202
 
find_files_result
203
 
find_files(THD *thd, List<LEX_STRING> *files, const char *db,
204
 
           const char *path, const char *wild, bool dir)
205
 
{
206
 
  uint i;
207
 
  char *ext;
208
 
  MY_DIR *dirp;
209
 
  FILEINFO *file;
210
 
  LEX_STRING *file_name= 0;
211
 
  uint file_name_len;
212
 
  TABLE_LIST table_list;
213
 
 
214
 
  if (wild && !wild[0])
215
 
    wild=0;
216
 
 
217
 
  memset(&table_list, 0, sizeof(table_list));
218
 
 
219
 
  if (!(dirp = my_dir(path,MYF(dir ? MY_WANT_STAT : 0))))
220
 
  {
221
 
    if (my_errno == ENOENT)
222
 
      my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), db);
223
 
    else
224
 
      my_error(ER_CANT_READ_DIR, MYF(ME_BELL+ME_WAITTANG), path, my_errno);
225
 
    return(FIND_FILES_DIR);
226
 
  }
227
 
 
228
 
  for (i=0 ; i < (uint) dirp->number_off_files  ; i++)
229
 
  {
230
 
    char uname[NAME_LEN + 1];                   /* Unencoded name */
231
 
    file=dirp->dir_entry+i;
232
 
    if (dir)
233
 
    {                                           /* Return databases */
234
 
      if ((file->name[0] == '.' && 
235
 
          ((file->name[1] == '.' && file->name[2] == '\0') ||
236
 
            file->name[1] == '\0')))
237
 
        continue;                               /* . or .. */
238
 
#ifdef USE_SYMDIR
239
 
      char *ext;
240
 
      char buff[FN_REFLEN];
241
 
      if (my_use_symdir && !strcmp(ext=fn_ext(file->name), ".sym"))
242
 
      {
243
 
        /* Only show the sym file if it points to a directory */
244
 
        char *end;
245
 
        *ext=0;                                 /* Remove extension */
246
 
        unpack_dirname(buff, file->name);
247
 
        end= strend(buff);
248
 
        if (end != buff && end[-1] == FN_LIBCHAR)
249
 
          end[-1]= 0;                           // Remove end FN_LIBCHAR
250
 
        if (stat(buff, file->mystat))
251
 
               continue;
252
 
       }
253
 
#endif
254
 
      if (!S_ISDIR(file->mystat->st_mode))
255
 
        continue;
256
 
 
257
 
      file_name_len= filename_to_tablename(file->name, uname, sizeof(uname));
258
 
      if (wild && wild_compare(uname, wild, 0))
259
 
        continue;
260
 
      if (!(file_name= 
261
 
            thd->make_lex_string(file_name, uname, file_name_len, true)))
262
 
      {
263
 
        my_dirend(dirp);
264
 
        return(FIND_FILES_OOM);
265
 
      }
266
 
    }
267
 
    else
268
 
    {
269
 
        // Return only .frm files which aren't temp files.
270
 
      if (my_strcasecmp(system_charset_info, ext=fn_rext(file->name),reg_ext) ||
271
 
          is_prefix(file->name, tmp_file_prefix))
272
 
        continue;
273
 
      *ext=0;
274
 
      file_name_len= filename_to_tablename(file->name, uname, sizeof(uname));
275
 
      if (wild)
276
 
      {
277
 
        if (lower_case_table_names)
278
 
        {
279
 
          if (wild_case_compare(files_charset_info, uname, wild))
280
 
            continue;
281
 
        }
282
 
        else if (wild_compare(uname, wild, 0))
283
 
          continue;
284
 
      }
285
 
    }
286
 
    if (!(file_name= 
287
 
          thd->make_lex_string(file_name, uname, file_name_len, true)) ||
288
 
        files->push_back(file_name))
289
 
    {
290
 
      my_dirend(dirp);
291
 
      return(FIND_FILES_OOM);
292
 
    }
293
 
  }
294
 
  my_dirend(dirp);
295
 
 
296
 
  return(FIND_FILES_OK);
297
 
}
298
 
 
299
 
 
300
 
bool
301
 
mysqld_show_create(THD *thd, TABLE_LIST *table_list)
302
 
{
303
 
  Protocol *protocol= thd->protocol;
 
122
 
 
123
bool drizzled_show_create(Session *session, TableList *table_list, bool is_if_not_exists)
 
124
{
304
125
  char buff[2048];
305
126
  String buffer(buff, sizeof(buff), system_charset_info);
306
127
 
307
128
  /* Only one table for now, but VIEW can involve several tables */
308
 
  if (open_normal_and_derived_tables(thd, table_list, 0))
 
129
  if (session->openTables(table_list))
309
130
  {
310
 
    if (thd->is_error() && thd->main_da.sql_errno() != ER_VIEW_INVALID)
311
 
      return(true);
 
131
    if (session->is_error())
 
132
      return true;
312
133
 
313
134
    /*
314
135
      Clear all messages with 'error' level status and
315
 
      issue a warning with 'warning' level status in 
 
136
      issue a warning with 'warning' level status in
316
137
      case of invalid view and last error is ER_VIEW_INVALID
317
138
    */
318
 
    drizzle_reset_errors(thd, true);
319
 
    thd->clear_error();
 
139
    drizzle_reset_errors(session, true);
 
140
    session->clear_error();
320
141
  }
321
142
 
322
143
  buffer.length(0);
323
144
 
324
 
  if (store_create_info(thd, table_list, &buffer, NULL))
325
 
    return(true);
 
145
  if (store_create_info(table_list, &buffer, is_if_not_exists))
 
146
    return true;
326
147
 
327
148
  List<Item> field_list;
328
149
  {
332
153
                                               max(buffer.length(),(uint32_t)1024)));
333
154
  }
334
155
 
335
 
  if (protocol->send_fields(&field_list,
336
 
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
337
 
    return(true);
338
 
  protocol->prepare_for_resend();
339
 
  {
340
 
    if (table_list->schema_table)
341
 
      protocol->store(table_list->schema_table->table_name,
342
 
                      system_charset_info);
343
 
    else
344
 
      protocol->store(table_list->table->alias, system_charset_info);
345
 
  }
346
 
 
347
 
  protocol->store(buffer.ptr(), buffer.length(), buffer.charset());
348
 
 
349
 
  if (protocol->write())
350
 
    return(true);
351
 
 
352
 
  my_eof(thd);
353
 
  return(false);
354
 
}
355
 
 
356
 
bool mysqld_show_create_db(THD *thd, char *dbname,
357
 
                           HA_CREATE_INFO *create_info)
358
 
{
359
 
  char buff[2048];
360
 
  String buffer(buff, sizeof(buff), system_charset_info);
361
 
  Protocol *protocol=thd->protocol;
362
 
 
363
 
  if (store_db_create_info(thd, dbname, &buffer, create_info))
364
 
  {
365
 
    /* 
366
 
      This assumes that the only reason for which store_db_create_info()
367
 
      can fail is incorrect database name (which is the case now).
368
 
    */
369
 
    my_error(ER_BAD_DB_ERROR, MYF(0), dbname);
370
 
    return(true);    
 
156
  if (session->client->sendFields(&field_list))
 
157
    return true;
 
158
  {
 
159
    session->client->store(table_list->table->alias);
 
160
  }
 
161
 
 
162
  session->client->store(buffer.ptr(), buffer.length());
 
163
 
 
164
  if (session->client->flush())
 
165
    return true;
 
166
 
 
167
  session->my_eof();
 
168
  return false;
 
169
}
 
170
 
 
171
/**
 
172
  Get a CREATE statement for a given database.
 
173
 
 
174
  The database is identified by its name, passed as @c dbname parameter.
 
175
  The name should be encoded using the system character set (UTF8 currently).
 
176
 
 
177
  Resulting statement is stored in the string pointed by @c buffer. The string
 
178
  is emptied first and its character set is set to the system character set.
 
179
 
 
180
  If is_if_not_exists is set, then
 
181
  the resulting CREATE statement contains "IF NOT EXISTS" clause. Other flags
 
182
  in @c create_options are ignored.
 
183
 
 
184
  @param  session           The current thread instance.
 
185
  @param  dbname        The name of the database.
 
186
  @param  buffer        A String instance where the statement is stored.
 
187
  @param  create_info   If not NULL, the options member influences the resulting
 
188
                        CRATE statement.
 
189
 
 
190
  @returns true if errors are detected, false otherwise.
 
191
*/
 
192
 
 
193
static bool store_db_create_info(SchemaIdentifier &schema_identifier, string &buffer, bool if_not_exists)
 
194
{
 
195
  message::Schema schema;
 
196
 
 
197
  bool found= plugin::StorageEngine::getSchemaDefinition(schema_identifier, schema);
 
198
  if (not found)
 
199
    return false;
 
200
 
 
201
  buffer.append("CREATE DATABASE ");
 
202
 
 
203
  if (if_not_exists)
 
204
    buffer.append("IF NOT EXISTS ");
 
205
 
 
206
  buffer.append("`");
 
207
  buffer.append(schema.name());
 
208
  buffer.append("`");
 
209
 
 
210
  if (schema.has_collation())
 
211
  {
 
212
    buffer.append(" COLLATE = ");
 
213
    buffer.append(schema.collation());
 
214
  }
 
215
 
 
216
  return true;
 
217
}
 
218
 
 
219
bool mysqld_show_create_db(Session &session, SchemaIdentifier &schema_identifier, bool if_not_exists)
 
220
{
 
221
  message::Schema schema_message;
 
222
  string buffer;
 
223
 
 
224
  if (not plugin::StorageEngine::getSchemaDefinition(schema_identifier, schema_message))
 
225
  {
 
226
    /*
 
227
      This assumes that the only reason for which store_db_create_info()
 
228
      can fail is incorrect database name (which is the case now).
 
229
    */
 
230
    my_error(ER_BAD_DB_ERROR, MYF(0), schema_identifier.getSQLPath().c_str());
 
231
    return true;
 
232
  }
 
233
 
 
234
  if (not store_db_create_info(schema_identifier, buffer, if_not_exists))
 
235
  {
 
236
    /*
 
237
      This assumes that the only reason for which store_db_create_info()
 
238
      can fail is incorrect database name (which is the case now).
 
239
    */
 
240
    my_error(ER_BAD_DB_ERROR, MYF(0), schema_identifier.getSQLPath().c_str());
 
241
    return true;
371
242
  }
372
243
 
373
244
  List<Item> field_list;
374
245
  field_list.push_back(new Item_empty_string("Database",NAME_CHAR_LEN));
375
246
  field_list.push_back(new Item_empty_string("Create Database",1024));
376
247
 
377
 
  if (protocol->send_fields(&field_list,
378
 
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
379
 
    return(true);
380
 
 
381
 
  protocol->prepare_for_resend();
382
 
  protocol->store(dbname, strlen(dbname), system_charset_info);
383
 
  protocol->store(buffer.ptr(), buffer.length(), buffer.charset());
384
 
 
385
 
  if (protocol->write())
386
 
    return(true);
387
 
  my_eof(thd);
388
 
  return(false);
389
 
}
390
 
 
391
 
 
392
 
 
393
 
/****************************************************************************
394
 
  Return only fields for API mysql_list_fields
395
 
  Use "show table wildcard" in mysql instead of this
396
 
****************************************************************************/
397
 
 
398
 
void
399
 
mysqld_list_fields(THD *thd, TABLE_LIST *table_list, const char *wild)
400
 
{
401
 
  TABLE *table;
402
 
 
403
 
  if (open_normal_and_derived_tables(thd, table_list, 0))
404
 
    return;
405
 
  table= table_list->table;
406
 
 
407
 
  List<Item> field_list;
408
 
 
409
 
  Field **ptr,*field;
410
 
  for (ptr=table->field ; (field= *ptr); ptr++)
411
 
  {
412
 
    if (!wild || !wild[0] || 
413
 
        !wild_case_compare(system_charset_info, field->field_name,wild))
414
 
    {
415
 
      field_list.push_back(new Item_field(field));
416
 
    }
417
 
  }
418
 
  restore_record(table, s->default_values);              // Get empty record
419
 
  table->use_all_columns();
420
 
  if (thd->protocol->send_fields(&field_list, Protocol::SEND_DEFAULTS))
421
 
    return;
422
 
  my_eof(thd);
423
 
  return;
424
 
}
425
 
 
426
 
 
427
 
/*
428
 
  Go through all character combinations and ensure that sql_lex.cc can
429
 
  parse it as an identifier.
430
 
 
431
 
  SYNOPSIS
432
 
  require_quotes()
433
 
  name                  attribute name
434
 
  name_length           length of name
435
 
 
436
 
  RETURN
437
 
    #   Pointer to conflicting character
438
 
    0   No conflicting character
439
 
*/
440
 
 
441
 
static const char *require_quotes(const char *name, uint name_length)
442
 
{
443
 
  uint length;
444
 
  bool pure_digit= true;
445
 
  const char *end= name + name_length;
446
 
 
447
 
  for (; name < end ; name++)
448
 
  {
449
 
    uchar chr= (uchar) *name;
450
 
    length= my_mbcharlen(system_charset_info, chr);
451
 
    if (length == 1 && !system_charset_info->ident_map[chr])
452
 
      return name;
453
 
    if (length == 1 && (chr < '0' || chr > '9'))
454
 
      pure_digit= false;
455
 
  }
456
 
  if (pure_digit)
457
 
    return name;
458
 
  return 0;
459
 
}
460
 
 
461
 
 
462
 
/*
463
 
  Quote the given identifier if needed and append it to the target string.
464
 
  If the given identifier is empty, it will be quoted.
465
 
 
466
 
  SYNOPSIS
467
 
  append_identifier()
468
 
  thd                   thread handler
469
 
  packet                target string
470
 
  name                  the identifier to be appended
471
 
  name_length           length of the appending identifier
472
 
*/
473
 
 
474
 
void
475
 
append_identifier(THD *thd, String *packet, const char *name, uint length)
476
 
{
477
 
  const char *name_end;
478
 
  char quote_char;
479
 
  int q= get_quote_char_for_identifier(thd, name, length);
480
 
 
481
 
  if (q == EOF)
482
 
  {
483
 
    packet->append(name, length, packet->charset());
484
 
    return;
485
 
  }
486
 
 
487
 
  /*
488
 
    The identifier must be quoted as it includes a quote character or
489
 
   it's a keyword
490
 
  */
491
 
 
492
 
  VOID(packet->reserve(length*2 + 2));
493
 
  quote_char= (char) q;
494
 
  packet->append(&quote_char, 1, system_charset_info);
495
 
 
496
 
  for (name_end= name+length ; name < name_end ; name+= length)
497
 
  {
498
 
    uchar chr= (uchar) *name;
499
 
    length= my_mbcharlen(system_charset_info, chr);
500
 
    /*
501
 
      my_mbcharlen can return 0 on a wrong multibyte
502
 
      sequence. It is possible when upgrading from 4.0,
503
 
      and identifier contains some accented characters.
504
 
      The manual says it does not work. So we'll just
505
 
      change length to 1 not to hang in the endless loop.
506
 
    */
507
 
    if (!length)
508
 
      length= 1;
509
 
    if (length == 1 && chr == (uchar) quote_char)
510
 
      packet->append(&quote_char, 1, system_charset_info);
511
 
    packet->append(name, length, system_charset_info);
512
 
  }
513
 
  packet->append(&quote_char, 1, system_charset_info);
514
 
}
515
 
 
 
248
  if (session.client->sendFields(&field_list))
 
249
    return true;
 
250
 
 
251
  session.client->store(schema_message.name());
 
252
  session.client->store(buffer);
 
253
 
 
254
  if (session.client->flush())
 
255
    return true;
 
256
 
 
257
  session.my_eof();
 
258
 
 
259
  return false;
 
260
}
516
261
 
517
262
/*
518
263
  Get the quote character for displaying an identifier.
519
264
 
520
265
  SYNOPSIS
521
266
    get_quote_char_for_identifier()
522
 
    thd         Thread handler
523
 
    name        name to quote
524
 
    length      length of name
525
267
 
526
268
  IMPLEMENTATION
527
269
    Force quoting in the following cases:
537
279
    #     Quote character
538
280
*/
539
281
 
540
 
int get_quote_char_for_identifier(THD *thd, const char *name, uint length)
541
 
{
542
 
  if (length &&
543
 
      !is_keyword(name,length) &&
544
 
      !require_quotes(name, length) &&
545
 
      !(thd->options & OPTION_QUOTE_SHOW_CREATE))
546
 
    return EOF;
547
 
  return '"';
548
 
}
549
 
 
550
 
 
551
 
/* Append directory name (if exists) to CREATE INFO */
552
 
 
553
 
static void append_directory(THD *thd __attribute__((unused)),
554
 
                             String *packet, const char *dir_type,
555
 
                             const char *filename)
556
 
{
557
 
  if (filename)
558
 
  {
559
 
    uint length= dirname_length(filename);
560
 
    packet->append(' ');
561
 
    packet->append(dir_type);
562
 
    packet->append(STRING_WITH_LEN(" DIRECTORY='"));
563
 
    packet->append(filename, length);
564
 
    packet->append('\'');
565
 
  }
 
282
int get_quote_char_for_identifier()
 
283
{
 
284
  return '`';
566
285
}
567
286
 
568
287
 
569
288
#define LIST_PROCESS_HOST_LEN 64
570
289
 
571
 
static bool get_field_default_value(THD *thd __attribute__((unused)),
572
 
                                    Field *timestamp_field,
 
290
static bool get_field_default_value(Field *timestamp_field,
573
291
                                    Field *field, String *def_value,
574
292
                                    bool quoted)
575
293
{
576
294
  bool has_default;
577
295
  bool has_now_default;
578
296
 
579
 
  /* 
 
297
  /*
580
298
     We are using CURRENT_TIMESTAMP instead of NOW because it is
581
299
     more standard
582
300
  */
583
301
  has_now_default= (timestamp_field == field &&
584
302
                    field->unireg_check != Field::TIMESTAMP_UN_FIELD);
585
 
    
 
303
 
586
304
  has_default= (field->type() != DRIZZLE_TYPE_BLOB &&
587
305
                !(field->flags & NO_DEFAULT_VALUE_FLAG) &&
588
 
                field->unireg_check != Field::NEXT_NUMBER
589
 
                  && has_now_default);
 
306
                field->unireg_check != Field::NEXT_NUMBER);
590
307
 
591
308
  def_value->length(0);
592
309
  if (has_default)
601
318
      if (type.length())
602
319
      {
603
320
        String def_val;
604
 
        uint dummy_errors;
 
321
        uint32_t dummy_errors;
605
322
        /* convert to system_charset_info == utf8 */
606
323
        def_val.copy(type.ptr(), type.length(), field->charset(),
607
324
                     system_charset_info, &dummy_errors);
616
333
    else if (field->maybe_null() && quoted)
617
334
      def_value->append(STRING_WITH_LEN("NULL"));    // Null as default
618
335
    else
619
 
      return 0;
620
 
 
 
336
      return false;
621
337
  }
622
338
  return has_default;
623
339
}
627
343
 
628
344
  SYNOPSIS
629
345
    store_create_info()
630
 
    thd               The thread
631
346
    table_list        A list containing one table to write statement
632
347
                      for.
633
348
    packet            Pointer to a string where statement will be
634
349
                      written.
635
 
    create_info_arg   Pointer to create information that can be used
636
 
                      to tailor the format of the statement.  Can be
637
 
                      NULL, in which case only SQL_MODE is considered
638
 
                      when building the statement.
639
 
  
 
350
 
640
351
  NOTE
641
352
    Currently always return 0, but might return error code in the
642
353
    future.
643
 
    
 
354
 
644
355
  RETURN
645
356
    0       OK
646
357
 */
647
358
 
648
 
int store_create_info(THD *thd, TABLE_LIST *table_list, String *packet,
649
 
                      HA_CREATE_INFO *create_info_arg)
 
359
int store_create_info(TableList *table_list, String *packet, bool is_if_not_exists)
650
360
{
651
361
  List<Item> field_list;
652
 
  char tmp[MAX_FIELD_WIDTH], *for_str, buff[128], def_value_buf[MAX_FIELD_WIDTH];
 
362
  char tmp[MAX_FIELD_WIDTH], *for_str, def_value_buf[MAX_FIELD_WIDTH];
653
363
  const char *alias;
 
364
  string buff;
654
365
  String type(tmp, sizeof(tmp), system_charset_info);
655
366
  String def_value(def_value_buf, sizeof(def_value_buf), system_charset_info);
656
367
  Field **ptr,*field;
657
 
  uint primary_key;
658
 
  KEY *key_info;
659
 
  TABLE *table= table_list->table;
660
 
  handler *file= table->file;
661
 
  TABLE_SHARE *share= table->s;
 
368
  uint32_t primary_key;
 
369
  KeyInfo *key_info;
 
370
  Table *table= table_list->table;
 
371
  Cursor *cursor= table->cursor;
662
372
  HA_CREATE_INFO create_info;
663
 
  bool show_table_options= false;
664
373
  my_bitmap_map *old_map;
665
374
 
666
 
  restore_record(table, s->default_values); // Get empty record
 
375
  table->restoreRecordAsDefault(); // Get empty record
667
376
 
668
 
  if (share->tmp_table)
 
377
  if (table->getShare()->tmp_table)
669
378
    packet->append(STRING_WITH_LEN("CREATE TEMPORARY TABLE "));
670
379
  else
671
380
    packet->append(STRING_WITH_LEN("CREATE TABLE "));
672
 
  if (create_info_arg &&
673
 
      (create_info_arg->options & HA_LEX_CREATE_IF_NOT_EXISTS))
 
381
  if (is_if_not_exists)
674
382
    packet->append(STRING_WITH_LEN("IF NOT EXISTS "));
675
 
  if (table_list->schema_table)
676
 
    alias= table_list->schema_table->table_name;
677
 
  else
678
 
  {
679
 
    if (lower_case_table_names == 2)
680
 
      alias= table->alias;
681
 
    else
682
 
    {
683
 
      alias= share->table_name.str;
684
 
    }
685
 
  }
686
 
  append_identifier(thd, packet, alias, strlen(alias));
 
383
  alias= table->getShare()->getTableName();
 
384
 
 
385
  packet->append_identifier(alias, strlen(alias));
687
386
  packet->append(STRING_WITH_LEN(" (\n"));
688
387
  /*
689
388
    We need this to get default values from the table
690
389
    We have to restore the read_set if we are called from insert in case
691
390
    of row based replication.
692
391
  */
693
 
  old_map= tmp_use_all_columns(table, table->read_set);
 
392
  old_map= table->use_all_columns(table->read_set);
694
393
 
695
394
  for (ptr=table->field ; (field= *ptr); ptr++)
696
395
  {
697
 
    uint flags = field->flags;
 
396
    uint32_t flags = field->flags;
698
397
 
699
398
    if (ptr != table->field)
700
399
      packet->append(STRING_WITH_LEN(",\n"));
701
400
 
702
401
    packet->append(STRING_WITH_LEN("  "));
703
 
    append_identifier(thd,packet,field->field_name, strlen(field->field_name));
 
402
    packet->append_identifier(field->field_name, strlen(field->field_name));
704
403
    packet->append(' ');
705
404
    // check for surprises from the previous call to Field::sql_type()
706
405
    if (type.ptr() != tmp)
713
412
 
714
413
    if (field->has_charset())
715
414
    {
716
 
      if (field->charset() != share->table_charset)
717
 
      {
718
 
        packet->append(STRING_WITH_LEN(" CHARACTER SET "));
719
 
        packet->append(field->charset()->csname);
720
 
      }
721
 
      /* 
722
 
        For string types dump collation name only if 
723
 
        collation is not primary for the given charset
 
415
      /*
 
416
        For string types dump collation name only if
 
417
        collation is not primary for the given charset
724
418
      */
725
419
      if (!(field->charset()->state & MY_CS_PRIMARY))
726
420
      {
727
 
        packet->append(STRING_WITH_LEN(" COLLATE "));
728
 
        packet->append(field->charset()->name);
 
421
        packet->append(STRING_WITH_LEN(" COLLATE "));
 
422
        packet->append(field->charset()->name);
729
423
      }
730
424
    }
731
425
 
749
443
      if (column_format)
750
444
      {
751
445
        packet->append(STRING_WITH_LEN(" /*!"));
752
 
        packet->append(STRING_WITH_LEN(DRIZZLE_VERSION_TABLESPACE_IN_FRM_STR));
753
446
        packet->append(STRING_WITH_LEN(" COLUMN_FORMAT"));
754
447
        if (column_format == COLUMN_FORMAT_TYPE_FIXED)
755
448
          packet->append(STRING_WITH_LEN(" FIXED */"));
757
450
          packet->append(STRING_WITH_LEN(" DYNAMIC */"));
758
451
      }
759
452
    }
760
 
    if (get_field_default_value(thd, table->timestamp_field,
761
 
                                field, &def_value, 1))
 
453
    if (get_field_default_value(table->timestamp_field, field, &def_value, 1))
762
454
    {
763
455
      packet->append(STRING_WITH_LEN(" DEFAULT "));
764
456
      packet->append(def_value.ptr(), def_value.length(), system_charset_info);
780
472
  key_info= table->key_info;
781
473
  memset(&create_info, 0, sizeof(create_info));
782
474
  /* Allow update_create_info to update row type */
783
 
  create_info.row_type= share->row_type;
784
 
  file->update_create_info(&create_info);
785
 
  primary_key= share->primary_key;
 
475
  create_info.row_type= table->getShare()->row_type;
 
476
  cursor->update_create_info(&create_info);
 
477
  primary_key= table->getShare()->primary_key;
786
478
 
787
 
  for (uint i=0 ; i < share->keys ; i++,key_info++)
 
479
  for (uint32_t i=0 ; i < table->getShare()->keys ; i++,key_info++)
788
480
  {
789
 
    KEY_PART_INFO *key_part= key_info->key_part;
 
481
    KeyPartInfo *key_part= key_info->key_part;
790
482
    bool found_primary=0;
791
483
    packet->append(STRING_WITH_LEN(",\n  "));
792
484
 
793
 
    if (i == primary_key && !strcmp(key_info->name, primary_key_name))
 
485
    if (i == primary_key && is_primary_key(key_info))
794
486
    {
795
487
      found_primary=1;
796
488
      /*
805
497
      packet->append(STRING_WITH_LEN("KEY "));
806
498
 
807
499
    if (!found_primary)
808
 
     append_identifier(thd, packet, key_info->name, strlen(key_info->name));
 
500
     packet->append_identifier(key_info->name, strlen(key_info->name));
809
501
 
810
502
    packet->append(STRING_WITH_LEN(" ("));
811
503
 
812
 
    for (uint j=0 ; j < key_info->key_parts ; j++,key_part++)
 
504
    for (uint32_t j=0 ; j < key_info->key_parts ; j++,key_part++)
813
505
    {
814
506
      if (j)
815
507
        packet->append(',');
816
508
 
817
509
      if (key_part->field)
818
 
        append_identifier(thd,packet,key_part->field->field_name,
819
 
                          strlen(key_part->field->field_name));
 
510
        packet->append_identifier(key_part->field->field_name,
 
511
                                  strlen(key_part->field->field_name));
820
512
      if (key_part->field &&
821
513
          (key_part->length !=
822
514
           table->field[key_part->fieldnr-1]->key_length()))
823
515
      {
824
 
        char *end;
825
 
        buff[0] = '(';
826
 
        end= int10_to_str((long) key_part->length /
827
 
                          key_part->field->charset()->mbmaxlen,
828
 
                          buff + 1,10);
829
 
        *end++ = ')';
830
 
        packet->append(buff,(uint) (end-buff));
 
516
        buff.assign("(");
 
517
        buff.append(to_string((int32_t) key_part->length /
 
518
                              key_part->field->charset()->mbmaxlen));
 
519
        buff.append(")");
 
520
        packet->append(buff.c_str(), buff.length());
831
521
      }
832
522
    }
833
523
    packet->append(')');
834
 
    store_key_options(thd, packet, table, key_info);
 
524
    store_key_options(packet, table, key_info);
835
525
  }
836
526
 
837
527
  /*
839
529
    to the CREATE TABLE statement
840
530
  */
841
531
 
842
 
  if ((for_str= file->get_foreign_key_create_info()))
 
532
  if ((for_str= cursor->get_foreign_key_create_info()))
843
533
  {
844
534
    packet->append(for_str, strlen(for_str));
845
 
    file->free_foreign_key_create_info(for_str);
 
535
    cursor->free_foreign_key_create_info(for_str);
846
536
  }
847
537
 
848
538
  packet->append(STRING_WITH_LEN("\n)"));
849
539
  {
850
 
    show_table_options= true;
851
540
    /*
852
541
      Get possible table space definitions and append them
853
542
      to the CREATE TABLE statement
854
543
    */
855
544
 
856
 
    /*
857
 
      IF   check_create_info
858
 
      THEN add ENGINE only if it was used when creating the table
859
 
    */
860
 
    if (!create_info_arg ||
861
 
        (create_info_arg->used_fields & HA_CREATE_USED_ENGINE))
862
 
    {
863
 
      packet->append(STRING_WITH_LEN(" ENGINE="));
864
 
      packet->append(file->table_type());
865
 
    }
866
 
 
867
 
    /*
868
 
      Add AUTO_INCREMENT=... if there is an AUTO_INCREMENT column,
869
 
      and NEXT_ID > 1 (the default).  We must not print the clause
870
 
      for engines that do not support this as it would break the
871
 
      import of dumps, but as of this writing, the test for whether
872
 
      AUTO_INCREMENT columns are allowed and wether AUTO_INCREMENT=...
873
 
      is supported is identical, !(file->table_flags() & HA_NO_AUTO_INCREMENT))
874
 
      Because of that, we do not explicitly test for the feature,
875
 
      but may extrapolate its existence from that of an AUTO_INCREMENT column.
876
 
    */
877
 
 
878
 
    if (create_info.auto_increment_value > 1)
879
 
    {
880
 
      char *end;
881
 
      packet->append(STRING_WITH_LEN(" AUTO_INCREMENT="));
882
 
      end= int64_t10_to_str(create_info.auto_increment_value, buff,10);
883
 
      packet->append(buff, (uint) (end - buff));
884
 
    }
885
 
 
886
 
    
887
 
    if (share->table_charset)
888
 
    {
889
 
      /*
890
 
        IF   check_create_info
891
 
        THEN add DEFAULT CHARSET only if it was used when creating the table
892
 
      */
893
 
      if (!create_info_arg ||
894
 
          (create_info_arg->used_fields & HA_CREATE_USED_DEFAULT_CHARSET))
895
 
      {
896
 
        packet->append(STRING_WITH_LEN(" DEFAULT CHARSET="));
897
 
        packet->append(share->table_charset->csname);
898
 
        if (!(share->table_charset->state & MY_CS_PRIMARY))
899
 
        {
900
 
          packet->append(STRING_WITH_LEN(" COLLATE="));
901
 
          packet->append(table->s->table_charset->name);
902
 
        }
903
 
      }
904
 
    }
905
 
 
906
 
    if (share->min_rows)
907
 
    {
908
 
      char *end;
909
 
      packet->append(STRING_WITH_LEN(" MIN_ROWS="));
910
 
      end= int64_t10_to_str(share->min_rows, buff, 10);
911
 
      packet->append(buff, (uint) (end- buff));
912
 
    }
913
 
 
914
 
    if (share->max_rows && !table_list->schema_table)
915
 
    {
916
 
      char *end;
917
 
      packet->append(STRING_WITH_LEN(" MAX_ROWS="));
918
 
      end= int64_t10_to_str(share->max_rows, buff, 10);
919
 
      packet->append(buff, (uint) (end - buff));
920
 
    }
921
 
 
922
 
    if (share->avg_row_length)
923
 
    {
924
 
      char *end;
925
 
      packet->append(STRING_WITH_LEN(" AVG_ROW_LENGTH="));
926
 
      end= int64_t10_to_str(share->avg_row_length, buff,10);
927
 
      packet->append(buff, (uint) (end - buff));
928
 
    }
929
 
 
930
 
    if (share->db_create_options & HA_OPTION_PACK_KEYS)
931
 
      packet->append(STRING_WITH_LEN(" PACK_KEYS=1"));
932
 
    if (share->db_create_options & HA_OPTION_NO_PACK_KEYS)
933
 
      packet->append(STRING_WITH_LEN(" PACK_KEYS=0"));
934
 
    /* We use CHECKSUM, instead of TABLE_CHECKSUM, for backward compability */
935
 
    if (share->db_create_options & HA_OPTION_CHECKSUM)
936
 
      packet->append(STRING_WITH_LEN(" CHECKSUM=1"));
937
 
    if (share->page_checksum != HA_CHOICE_UNDEF)
938
 
    {
939
 
      packet->append(STRING_WITH_LEN(" PAGE_CHECKSUM="));
940
 
      packet->append(ha_choice_values[(uint) share->page_checksum], 1);
941
 
    }
942
 
    if (share->db_create_options & HA_OPTION_DELAY_KEY_WRITE)
943
 
      packet->append(STRING_WITH_LEN(" DELAY_KEY_WRITE=1"));
 
545
    /* 
 
546
      We should always store engine since we will now be 
 
547
      making sure engines accept options (aka... no
 
548
      dangling arguments for engines.
 
549
    */
 
550
    packet->append(STRING_WITH_LEN(" ENGINE="));
 
551
    packet->append(cursor->getEngine()->getName().c_str());
 
552
 
 
553
    size_t num_engine_options= table->getShare()->getTableProto()->engine().options_size();
 
554
    for (size_t x= 0; x < num_engine_options; ++x)
 
555
    {
 
556
      const message::Engine::Option &option= table->getShare()->getTableProto()->engine().options(x);
 
557
      packet->append(" ");
 
558
      packet->append(option.name().c_str());
 
559
      packet->append("=");
 
560
      append_unescaped(packet, option.state().c_str(), option.state().length());
 
561
    }
 
562
 
 
563
#if 0
944
564
    if (create_info.row_type != ROW_TYPE_DEFAULT)
945
565
    {
946
566
      packet->append(STRING_WITH_LEN(" ROW_FORMAT="));
947
 
      packet->append(ha_row_type[(uint) create_info.row_type]);
948
 
    }
949
 
    if (share->transactional != HA_CHOICE_UNDEF)
950
 
    {
951
 
      packet->append(STRING_WITH_LEN(" TRANSACTIONAL="));
952
 
      packet->append(ha_choice_values[(uint) share->transactional], 1);
953
 
    }
954
 
    if (table->s->key_block_size)
955
 
    {
956
 
      char *end;
957
 
      packet->append(STRING_WITH_LEN(" KEY_BLOCK_SIZE="));
958
 
      end= int64_t10_to_str(table->s->key_block_size, buff, 10);
959
 
      packet->append(buff, (uint) (end - buff));
960
 
    }
961
 
    if (share->block_size)
962
 
    {
963
 
      char *end;
 
567
      packet->append(ha_row_type[(uint32_t) create_info.row_type]);
 
568
    }
 
569
#endif
 
570
    if (table->getShare()->block_size)
 
571
    {
964
572
      packet->append(STRING_WITH_LEN(" BLOCK_SIZE="));
965
 
      end= int64_t10_to_str(share->block_size, buff,10);
966
 
      packet->append(buff, (uint) (end - buff));
 
573
      buff= to_string(table->getShare()->block_size);
 
574
      packet->append(buff.c_str(), buff.length());
967
575
    }
968
 
    table->file->append_create_info(packet);
969
 
    if (share->comment.length)
 
576
    table->cursor->append_create_info(packet);
 
577
    if (table->getMutableShare()->hasComment() && table->getMutableShare()->getCommentLength())
970
578
    {
971
579
      packet->append(STRING_WITH_LEN(" COMMENT="));
972
 
      append_unescaped(packet, share->comment.str, share->comment.length);
973
 
    }
974
 
    if (share->connect_string.length)
975
 
    {
976
 
      packet->append(STRING_WITH_LEN(" CONNECTION="));
977
 
      append_unescaped(packet, share->connect_string.str, share->connect_string.length);
978
 
    }
979
 
    append_directory(thd, packet, "DATA",  create_info.data_file_name);
980
 
    append_directory(thd, packet, "INDEX", create_info.index_file_name);
 
580
      append_unescaped(packet, table->getMutableShare()->getComment(),
 
581
                       table->getMutableShare()->getCommentLength());
 
582
    }
981
583
  }
982
 
  tmp_restore_column_map(table->read_set, old_map);
 
584
  table->restore_column_map(old_map);
983
585
  return(0);
984
586
}
985
587
 
986
 
/**
987
 
  Get a CREATE statement for a given database.
988
 
 
989
 
  The database is identified by its name, passed as @c dbname parameter.
990
 
  The name should be encoded using the system character set (UTF8 currently).
991
 
 
992
 
  Resulting statement is stored in the string pointed by @c buffer. The string
993
 
  is emptied first and its character set is set to the system character set.
994
 
 
995
 
  If HA_LEX_CREATE_IF_NOT_EXISTS flag is set in @c create_info->options, then
996
 
  the resulting CREATE statement contains "IF NOT EXISTS" clause. Other flags
997
 
  in @c create_options are ignored.
998
 
 
999
 
  @param  thd           The current thread instance.
1000
 
  @param  dbname        The name of the database.
1001
 
  @param  buffer        A String instance where the statement is stored.
1002
 
  @param  create_info   If not NULL, the options member influences the resulting 
1003
 
                        CRATE statement.
1004
 
 
1005
 
  @returns true if errors are detected, false otherwise.
1006
 
*/
1007
 
 
1008
 
bool store_db_create_info(THD *thd, const char *dbname, String *buffer,
1009
 
                          HA_CREATE_INFO *create_info)
1010
 
{
1011
 
  HA_CREATE_INFO create;
1012
 
  uint create_options = create_info ? create_info->options : 0;
1013
 
 
1014
 
  if (!my_strcasecmp(system_charset_info, dbname,
1015
 
                     INFORMATION_SCHEMA_NAME.str))
1016
 
  {
1017
 
    dbname= INFORMATION_SCHEMA_NAME.str;
1018
 
    create.default_table_charset= system_charset_info;
1019
 
  }
1020
 
  else
1021
 
  {
1022
 
    if (check_db_dir_existence(dbname))
1023
 
      return(true);
1024
 
 
1025
 
    load_db_opt_by_name(thd, dbname, &create);
1026
 
  }
1027
 
 
1028
 
  buffer->length(0);
1029
 
  buffer->free();
1030
 
  buffer->set_charset(system_charset_info);
1031
 
  buffer->append(STRING_WITH_LEN("CREATE DATABASE "));
1032
 
 
1033
 
  if (create_options & HA_LEX_CREATE_IF_NOT_EXISTS)
1034
 
    buffer->append(STRING_WITH_LEN("/*!32312 IF NOT EXISTS*/ "));
1035
 
 
1036
 
  append_identifier(thd, buffer, dbname, strlen(dbname));
1037
 
 
1038
 
  if (create.default_table_charset)
1039
 
  {
1040
 
    buffer->append(STRING_WITH_LEN(" /*!40100"));
1041
 
    buffer->append(STRING_WITH_LEN(" DEFAULT CHARACTER SET "));
1042
 
    buffer->append(create.default_table_charset->csname);
1043
 
    if (!(create.default_table_charset->state & MY_CS_PRIMARY))
1044
 
    {
1045
 
      buffer->append(STRING_WITH_LEN(" COLLATE "));
1046
 
      buffer->append(create.default_table_charset->name);
1047
 
    }
1048
 
    buffer->append(STRING_WITH_LEN(" */"));
1049
 
  }
1050
 
 
1051
 
  return(false);
1052
 
}
1053
 
 
1054
 
static void store_key_options(THD *thd __attribute__((unused)),
1055
 
                              String *packet, TABLE *table,
1056
 
                              KEY *key_info)
1057
 
{
1058
 
  char *end, buff[32];
1059
 
 
 
588
static void store_key_options(String *packet, Table *, KeyInfo *key_info)
 
589
{
1060
590
  if (key_info->algorithm == HA_KEY_ALG_BTREE)
1061
591
    packet->append(STRING_WITH_LEN(" USING BTREE"));
1062
592
 
1063
593
  if (key_info->algorithm == HA_KEY_ALG_HASH)
1064
594
    packet->append(STRING_WITH_LEN(" USING HASH"));
1065
595
 
1066
 
  if ((key_info->flags & HA_USES_BLOCK_SIZE) &&
1067
 
      table->s->key_block_size != key_info->block_size)
1068
 
  {
1069
 
    packet->append(STRING_WITH_LEN(" KEY_BLOCK_SIZE="));
1070
 
    end= int64_t10_to_str(key_info->block_size, buff, 10);
1071
 
    packet->append(buff, (uint) (end - buff));
1072
 
  }
1073
 
 
1074
 
  assert(test(key_info->flags & HA_USES_COMMENT) == 
 
596
  assert(test(key_info->flags & HA_USES_COMMENT) ==
1075
597
              (key_info->comment.length > 0));
1076
598
  if (key_info->flags & HA_USES_COMMENT)
1077
599
  {
1078
600
    packet->append(STRING_WITH_LEN(" COMMENT "));
1079
 
    append_unescaped(packet, key_info->comment.str, 
 
601
    append_unescaped(packet, key_info->comment.str,
1080
602
                     key_info->comment.length);
1081
603
  }
1082
604
}
1087
609
  returns for each thread: thread id, user, host, db, command, info
1088
610
****************************************************************************/
1089
611
 
1090
 
class thread_info :public ilink {
 
612
class thread_info
 
613
{
 
614
  thread_info();
1091
615
public:
1092
 
  static void *operator new(size_t size)
1093
 
  {
1094
 
    return (void*) sql_alloc((uint) size);
1095
 
  }
1096
 
  static void operator delete(void *ptr __attribute__((unused)),
1097
 
                              size_t size __attribute__((unused)))
1098
 
  { TRASH(ptr, size); }
1099
 
 
1100
 
  ulong thread_id;
 
616
  uint64_t thread_id;
1101
617
  time_t start_time;
1102
 
  uint   command;
1103
 
  const char *user,*host,*db,*proc_info,*state_info;
1104
 
  char *query;
 
618
  uint32_t   command;
 
619
  string user;
 
620
  string host;
 
621
  string db;
 
622
  string proc_info;
 
623
  string state_info;
 
624
  string query;
 
625
  thread_info(uint64_t thread_id_arg,
 
626
              time_t start_time_arg,
 
627
              uint32_t command_arg,
 
628
              const string &user_arg,
 
629
              const string &host_arg,
 
630
              const string &db_arg,
 
631
              const string &proc_info_arg,
 
632
              const string &state_info_arg,
 
633
              const string &query_arg)
 
634
    : thread_id(thread_id_arg), start_time(start_time_arg), command(command_arg),
 
635
      user(user_arg), host(host_arg), db(db_arg), proc_info(proc_info_arg),
 
636
      state_info(state_info_arg), query(query_arg)
 
637
  {}
1105
638
};
1106
639
 
1107
 
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
1108
 
template class I_List<thread_info>;
1109
 
#endif
1110
 
 
1111
 
void mysqld_list_processes(THD *thd,const char *user, bool verbose)
1112
 
{
1113
 
  Item *field;
1114
 
  List<Item> field_list;
1115
 
  I_List<thread_info> thread_infos;
1116
 
  ulong max_query_length= (verbose ? thd->variables.max_allowed_packet :
1117
 
                           PROCESS_LIST_WIDTH);
1118
 
  Protocol *protocol= thd->protocol;
1119
 
 
1120
 
  field_list.push_back(new Item_int("Id", 0, MY_INT32_NUM_DECIMAL_DIGITS));
1121
 
  field_list.push_back(new Item_empty_string("User",16));
1122
 
  field_list.push_back(new Item_empty_string("Host",LIST_PROCESS_HOST_LEN));
1123
 
  field_list.push_back(field=new Item_empty_string("db",NAME_CHAR_LEN));
1124
 
  field->maybe_null=1;
1125
 
  field_list.push_back(new Item_empty_string("Command",16));
1126
 
  field_list.push_back(new Item_return_int("Time",7, DRIZZLE_TYPE_LONG));
1127
 
  field_list.push_back(field=new Item_empty_string("State",30));
1128
 
  field->maybe_null=1;
1129
 
  field_list.push_back(field=new Item_empty_string("Info",max_query_length));
1130
 
  field->maybe_null=1;
1131
 
  if (protocol->send_fields(&field_list,
1132
 
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
1133
 
    return;
1134
 
 
1135
 
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
1136
 
  if (!thd->killed)
1137
 
  {
1138
 
    I_List_iterator<THD> it(threads);
1139
 
    THD *tmp;
1140
 
    while ((tmp=it++))
1141
 
    {
1142
 
      Security_context *tmp_sctx= tmp->security_ctx;
1143
 
      struct st_my_thread_var *mysys_var;
1144
 
      if ((tmp->vio_ok() || tmp->system_thread) && (!user || (tmp_sctx->user && !strcmp(tmp_sctx->user, user))))
1145
 
      {
1146
 
        thread_info *thd_info= new thread_info;
1147
 
 
1148
 
        thd_info->thread_id=tmp->thread_id;
1149
 
        thd_info->user= thd->strdup(tmp_sctx->user ? tmp_sctx->user :
1150
 
                                    (tmp->system_thread ?
1151
 
                                     "system user" : "unauthenticated user"));
1152
 
        thd_info->host= thd->strdup(tmp_sctx->ip);
1153
 
        if ((thd_info->db=tmp->db))             // Safe test
1154
 
          thd_info->db=thd->strdup(thd_info->db);
1155
 
        thd_info->command=(int) tmp->command;
1156
 
        if ((mysys_var= tmp->mysys_var))
1157
 
          pthread_mutex_lock(&mysys_var->mutex);
1158
 
        thd_info->proc_info= (char*) (tmp->killed == THD::KILL_CONNECTION? "Killed" : 0);
1159
 
        thd_info->state_info= (char*) (tmp->net.reading_or_writing ?
1160
 
                                       (tmp->net.reading_or_writing == 2 ?
1161
 
                                        "Writing to net" :
1162
 
                                        thd_info->command == COM_SLEEP ? NullS :
1163
 
                                        "Reading from net") :
1164
 
                                       tmp->proc_info ? tmp->proc_info :
1165
 
                                       tmp->mysys_var &&
1166
 
                                       tmp->mysys_var->current_cond ?
1167
 
                                       "Waiting on cond" : NullS);
1168
 
        if (mysys_var)
1169
 
          pthread_mutex_unlock(&mysys_var->mutex);
1170
 
 
1171
 
        thd_info->start_time= tmp->start_time;
1172
 
        thd_info->query=0;
1173
 
        if (tmp->query)
1174
 
        {
1175
 
          /* 
1176
 
            query_length is always set to 0 when we set query = NULL; see
1177
 
            the comment in sql_class.h why this prevents crashes in possible
1178
 
            races with query_length
1179
 
          */
1180
 
          uint length= min((uint32_t)max_query_length, tmp->query_length);
1181
 
          thd_info->query=(char*) thd->strmake(tmp->query,length);
1182
 
        }
1183
 
        thread_infos.append(thd_info);
1184
 
      }
1185
 
    }
1186
 
  }
1187
 
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
1188
 
 
1189
 
  thread_info *thd_info;
1190
 
  time_t now= my_time(0);
1191
 
  while ((thd_info=thread_infos.get()))
1192
 
  {
1193
 
    protocol->prepare_for_resend();
1194
 
    protocol->store((uint64_t) thd_info->thread_id);
1195
 
    protocol->store(thd_info->user, system_charset_info);
1196
 
    protocol->store(thd_info->host, system_charset_info);
1197
 
    protocol->store(thd_info->db, system_charset_info);
1198
 
    if (thd_info->proc_info)
1199
 
      protocol->store(thd_info->proc_info, system_charset_info);
1200
 
    else
1201
 
      protocol->store(command_name[thd_info->command].str, system_charset_info);
1202
 
    if (thd_info->start_time)
1203
 
      protocol->store((uint32_t) (now - thd_info->start_time));
1204
 
    else
1205
 
      protocol->store_null();
1206
 
    protocol->store(thd_info->state_info, system_charset_info);
1207
 
    protocol->store(thd_info->query, system_charset_info);
1208
 
    if (protocol->write())
1209
 
      break; /* purecov: inspected */
1210
 
  }
1211
 
  my_eof(thd);
1212
 
  return;
1213
 
}
1214
 
 
1215
 
int fill_schema_processlist(THD* thd, TABLE_LIST* tables,
1216
 
                            COND* cond __attribute__((unused)))
1217
 
{
1218
 
  TABLE *table= tables->table;
1219
 
  const CHARSET_INFO * const cs= system_charset_info;
1220
 
  char *user;
1221
 
  time_t now= my_time(0);
1222
 
 
1223
 
  user= NullS;
1224
 
 
1225
 
  VOID(pthread_mutex_lock(&LOCK_thread_count));
1226
 
 
1227
 
  if (!thd->killed)
1228
 
  {
1229
 
    I_List_iterator<THD> it(threads);
1230
 
    THD* tmp;
1231
 
 
1232
 
    while ((tmp= it++))
1233
 
    {
1234
 
      Security_context *tmp_sctx= tmp->security_ctx;
1235
 
      struct st_my_thread_var *mysys_var;
1236
 
      const char *val;
1237
 
 
1238
 
      if ((!tmp->vio_ok() && !tmp->system_thread))
1239
 
        continue;
1240
 
 
1241
 
      restore_record(table, s->default_values);
1242
 
      /* ID */
1243
 
      table->field[0]->store((int64_t) tmp->thread_id, true);
1244
 
      /* USER */
1245
 
      val= tmp_sctx->user ? tmp_sctx->user :
1246
 
            (tmp->system_thread ? "system user" : "unauthenticated user");
1247
 
      table->field[1]->store(val, strlen(val), cs);
1248
 
      /* HOST */
1249
 
      table->field[2]->store(tmp_sctx->ip, strlen(tmp_sctx->ip), cs);
1250
 
      /* DB */
1251
 
      if (tmp->db)
1252
 
      {
1253
 
        table->field[3]->store(tmp->db, strlen(tmp->db), cs);
1254
 
        table->field[3]->set_notnull();
1255
 
      }
1256
 
 
1257
 
      if ((mysys_var= tmp->mysys_var))
1258
 
        pthread_mutex_lock(&mysys_var->mutex);
1259
 
      /* COMMAND */
1260
 
      if ((val= (char *) (tmp->killed == THD::KILL_CONNECTION? "Killed" : 0)))
1261
 
        table->field[4]->store(val, strlen(val), cs);
1262
 
      else
1263
 
        table->field[4]->store(command_name[tmp->command].str,
1264
 
                               command_name[tmp->command].length, cs);
1265
 
      /* DRIZZLE_TIME */
1266
 
      table->field[5]->store((uint32_t)(tmp->start_time ?
1267
 
                                      now - tmp->start_time : 0), true);
1268
 
      /* STATE */
1269
 
      val= (char*) (tmp->net.reading_or_writing ?
1270
 
                    (tmp->net.reading_or_writing == 2 ?
1271
 
                     "Writing to net" :
1272
 
                     tmp->command == COM_SLEEP ? NullS :
1273
 
                     "Reading from net") :
1274
 
                    tmp->proc_info ? tmp->proc_info :
1275
 
                    tmp->mysys_var &&
1276
 
                    tmp->mysys_var->current_cond ?
1277
 
                    "Waiting on cond" : NullS);
1278
 
      if (val)
1279
 
      {
1280
 
        table->field[6]->store(val, strlen(val), cs);
1281
 
        table->field[6]->set_notnull();
1282
 
      }
1283
 
 
1284
 
      if (mysys_var)
1285
 
        pthread_mutex_unlock(&mysys_var->mutex);
1286
 
 
1287
 
      /* INFO */
1288
 
      if (tmp->query)
1289
 
      {
1290
 
        table->field[7]->store(tmp->query,
1291
 
                               min((uint32_t)PROCESS_LIST_INFO_WIDTH,
1292
 
                                   tmp->query_length), cs);
1293
 
        table->field[7]->set_notnull();
1294
 
      }
1295
 
 
1296
 
      if (schema_table_store_record(thd, table))
1297
 
      {
1298
 
        VOID(pthread_mutex_unlock(&LOCK_thread_count));
1299
 
        return(1);
1300
 
      }
1301
 
    }
1302
 
  }
1303
 
 
1304
 
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
1305
 
  return(0);
1306
 
}
1307
 
 
1308
640
/*****************************************************************************
1309
641
  Status functions
1310
642
*****************************************************************************/
1311
643
 
1312
 
static DYNAMIC_ARRAY all_status_vars;
 
644
static vector<drizzle_show_var *> all_status_vars;
1313
645
static bool status_vars_inited= 0;
1314
646
static int show_var_cmp(const void *var1, const void *var2)
1315
647
{
1316
 
  return strcmp(((SHOW_VAR*)var1)->name, ((SHOW_VAR*)var2)->name);
1317
 
}
1318
 
 
1319
 
/*
1320
 
  deletes all the SHOW_UNDEF elements from the array and calls
1321
 
  delete_dynamic() if it's completely empty.
1322
 
*/
1323
 
static void shrink_var_array(DYNAMIC_ARRAY *array)
1324
 
{
1325
 
  uint a,b;
1326
 
  SHOW_VAR *all= dynamic_element(array, 0, SHOW_VAR *);
1327
 
 
1328
 
  for (a= b= 0; b < array->elements; b++)
1329
 
    if (all[b].type != SHOW_UNDEF)
1330
 
      all[a++]= all[b];
1331
 
  if (a)
1332
 
  {
1333
 
    memset(all+a, 0, sizeof(SHOW_VAR)); // writing NULL-element to the end
1334
 
    array->elements= a;
1335
 
  }
1336
 
  else // array is completely empty - delete it
1337
 
    delete_dynamic(array);
1338
 
}
1339
 
 
1340
 
/*
1341
 
  Adds an array of SHOW_VAR entries to the output of SHOW STATUS
 
648
  return strcmp(((drizzle_show_var*)var1)->name, ((drizzle_show_var*)var2)->name);
 
649
}
 
650
 
 
651
class show_var_cmp_functor
 
652
{
 
653
  public:
 
654
  show_var_cmp_functor() { }
 
655
  inline bool operator()(const drizzle_show_var *var1, const drizzle_show_var *var2) const
 
656
  {
 
657
    int val= strcmp(var1->name, var2->name);
 
658
    return (val < 0);
 
659
  }
 
660
};
 
661
 
 
662
class show_var_remove_if
 
663
{
 
664
  public:
 
665
  show_var_remove_if() { }
 
666
  inline bool operator()(const drizzle_show_var *curr) const
 
667
  {
 
668
    return (curr->type == SHOW_UNDEF);
 
669
  }
 
670
};
 
671
 
 
672
drizzle_show_var *getFrontOfStatusVars()
 
673
{
 
674
  return all_status_vars.front();
 
675
}
 
676
 
 
677
/*
 
678
  Adds an array of drizzle_show_var entries to the output of SHOW STATUS
1342
679
 
1343
680
  SYNOPSIS
1344
 
    add_status_vars(SHOW_VAR *list)
1345
 
    list - an array of SHOW_VAR entries to add to all_status_vars
 
681
    add_status_vars(drizzle_show_var *list)
 
682
    list - an array of drizzle_show_var entries to add to all_status_vars
1346
683
           the last entry must be {0,0,SHOW_UNDEF}
1347
684
 
1348
685
  NOTE
1353
690
    As a special optimization, if add_status_vars() is called before
1354
691
    init_status_vars(), it assumes "startup mode" - neither concurrent access
1355
692
    to the array nor SHOW STATUS are possible (thus it skips locks and qsort)
1356
 
 
1357
 
    The last entry of the all_status_vars[] should always be {0,0,SHOW_UNDEF}
1358
693
*/
1359
 
int add_status_vars(SHOW_VAR *list)
 
694
int add_status_vars(drizzle_show_var *list)
1360
695
{
1361
696
  int res= 0;
1362
697
  if (status_vars_inited)
1363
698
    pthread_mutex_lock(&LOCK_status);
1364
 
  if (!all_status_vars.buffer && // array is not allocated yet - do it now
1365
 
      my_init_dynamic_array(&all_status_vars, sizeof(SHOW_VAR), 200, 20))
1366
 
  {
1367
 
    res= 1;
1368
 
    goto err;
1369
 
  }
1370
699
  while (list->name)
1371
 
    res|= insert_dynamic(&all_status_vars, (uchar*)list++);
1372
 
  res|= insert_dynamic(&all_status_vars, (uchar*)list); // appending NULL-element
1373
 
  all_status_vars.elements--; // but next insert_dynamic should overwite it
 
700
    all_status_vars.insert(all_status_vars.begin(), list++);
1374
701
  if (status_vars_inited)
1375
 
    sort_dynamic(&all_status_vars, show_var_cmp);
1376
 
err:
 
702
    sort(all_status_vars.begin(), all_status_vars.end(),
 
703
         show_var_cmp_functor());
1377
704
  if (status_vars_inited)
1378
705
    pthread_mutex_unlock(&LOCK_status);
1379
706
  return res;
1389
716
*/
1390
717
void init_status_vars()
1391
718
{
1392
 
  status_vars_inited=1;
1393
 
  sort_dynamic(&all_status_vars, show_var_cmp);
 
719
  status_vars_inited= 1;
 
720
  sort(all_status_vars.begin(), all_status_vars.end(),
 
721
       show_var_cmp_functor());
1394
722
}
1395
723
 
1396
724
void reset_status_vars()
1397
725
{
1398
 
  SHOW_VAR *ptr= (SHOW_VAR*) all_status_vars.buffer;
1399
 
  SHOW_VAR *last= ptr + all_status_vars.elements;
1400
 
  for (; ptr < last; ptr++)
 
726
  vector<drizzle_show_var *>::iterator p;
 
727
 
 
728
  p= all_status_vars.begin();
 
729
  while (p != all_status_vars.end())
1401
730
  {
1402
731
    /* Note that SHOW_LONG_NOFLUSH variables are not reset */
1403
 
    if (ptr->type == SHOW_LONG)
1404
 
      *(ulong*) ptr->value= 0;
1405
 
  }  
 
732
    if ((*p)->type == SHOW_LONG)
 
733
      (*p)->value= 0;
 
734
    ++p;
 
735
  }
1406
736
}
1407
737
 
1408
738
/*
1411
741
  DESCRIPTION
1412
742
    This function is not strictly required if all add_to_status/
1413
743
    remove_status_vars are properly paired, but it's a safety measure that
1414
 
    deletes everything from the all_status_vars[] even if some
 
744
    deletes everything from the all_status_vars vector even if some
1415
745
    remove_status_vars were forgotten
1416
746
*/
1417
747
void free_status_vars()
1418
748
{
1419
 
  delete_dynamic(&all_status_vars);
 
749
  all_status_vars.clear();
1420
750
}
1421
751
 
1422
752
/*
1423
 
  Removes an array of SHOW_VAR entries from the output of SHOW STATUS
 
753
  Removes an array of drizzle_show_var entries from the output of SHOW STATUS
1424
754
 
1425
755
  SYNOPSIS
1426
 
    remove_status_vars(SHOW_VAR *list)
1427
 
    list - an array of SHOW_VAR entries to remove to all_status_vars
 
756
    remove_status_vars(drizzle_show_var *list)
 
757
    list - an array of drizzle_show_var entries to remove to all_status_vars
1428
758
           the last entry must be {0,0,SHOW_UNDEF}
1429
759
 
1430
760
  NOTE
1433
763
    initialization in the mysqld startup.
1434
764
*/
1435
765
 
1436
 
void remove_status_vars(SHOW_VAR *list)
 
766
void remove_status_vars(drizzle_show_var *list)
1437
767
{
1438
768
  if (status_vars_inited)
1439
769
  {
1440
770
    pthread_mutex_lock(&LOCK_status);
1441
 
    SHOW_VAR *all= dynamic_element(&all_status_vars, 0, SHOW_VAR *);
1442
 
    int a= 0, b= all_status_vars.elements, c= (a+b)/2;
 
771
    drizzle_show_var *all= all_status_vars.front();
 
772
    int a= 0, b= all_status_vars.size(), c= (a+b)/2;
1443
773
 
1444
774
    for (; list->name; list++)
1445
775
    {
1446
776
      int res= 0;
1447
 
      for (a= 0, b= all_status_vars.elements; b-a > 1; c= (a+b)/2)
 
777
      for (a= 0, b= all_status_vars.size(); b-a > 1; c= (a+b)/2)
1448
778
      {
1449
779
        res= show_var_cmp(list, all+c);
1450
780
        if (res < 0)
1457
787
      if (res == 0)
1458
788
        all[c].type= SHOW_UNDEF;
1459
789
    }
1460
 
    shrink_var_array(&all_status_vars);
 
790
    /* removes all the SHOW_UNDEF elements from the vector */
 
791
    all_status_vars.erase(std::remove_if(all_status_vars.begin(),
 
792
                            all_status_vars.end(),show_var_remove_if()),
 
793
                            all_status_vars.end());
1461
794
    pthread_mutex_unlock(&LOCK_status);
1462
795
  }
1463
796
  else
1464
797
  {
1465
 
    SHOW_VAR *all= dynamic_element(&all_status_vars, 0, SHOW_VAR *);
1466
 
    uint i;
 
798
    drizzle_show_var *all= all_status_vars.front();
 
799
    uint32_t i;
1467
800
    for (; list->name; list++)
1468
801
    {
1469
 
      for (i= 0; i < all_status_vars.elements; i++)
 
802
      for (i= 0; i < all_status_vars.size(); i++)
1470
803
      {
1471
804
        if (show_var_cmp(list, all+i))
1472
805
          continue;
1474
807
        break;
1475
808
      }
1476
809
    }
1477
 
    shrink_var_array(&all_status_vars);
1478
 
  }
1479
 
}
1480
 
 
1481
 
inline void make_upper(char *buf)
1482
 
{
1483
 
  for (; *buf; buf++)
1484
 
    *buf= my_toupper(system_charset_info, *buf);
1485
 
}
1486
 
 
1487
 
static bool show_status_array(THD *thd, const char *wild,
1488
 
                              SHOW_VAR *variables,
1489
 
                              enum enum_var_type value_type,
1490
 
                              struct system_status_var *status_var,
1491
 
                              const char *prefix, TABLE *table,
1492
 
                              bool ucase_names)
1493
 
{
1494
 
  MY_ALIGNED_BYTE_ARRAY(buff_data, SHOW_VAR_FUNC_BUFF_SIZE, long);
1495
 
  char * const buff= (char *) &buff_data;
1496
 
  char *prefix_end;
1497
 
  /* the variable name should not be longer than 64 characters */
1498
 
  char name_buffer[64];
1499
 
  int len;
1500
 
  LEX_STRING null_lex_str;
1501
 
  SHOW_VAR tmp, *var;
1502
 
 
1503
 
  null_lex_str.str= 0;                          // For sys_var->value_ptr()
1504
 
  null_lex_str.length= 0;
1505
 
 
1506
 
  prefix_end=stpncpy(name_buffer, prefix, sizeof(name_buffer)-1);
1507
 
  if (*prefix)
1508
 
    *prefix_end++= '_';
1509
 
  len=name_buffer + sizeof(name_buffer) - prefix_end;
1510
 
 
1511
 
  for (; variables->name; variables++)
1512
 
  {
1513
 
    stpncpy(prefix_end, variables->name, len);
1514
 
    name_buffer[sizeof(name_buffer)-1]=0;       /* Safety */
1515
 
    if (ucase_names)
1516
 
      make_upper(name_buffer);
1517
 
 
1518
 
    /*
1519
 
      if var->type is SHOW_FUNC, call the function.
1520
 
      Repeat as necessary, if new var is again SHOW_FUNC
1521
 
    */
1522
 
    for (var=variables; var->type == SHOW_FUNC; var= &tmp)
1523
 
      ((mysql_show_var_func)((st_show_var_func_container *)var->value)->func)(thd, &tmp, buff);
1524
 
 
1525
 
    SHOW_TYPE show_type=var->type;
1526
 
    if (show_type == SHOW_ARRAY)
1527
 
    {
1528
 
      show_status_array(thd, wild, (SHOW_VAR *) var->value, value_type,
1529
 
                        status_var, name_buffer, table, ucase_names);
1530
 
    }
1531
 
    else
1532
 
    {
1533
 
      if (!(wild && wild[0] && wild_case_compare(system_charset_info,
1534
 
                                                 name_buffer, wild)))
1535
 
      {
1536
 
        char *value=var->value;
1537
 
        const char *pos, *end;                  // We assign a lot of const's
1538
 
 
1539
 
        pthread_mutex_lock(&LOCK_global_system_variables);
1540
 
 
1541
 
        if (show_type == SHOW_SYS)
1542
 
        {
1543
 
          show_type= ((sys_var*) value)->show_type();
1544
 
          value=     (char*) ((sys_var*) value)->value_ptr(thd, value_type,
1545
 
                                                           &null_lex_str);
1546
 
        }
1547
 
 
1548
 
        pos= end= buff;
1549
 
        /*
1550
 
          note that value may be == buff. All SHOW_xxx code below
1551
 
          should still work in this case
1552
 
        */
1553
 
        switch (show_type) {
1554
 
        case SHOW_DOUBLE_STATUS:
1555
 
          value= ((char *) status_var + (ulong) value);
1556
 
          /* fall through */
1557
 
        case SHOW_DOUBLE:
1558
 
          /* 6 is the default precision for '%f' in sprintf() */
1559
 
          end= buff + my_fcvt(*(double *) value, 6, buff, NULL);
1560
 
          break;
1561
 
        case SHOW_LONG_STATUS:
1562
 
          value= ((char *) status_var + (ulong) value);
1563
 
          /* fall through */
1564
 
        case SHOW_LONG:
1565
 
        case SHOW_LONG_NOFLUSH: // the difference lies in refresh_status()
1566
 
          end= int10_to_str(*(long*) value, buff, 10);
1567
 
          break;
1568
 
        case SHOW_LONGLONG_STATUS:
1569
 
          value= ((char *) status_var + (uint64_t) value);
1570
 
          /* fall through */
1571
 
        case SHOW_LONGLONG:
1572
 
          end= int64_t10_to_str(*(int64_t*) value, buff, 10);
1573
 
          break;
1574
 
        case SHOW_HA_ROWS:
1575
 
          end= int64_t10_to_str((int64_t) *(ha_rows*) value, buff, 10);
1576
 
          break;
1577
 
        case SHOW_BOOL:
1578
 
          end= stpcpy(buff, *(bool*) value ? "ON" : "OFF");
1579
 
          break;
1580
 
        case SHOW_MY_BOOL:
1581
 
          end= stpcpy(buff, *(bool*) value ? "ON" : "OFF");
1582
 
          break;
1583
 
        case SHOW_INT:
1584
 
          end= int10_to_str((long) *(uint32_t*) value, buff, 10);
1585
 
          break;
1586
 
        case SHOW_HAVE:
1587
 
        {
1588
 
          SHOW_COMP_OPTION tmp= *(SHOW_COMP_OPTION*) value;
1589
 
          pos= show_comp_option_name[(int) tmp];
1590
 
          end= strend(pos);
1591
 
          break;
1592
 
        }
1593
 
        case SHOW_CHAR:
1594
 
        {
1595
 
          if (!(pos= value))
1596
 
            pos= "";
1597
 
          end= strend(pos);
1598
 
          break;
1599
 
        }
1600
 
       case SHOW_CHAR_PTR:
1601
 
        {
1602
 
          if (!(pos= *(char**) value))
1603
 
            pos= "";
1604
 
          end= strend(pos);
1605
 
          break;
1606
 
        }
1607
 
        case SHOW_KEY_CACHE_LONG:
1608
 
          value= (char*) dflt_key_cache + (ulong)value;
1609
 
          end= int10_to_str(*(long*) value, buff, 10);
1610
 
          break;
1611
 
        case SHOW_KEY_CACHE_LONGLONG:
1612
 
          value= (char*) dflt_key_cache + (ulong)value;
1613
 
          end= int64_t10_to_str(*(int64_t*) value, buff, 10);
1614
 
          break;
1615
 
        case SHOW_UNDEF:
1616
 
          break;                                        // Return empty string
1617
 
        case SHOW_SYS:                                  // Cannot happen
1618
 
        default:
1619
 
          assert(0);
1620
 
          break;
1621
 
        }
1622
 
        restore_record(table, s->default_values);
1623
 
        table->field[0]->store(name_buffer, strlen(name_buffer),
1624
 
                               system_charset_info);
1625
 
        table->field[1]->store(pos, (uint32_t) (end - pos), system_charset_info);
1626
 
        table->field[1]->set_notnull();
1627
 
 
1628
 
        pthread_mutex_unlock(&LOCK_global_system_variables);
1629
 
 
1630
 
        if (schema_table_store_record(thd, table))
1631
 
          return(true);
1632
 
      }
1633
 
    }
1634
 
  }
1635
 
 
1636
 
  return(false);
1637
 
}
1638
 
 
 
810
    /* removes all the SHOW_UNDEF elements from the vector */
 
811
    all_status_vars.erase(std::remove_if(all_status_vars.begin(),
 
812
                            all_status_vars.end(),show_var_remove_if()),
 
813
                            all_status_vars.end());
 
814
  }
 
815
}
1639
816
 
1640
817
/* collect status for all running threads */
1641
818
 
1642
 
void calc_sum_of_all_status(STATUS_VAR *to)
 
819
void calc_sum_of_all_status(system_status_var *to)
1643
820
{
1644
 
 
1645
821
  /* Ensure that thread id not killed during loop */
1646
 
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
 
822
  pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
1647
823
 
1648
 
  I_List_iterator<THD> it(threads);
1649
 
  THD *tmp;
1650
 
  
1651
824
  /* Get global values as base */
1652
825
  *to= global_status_var;
1653
 
  
 
826
 
1654
827
  /* Add to this status from existing threads */
1655
 
  while ((tmp= it++))
1656
 
    add_to_status(to, &tmp->status_var);
1657
 
  
1658
 
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
 
828
  for(SessionList::iterator it= getSessionList().begin(); it != getSessionList().end(); ++it )
 
829
  {
 
830
    add_to_status(to, &((*it)->status_var));
 
831
  }
 
832
 
 
833
  pthread_mutex_unlock(&LOCK_thread_count);
1659
834
  return;
1660
835
}
1661
836
 
1662
 
 
1663
 
/* This is only used internally, but we need it here as a forward reference */
1664
 
extern ST_SCHEMA_TABLE schema_tables[];
1665
 
 
1666
 
typedef struct st_lookup_field_values
1667
 
{
1668
 
  LEX_STRING db_value, table_value;
1669
 
  bool wild_db_value, wild_table_value;
1670
 
} LOOKUP_FIELD_VALUES;
1671
 
 
1672
 
 
1673
 
/*
1674
 
  Store record to I_S table, convert HEAP table
1675
 
  to MyISAM if necessary
1676
 
 
1677
 
  SYNOPSIS
1678
 
    schema_table_store_record()
1679
 
    thd                   thread handler
1680
 
    table                 Information schema table to be updated
1681
 
 
1682
 
  RETURN
1683
 
    0                     success
1684
 
    1                     error
1685
 
*/
1686
 
 
1687
 
bool schema_table_store_record(THD *thd, TABLE *table)
1688
 
{
1689
 
  int error;
1690
 
  if ((error= table->file->ha_write_row(table->record[0])))
1691
 
  {
1692
 
    TMP_TABLE_PARAM *param= table->pos_in_table_list->schema_table_param;
1693
 
 
1694
 
    if (create_myisam_from_heap(thd, table, param->start_recinfo, 
1695
 
                                &param->recinfo, error, 0))
1696
 
      return 1;
1697
 
  }
1698
 
  return 0;
1699
 
}
1700
 
 
1701
 
 
1702
 
int make_table_list(THD *thd, SELECT_LEX *sel,
1703
 
                    LEX_STRING *db_name, LEX_STRING *table_name)
1704
 
{
1705
 
  Table_ident *table_ident;
1706
 
  table_ident= new Table_ident(thd, *db_name, *table_name, 1);
1707
 
  sel->init_query();
1708
 
  if (!sel->add_table_to_list(thd, table_ident, 0, 0, TL_READ))
1709
 
    return 1;
1710
 
  return 0;
1711
 
}
1712
 
 
1713
 
 
1714
 
/**
1715
 
  @brief    Get lookup value from the part of 'WHERE' condition 
1716
 
 
1717
 
  @details This function gets lookup value from 
1718
 
           the part of 'WHERE' condition if it's possible and 
1719
 
           fill appropriate lookup_field_vals struct field
1720
 
           with this value.
1721
 
 
1722
 
  @param[in]      thd                   thread handler
1723
 
  @param[in]      item_func             part of WHERE condition
1724
 
  @param[in]      table                 I_S table
1725
 
  @param[in, out] lookup_field_vals     Struct which holds lookup values 
1726
 
 
1727
 
  @return
1728
 
    0             success
1729
 
    1             error, there can be no matching records for the condition
1730
 
*/
1731
 
 
1732
 
bool get_lookup_value(THD *thd, Item_func *item_func,
1733
 
                      TABLE_LIST *table, 
1734
 
                      LOOKUP_FIELD_VALUES *lookup_field_vals)
1735
 
{
1736
 
  ST_SCHEMA_TABLE *schema_table= table->schema_table;
1737
 
  ST_FIELD_INFO *field_info= schema_table->fields_info;
1738
 
  const char *field_name1= schema_table->idx_field1 >= 0 ?
1739
 
    field_info[schema_table->idx_field1].field_name : "";
1740
 
  const char *field_name2= schema_table->idx_field2 >= 0 ?
1741
 
    field_info[schema_table->idx_field2].field_name : "";
1742
 
 
1743
 
  if (item_func->functype() == Item_func::EQ_FUNC ||
1744
 
      item_func->functype() == Item_func::EQUAL_FUNC)
1745
 
  {
1746
 
    int idx_field, idx_val;
1747
 
    char tmp[MAX_FIELD_WIDTH];
1748
 
    String *tmp_str, str_buff(tmp, sizeof(tmp), system_charset_info);
1749
 
    Item_field *item_field;
1750
 
    const CHARSET_INFO * const cs= system_charset_info;
1751
 
 
1752
 
    if (item_func->arguments()[0]->type() == Item::FIELD_ITEM &&
1753
 
        item_func->arguments()[1]->const_item())
1754
 
    {
1755
 
      idx_field= 0;
1756
 
      idx_val= 1;
1757
 
    }
1758
 
    else if (item_func->arguments()[1]->type() == Item::FIELD_ITEM &&
1759
 
             item_func->arguments()[0]->const_item())
1760
 
    {
1761
 
      idx_field= 1;
1762
 
      idx_val= 0;
1763
 
    }
1764
 
    else
1765
 
      return 0;
1766
 
 
1767
 
    item_field= (Item_field*) item_func->arguments()[idx_field];
1768
 
    if (table->table != item_field->field->table)
1769
 
      return 0;
1770
 
    tmp_str= item_func->arguments()[idx_val]->val_str(&str_buff);
1771
 
 
1772
 
    /* impossible value */
1773
 
    if (!tmp_str)
1774
 
      return 1;
1775
 
 
1776
 
    /* Lookup value is database name */
1777
 
    if (!cs->coll->strnncollsp(cs, (uchar *) field_name1, strlen(field_name1),
1778
 
                               (uchar *) item_field->field_name,
1779
 
                               strlen(item_field->field_name), 0))
1780
 
    {
1781
 
      thd->make_lex_string(&lookup_field_vals->db_value, tmp_str->ptr(),
1782
 
                           tmp_str->length(), false);
1783
 
    }
1784
 
    /* Lookup value is table name */
1785
 
    else if (!cs->coll->strnncollsp(cs, (uchar *) field_name2,
1786
 
                                    strlen(field_name2),
1787
 
                                    (uchar *) item_field->field_name,
1788
 
                                    strlen(item_field->field_name), 0))
1789
 
    {
1790
 
      thd->make_lex_string(&lookup_field_vals->table_value, tmp_str->ptr(),
1791
 
                           tmp_str->length(), false);
1792
 
    }
1793
 
  }
1794
 
  return 0;
1795
 
}
1796
 
 
1797
 
 
1798
 
/**
1799
 
  @brief    Calculates lookup values from 'WHERE' condition 
1800
 
 
1801
 
  @details This function calculates lookup value(database name, table name)
1802
 
           from 'WHERE' condition if it's possible and 
1803
 
           fill lookup_field_vals struct fields with these values.
1804
 
 
1805
 
  @param[in]      thd                   thread handler
1806
 
  @param[in]      cond                  WHERE condition
1807
 
  @param[in]      table                 I_S table
1808
 
  @param[in, out] lookup_field_vals     Struct which holds lookup values 
1809
 
 
1810
 
  @return
1811
 
    0             success
1812
 
    1             error, there can be no matching records for the condition
1813
 
*/
1814
 
 
1815
 
bool calc_lookup_values_from_cond(THD *thd, COND *cond, TABLE_LIST *table,
1816
 
                                  LOOKUP_FIELD_VALUES *lookup_field_vals)
1817
 
{
1818
 
  if (!cond)
1819
 
    return 0;
1820
 
 
1821
 
  if (cond->type() == Item::COND_ITEM)
1822
 
  {
1823
 
    if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
1824
 
    {
1825
 
      List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
1826
 
      Item *item;
1827
 
      while ((item= li++))
1828
 
      {
1829
 
        if (item->type() == Item::FUNC_ITEM)
1830
 
        {
1831
 
          if (get_lookup_value(thd, (Item_func*)item, table, lookup_field_vals))
1832
 
            return 1;
1833
 
        }
1834
 
        else
1835
 
        {
1836
 
          if (calc_lookup_values_from_cond(thd, item, table, lookup_field_vals))
1837
 
            return 1;
1838
 
        }
1839
 
      }
1840
 
    }
1841
 
    return 0;
1842
 
  }
1843
 
  else if (cond->type() == Item::FUNC_ITEM &&
1844
 
           get_lookup_value(thd, (Item_func*) cond, table, lookup_field_vals))
1845
 
    return 1;
1846
 
  return 0;
1847
 
}
1848
 
 
1849
 
 
1850
 
bool uses_only_table_name_fields(Item *item, TABLE_LIST *table)
1851
 
{
1852
 
  if (item->type() == Item::FUNC_ITEM)
1853
 
  {
1854
 
    Item_func *item_func= (Item_func*)item;
1855
 
    for (uint i=0; i<item_func->argument_count(); i++)
1856
 
    {
1857
 
      if (!uses_only_table_name_fields(item_func->arguments()[i], table))
1858
 
        return 0;
1859
 
    }
1860
 
  }
1861
 
  else if (item->type() == Item::FIELD_ITEM)
1862
 
  {
1863
 
    Item_field *item_field= (Item_field*)item;
1864
 
    const CHARSET_INFO * const cs= system_charset_info;
1865
 
    ST_SCHEMA_TABLE *schema_table= table->schema_table;
1866
 
    ST_FIELD_INFO *field_info= schema_table->fields_info;
1867
 
    const char *field_name1= schema_table->idx_field1 >= 0 ?
1868
 
      field_info[schema_table->idx_field1].field_name : "";
1869
 
    const char *field_name2= schema_table->idx_field2 >= 0 ?
1870
 
      field_info[schema_table->idx_field2].field_name : "";
1871
 
    if (table->table != item_field->field->table ||
1872
 
        (cs->coll->strnncollsp(cs, (uchar *) field_name1, strlen(field_name1),
1873
 
                               (uchar *) item_field->field_name,
1874
 
                               strlen(item_field->field_name), 0) &&
1875
 
         cs->coll->strnncollsp(cs, (uchar *) field_name2, strlen(field_name2),
1876
 
                               (uchar *) item_field->field_name,
1877
 
                               strlen(item_field->field_name), 0)))
1878
 
      return 0;
1879
 
  }
1880
 
  else if (item->type() == Item::REF_ITEM)
1881
 
    return uses_only_table_name_fields(item->real_item(), table);
1882
 
 
1883
 
  if (item->type() == Item::SUBSELECT_ITEM && !item->const_item())
1884
 
    return 0;
1885
 
 
1886
 
  return 1;
1887
 
}
1888
 
 
1889
 
 
1890
 
static COND * make_cond_for_info_schema(COND *cond, TABLE_LIST *table)
1891
 
{
1892
 
  if (!cond)
1893
 
    return (COND*) 0;
1894
 
  if (cond->type() == Item::COND_ITEM)
1895
 
  {
1896
 
    if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
1897
 
    {
1898
 
      /* Create new top level AND item */
1899
 
      Item_cond_and *new_cond=new Item_cond_and;
1900
 
      if (!new_cond)
1901
 
        return (COND*) 0;
1902
 
      List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
1903
 
      Item *item;
1904
 
      while ((item=li++))
1905
 
      {
1906
 
        Item *fix= make_cond_for_info_schema(item, table);
1907
 
        if (fix)
1908
 
          new_cond->argument_list()->push_back(fix);
1909
 
      }
1910
 
      switch (new_cond->argument_list()->elements) {
1911
 
      case 0:
1912
 
        return (COND*) 0;
1913
 
      case 1:
1914
 
        return new_cond->argument_list()->head();
1915
 
      default:
1916
 
        new_cond->quick_fix_field();
1917
 
        return new_cond;
1918
 
      }
1919
 
    }
1920
 
    else
1921
 
    {                                           // Or list
1922
 
      Item_cond_or *new_cond=new Item_cond_or;
1923
 
      if (!new_cond)
1924
 
        return (COND*) 0;
1925
 
      List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
1926
 
      Item *item;
1927
 
      while ((item=li++))
1928
 
      {
1929
 
        Item *fix=make_cond_for_info_schema(item, table);
1930
 
        if (!fix)
1931
 
          return (COND*) 0;
1932
 
        new_cond->argument_list()->push_back(fix);
1933
 
      }
1934
 
      new_cond->quick_fix_field();
1935
 
      new_cond->top_level_item();
1936
 
      return new_cond;
1937
 
    }
1938
 
  }
1939
 
 
1940
 
  if (!uses_only_table_name_fields(cond, table))
1941
 
    return (COND*) 0;
1942
 
  return cond;
1943
 
}
1944
 
 
1945
 
 
1946
 
/**
1947
 
  @brief   Calculate lookup values(database name, table name)
1948
 
 
1949
 
  @details This function calculates lookup values(database name, table name)
1950
 
           from 'WHERE' condition or wild values (for 'SHOW' commands only)
1951
 
           from LEX struct and fill lookup_field_vals struct field
1952
 
           with these values.
1953
 
 
1954
 
  @param[in]      thd                   thread handler
1955
 
  @param[in]      cond                  WHERE condition
1956
 
  @param[in]      tables                I_S table
1957
 
  @param[in, out] lookup_field_values   Struct which holds lookup values 
1958
 
 
1959
 
  @return
1960
 
    0             success
1961
 
    1             error, there can be no matching records for the condition
1962
 
*/
1963
 
 
1964
 
bool get_lookup_field_values(THD *thd, COND *cond, TABLE_LIST *tables,
1965
 
                             LOOKUP_FIELD_VALUES *lookup_field_values)
1966
 
{
1967
 
  LEX *lex= thd->lex;
1968
 
  const char *wild= lex->wild ? lex->wild->ptr() : NullS;
1969
 
  memset(lookup_field_values, 0, sizeof(LOOKUP_FIELD_VALUES));
1970
 
  switch (lex->sql_command) {
1971
 
  case SQLCOM_SHOW_DATABASES:
1972
 
    if (wild)
1973
 
    {
1974
 
      lookup_field_values->db_value.str= (char*) wild;
1975
 
      lookup_field_values->db_value.length= strlen(wild);
1976
 
      lookup_field_values->wild_db_value= 1;
1977
 
    }
1978
 
    return 0;
1979
 
  case SQLCOM_SHOW_TABLES:
1980
 
  case SQLCOM_SHOW_TABLE_STATUS:
1981
 
    lookup_field_values->db_value.str= lex->select_lex.db;
1982
 
    lookup_field_values->db_value.length=strlen(lex->select_lex.db);
1983
 
    if (wild)
1984
 
    {
1985
 
      lookup_field_values->table_value.str= (char*)wild;
1986
 
      lookup_field_values->table_value.length= strlen(wild);
1987
 
      lookup_field_values->wild_table_value= 1;
1988
 
    }
1989
 
    return 0;
1990
 
  default:
1991
 
    /*
1992
 
      The "default" is for queries over I_S.
1993
 
      All previous cases handle SHOW commands.
1994
 
    */
1995
 
    return calc_lookup_values_from_cond(thd, cond, tables, lookup_field_values);
1996
 
  }
1997
 
}
1998
 
 
1999
 
 
2000
 
enum enum_schema_tables get_schema_table_idx(ST_SCHEMA_TABLE *schema_table)
2001
 
{
2002
 
  return (enum enum_schema_tables) (schema_table - &schema_tables[0]);
2003
 
}
2004
 
 
2005
 
 
2006
 
/*
2007
 
  Create db names list. Information schema name always is first in list
2008
 
 
2009
 
  SYNOPSIS
2010
 
    make_db_list()
2011
 
    thd                   thread handler
2012
 
    files                 list of db names
2013
 
    wild                  wild string
2014
 
    idx_field_vals        idx_field_vals->db_name contains db name or
2015
 
                          wild string
2016
 
    with_i_schema         returns 1 if we added 'IS' name to list
2017
 
                          otherwise returns 0 
2018
 
 
2019
 
  RETURN
2020
 
    zero                  success
2021
 
    non-zero              error
2022
 
*/
2023
 
 
2024
 
int make_db_list(THD *thd, List<LEX_STRING> *files,
2025
 
                 LOOKUP_FIELD_VALUES *lookup_field_vals,
2026
 
                 bool *with_i_schema)
2027
 
{
2028
 
  LEX_STRING *i_s_name_copy= 0;
2029
 
  i_s_name_copy= thd->make_lex_string(i_s_name_copy,
2030
 
                                      INFORMATION_SCHEMA_NAME.str,
2031
 
                                      INFORMATION_SCHEMA_NAME.length, true);
2032
 
  *with_i_schema= 0;
2033
 
  if (lookup_field_vals->wild_db_value)
2034
 
  {
2035
 
    /*
2036
 
      This part of code is only for SHOW DATABASES command.
2037
 
      idx_field_vals->db_value can be 0 when we don't use
2038
 
      LIKE clause (see also get_index_field_values() function)
2039
 
    */
2040
 
    if (!lookup_field_vals->db_value.str ||
2041
 
        !wild_case_compare(system_charset_info, 
2042
 
                           INFORMATION_SCHEMA_NAME.str,
2043
 
                           lookup_field_vals->db_value.str))
2044
 
    {
2045
 
      *with_i_schema= 1;
2046
 
      if (files->push_back(i_s_name_copy))
2047
 
        return 1;
2048
 
    }
2049
 
    return (find_files(thd, files, NullS, mysql_data_home,
2050
 
                       lookup_field_vals->db_value.str, 1) != FIND_FILES_OK);
2051
 
  }
2052
 
 
2053
 
 
2054
 
  /*
2055
 
    If we have db lookup vaule we just add it to list and
2056
 
    exit from the function
2057
 
  */
2058
 
  if (lookup_field_vals->db_value.str)
2059
 
  {
2060
 
    if (!my_strcasecmp(system_charset_info, INFORMATION_SCHEMA_NAME.str,
2061
 
                       lookup_field_vals->db_value.str))
2062
 
    {
2063
 
      *with_i_schema= 1;
2064
 
      if (files->push_back(i_s_name_copy))
2065
 
        return 1;
2066
 
      return 0;
2067
 
    }
2068
 
    if (files->push_back(&lookup_field_vals->db_value))
2069
 
      return 1;
2070
 
    return 0;
2071
 
  }
2072
 
 
2073
 
  /*
2074
 
    Create list of existing databases. It is used in case
2075
 
    of select from information schema table
2076
 
  */
2077
 
  if (files->push_back(i_s_name_copy))
2078
 
    return 1;
2079
 
  *with_i_schema= 1;
2080
 
  return (find_files(thd, files, NullS,
2081
 
                     mysql_data_home, NullS, 1) != FIND_FILES_OK);
2082
 
}
2083
 
 
2084
 
 
2085
 
struct st_add_schema_table 
2086
 
{
2087
 
  List<LEX_STRING> *files;
2088
 
  const char *wild;
2089
 
};
2090
 
 
2091
 
 
2092
 
static bool add_schema_table(THD *thd, plugin_ref plugin,
2093
 
                                void* p_data)
2094
 
{
2095
 
  LEX_STRING *file_name= 0;
2096
 
  st_add_schema_table *data= (st_add_schema_table *)p_data;
2097
 
  List<LEX_STRING> *file_list= data->files;
2098
 
  const char *wild= data->wild;
2099
 
  ST_SCHEMA_TABLE *schema_table= plugin_data(plugin, ST_SCHEMA_TABLE *);
2100
 
 
2101
 
  if (schema_table->hidden)
2102
 
      return(0);
2103
 
  if (wild)
2104
 
  {
2105
 
    if (lower_case_table_names)
2106
 
    {
2107
 
      if (wild_case_compare(files_charset_info,
2108
 
                            schema_table->table_name,
2109
 
                            wild))
2110
 
        return(0);
2111
 
    }
2112
 
    else if (wild_compare(schema_table->table_name, wild, 0))
2113
 
      return(0);
2114
 
  }
2115
 
 
2116
 
  if ((file_name= thd->make_lex_string(file_name, schema_table->table_name,
2117
 
                                       strlen(schema_table->table_name),
2118
 
                                       true)) &&
2119
 
      !file_list->push_back(file_name))
2120
 
    return(0);
2121
 
  return(1);
2122
 
}
2123
 
 
2124
 
 
2125
 
int schema_tables_add(THD *thd, List<LEX_STRING> *files, const char *wild)
2126
 
{
2127
 
  LEX_STRING *file_name= 0;
2128
 
  ST_SCHEMA_TABLE *tmp_schema_table= schema_tables;
2129
 
  st_add_schema_table add_data;
2130
 
 
2131
 
  for (; tmp_schema_table->table_name; tmp_schema_table++)
2132
 
  {
2133
 
    if (tmp_schema_table->hidden)
2134
 
      continue;
2135
 
    if (wild)
2136
 
    {
2137
 
      if (lower_case_table_names)
2138
 
      {
2139
 
        if (wild_case_compare(files_charset_info,
2140
 
                              tmp_schema_table->table_name,
2141
 
                              wild))
2142
 
          continue;
2143
 
      }
2144
 
      else if (wild_compare(tmp_schema_table->table_name, wild, 0))
2145
 
        continue;
2146
 
    }
2147
 
    if ((file_name= 
2148
 
         thd->make_lex_string(file_name, tmp_schema_table->table_name,
2149
 
                              strlen(tmp_schema_table->table_name), true)) &&
2150
 
        !files->push_back(file_name))
2151
 
      continue;
2152
 
    return(1);
2153
 
  }
2154
 
 
2155
 
  add_data.files= files;
2156
 
  add_data.wild= wild;
2157
 
  if (plugin_foreach(thd, add_schema_table,
2158
 
                     DRIZZLE_INFORMATION_SCHEMA_PLUGIN, &add_data))
2159
 
    return(1);
2160
 
 
2161
 
  return(0);
2162
 
}
2163
 
 
2164
 
 
2165
 
/**
2166
 
  @brief          Create table names list
2167
 
 
2168
 
  @details        The function creates the list of table names in
2169
 
                  database
2170
 
 
2171
 
  @param[in]      thd                   thread handler
2172
 
  @param[in]      table_names           List of table names in database
2173
 
  @param[in]      lex                   pointer to LEX struct
2174
 
  @param[in]      lookup_field_vals     pointer to LOOKUP_FIELD_VALUE struct
2175
 
  @param[in]      with_i_schema         true means that we add I_S tables to list
2176
 
  @param[in]      db_name               database name
2177
 
 
2178
 
  @return         Operation status
2179
 
    @retval       0           ok
2180
 
    @retval       1           fatal error
2181
 
    @retval       2           Not fatal error; Safe to ignore this file list
2182
 
*/
2183
 
 
2184
 
static int
2185
 
make_table_name_list(THD *thd, List<LEX_STRING> *table_names, LEX *lex,
2186
 
                     LOOKUP_FIELD_VALUES *lookup_field_vals,
2187
 
                     bool with_i_schema, LEX_STRING *db_name)
2188
 
{
2189
 
  char path[FN_REFLEN];
2190
 
  build_table_filename(path, sizeof(path), db_name->str, "", "", 0);
2191
 
  if (!lookup_field_vals->wild_table_value &&
2192
 
      lookup_field_vals->table_value.str)
2193
 
  {
2194
 
    if (with_i_schema)
2195
 
    {
2196
 
      if (find_schema_table(thd, lookup_field_vals->table_value.str))
2197
 
      {
2198
 
        if (table_names->push_back(&lookup_field_vals->table_value))
2199
 
          return 1;
2200
 
      }
2201
 
    }
2202
 
    else
2203
 
    {    
2204
 
      if (table_names->push_back(&lookup_field_vals->table_value))
2205
 
        return 1;
2206
 
    }
2207
 
    return 0;
2208
 
  }
2209
 
 
2210
 
  /*
2211
 
    This call will add all matching the wildcards (if specified) IS tables
2212
 
    to the list
2213
 
  */
2214
 
  if (with_i_schema)
2215
 
    return (schema_tables_add(thd, table_names,
2216
 
                              lookup_field_vals->table_value.str));
2217
 
 
2218
 
  find_files_result res= find_files(thd, table_names, db_name->str, path,
2219
 
                                    lookup_field_vals->table_value.str, 0);
2220
 
  if (res != FIND_FILES_OK)
2221
 
  {
2222
 
    /*
2223
 
      Downgrade errors about problems with database directory to
2224
 
      warnings if this is not a 'SHOW' command.  Another thread
2225
 
      may have dropped database, and we may still have a name
2226
 
      for that directory.
2227
 
    */
2228
 
    if (res == FIND_FILES_DIR)
2229
 
    {
2230
 
      if (lex->sql_command != SQLCOM_SELECT)
2231
 
        return 1;
2232
 
      thd->clear_error();
2233
 
      return 2;
2234
 
    }
2235
 
    return 1;
2236
 
  }
2237
 
  return 0;
2238
 
}
2239
 
 
2240
 
 
2241
 
/**
2242
 
  @brief          Fill I_S table for SHOW COLUMNS|INDEX commands
2243
 
 
2244
 
  @param[in]      thd                      thread handler
2245
 
  @param[in]      tables                   TABLE_LIST for I_S table
2246
 
  @param[in]      schema_table             pointer to I_S structure
2247
 
  @param[in]      open_tables_state_backup pointer to Open_tables_state object
2248
 
                                           which is used to save|restore original
2249
 
                                           status of variables related to
2250
 
                                           open tables state
2251
 
 
2252
 
  @return         Operation status
2253
 
    @retval       0           success
2254
 
    @retval       1           error
2255
 
*/
2256
 
 
2257
 
static int 
2258
 
fill_schema_show_cols_or_idxs(THD *thd, TABLE_LIST *tables,
2259
 
                              ST_SCHEMA_TABLE *schema_table,
2260
 
                              Open_tables_state *open_tables_state_backup)
2261
 
{
2262
 
  LEX *lex= thd->lex;
2263
 
  bool res;
2264
 
  LEX_STRING tmp_lex_string, tmp_lex_string1, *db_name, *table_name;
2265
 
  enum_sql_command save_sql_command= lex->sql_command;
2266
 
  TABLE_LIST *show_table_list= (TABLE_LIST*) tables->schema_select_lex->
2267
 
    table_list.first;
2268
 
  TABLE *table= tables->table;
2269
 
  int error= 1;
2270
 
 
2271
 
  lex->all_selects_list= tables->schema_select_lex;
2272
 
  /*
2273
 
    Restore thd->temporary_tables to be able to process
2274
 
    temporary tables(only for 'show index' & 'show columns').
2275
 
    This should be changed when processing of temporary tables for
2276
 
    I_S tables will be done.
2277
 
  */
2278
 
  thd->temporary_tables= open_tables_state_backup->temporary_tables;
2279
 
  /*
2280
 
    Let us set fake sql_command so views won't try to merge
2281
 
    themselves into main statement. If we don't do this,
2282
 
    SELECT * from information_schema.xxxx will cause problems.
2283
 
    SQLCOM_SHOW_FIELDS is used because it satisfies 'only_view_structure()' 
2284
 
  */
2285
 
  lex->sql_command= SQLCOM_SHOW_FIELDS;
2286
 
  res= open_normal_and_derived_tables(thd, show_table_list,
2287
 
                                      DRIZZLE_LOCK_IGNORE_FLUSH);
2288
 
  lex->sql_command= save_sql_command;
2289
 
  /*
2290
 
    get_all_tables() returns 1 on failure and 0 on success thus
2291
 
    return only these and not the result code of ::process_table()
2292
 
 
2293
 
    We should use show_table_list->alias instead of 
2294
 
    show_table_list->table_name because table_name
2295
 
    could be changed during opening of I_S tables. It's safe
2296
 
    to use alias because alias contains original table name 
2297
 
    in this case(this part of code is used only for 
2298
 
    'show columns' & 'show statistics' commands).
2299
 
  */
2300
 
   table_name= thd->make_lex_string(&tmp_lex_string1, show_table_list->alias,
2301
 
                                    strlen(show_table_list->alias), false);
2302
 
   db_name= thd->make_lex_string(&tmp_lex_string, show_table_list->db,
2303
 
                                 show_table_list->db_length, false);
2304
 
      
2305
 
 
2306
 
   error= test(schema_table->process_table(thd, show_table_list,
2307
 
                                           table, res, db_name,
2308
 
                                           table_name));
2309
 
   thd->temporary_tables= 0;
2310
 
   close_tables_for_reopen(thd, &show_table_list);
2311
 
   return(error);
2312
 
}
2313
 
 
2314
 
 
2315
 
/**
2316
 
  @brief          Fill I_S table for SHOW TABLE NAMES commands
2317
 
 
2318
 
  @param[in]      thd                      thread handler
2319
 
  @param[in]      table                    TABLE struct for I_S table
2320
 
  @param[in]      db_name                  database name
2321
 
  @param[in]      table_name               table name
2322
 
  @param[in]      with_i_schema            I_S table if true
2323
 
 
2324
 
  @return         Operation status
2325
 
    @retval       0           success
2326
 
    @retval       1           error
2327
 
*/
2328
 
 
2329
 
static int fill_schema_table_names(THD *thd, TABLE *table,
2330
 
                                   LEX_STRING *db_name, LEX_STRING *table_name,
2331
 
                                   bool with_i_schema)
2332
 
{
2333
 
  if (with_i_schema)
2334
 
  {
2335
 
    table->field[3]->store(STRING_WITH_LEN("SYSTEM VIEW"),
2336
 
                           system_charset_info);
2337
 
  }
2338
 
  else
2339
 
  {
2340
 
    enum legacy_db_type not_used;
2341
 
    char path[FN_REFLEN];
2342
 
    (void) build_table_filename(path, sizeof(path), db_name->str, 
2343
 
                                table_name->str, reg_ext, 0);
2344
 
    switch (mysql_frm_type(thd, path, &not_used)) {
2345
 
    case FRMTYPE_ERROR:
2346
 
      table->field[3]->store(STRING_WITH_LEN("ERROR"),
2347
 
                             system_charset_info);
2348
 
      break;
2349
 
    case FRMTYPE_TABLE:
2350
 
      table->field[3]->store(STRING_WITH_LEN("BASE TABLE"),
2351
 
                             system_charset_info);
2352
 
      break;
2353
 
    default:
2354
 
      assert(0);
2355
 
    }
2356
 
    if (thd->is_error() && thd->main_da.sql_errno() == ER_NO_SUCH_TABLE)
2357
 
    {
2358
 
      thd->clear_error();
2359
 
      return 0;
2360
 
    }
2361
 
  }
2362
 
  if (schema_table_store_record(thd, table))
2363
 
    return 1;
2364
 
  return 0;
2365
 
}
2366
 
 
2367
 
 
2368
 
/**
2369
 
  @brief          Get open table method
2370
 
 
2371
 
  @details        The function calculates the method which will be used
2372
 
                  for table opening:
2373
 
                  SKIP_OPEN_TABLE - do not open table
2374
 
                  OPEN_FRM_ONLY   - open FRM file only
2375
 
                  OPEN_FULL_TABLE - open FRM, data, index files
2376
 
  @param[in]      tables               I_S table table_list
2377
 
  @param[in]      schema_table         I_S table struct
2378
 
  @param[in]      schema_table_idx     I_S table index
2379
 
 
2380
 
  @return         return a set of flags
2381
 
    @retval       SKIP_OPEN_TABLE | OPEN_FRM_ONLY | OPEN_FULL_TABLE
2382
 
*/
2383
 
 
2384
 
static uint get_table_open_method(TABLE_LIST *tables,
2385
 
                                  ST_SCHEMA_TABLE *schema_table,
2386
 
                                  enum enum_schema_tables schema_table_idx __attribute__((unused)))
2387
 
{
2388
 
  /*
2389
 
    determine which method will be used for table opening
2390
 
  */
2391
 
  if (schema_table->i_s_requested_object & OPTIMIZE_I_S_TABLE)
2392
 
  {
2393
 
    Field **ptr, *field;
2394
 
    int table_open_method= 0, field_indx= 0;
2395
 
    for (ptr=tables->table->field; (field= *ptr) ; ptr++)
2396
 
    {
2397
 
      if (bitmap_is_set(tables->table->read_set, field->field_index))
2398
 
        table_open_method|= schema_table->fields_info[field_indx].open_method;
2399
 
      field_indx++;
2400
 
    }
2401
 
    return table_open_method;
2402
 
  }
2403
 
  /* I_S tables which use get_all_tables but can not be optimized */
2404
 
  return (uint) OPEN_FULL_TABLE;
2405
 
}
2406
 
 
2407
 
 
2408
 
/**
2409
 
  @brief          Fill I_S table with data from FRM file only
2410
 
 
2411
 
  @param[in]      thd                      thread handler
2412
 
  @param[in]      table                    TABLE struct for I_S table
2413
 
  @param[in]      schema_table             I_S table struct
2414
 
  @param[in]      db_name                  database name
2415
 
  @param[in]      table_name               table name
2416
 
  @param[in]      schema_table_idx         I_S table index
2417
 
 
2418
 
  @return         Operation status
2419
 
    @retval       0           Table is processed and we can continue
2420
 
                              with new table
2421
 
    @retval       1           It's view and we have to use
2422
 
                              open_tables function for this table
2423
 
*/
2424
 
 
2425
 
static int fill_schema_table_from_frm(THD *thd,TABLE_LIST *tables,
2426
 
                                      ST_SCHEMA_TABLE *schema_table,
2427
 
                                      LEX_STRING *db_name,
2428
 
                                      LEX_STRING *table_name,
2429
 
                                      enum enum_schema_tables schema_table_idx __attribute__((unused)))
2430
 
{
2431
 
  TABLE *table= tables->table;
2432
 
  TABLE_SHARE *share;
2433
 
  TABLE tbl;
2434
 
  TABLE_LIST table_list;
2435
 
  uint res= 0;
2436
 
  int error;
2437
 
  char key[MAX_DBKEY_LENGTH];
2438
 
  uint key_length;
2439
 
 
2440
 
  memset(&table_list, 0, sizeof(TABLE_LIST));
2441
 
  memset(&tbl, 0, sizeof(TABLE));
2442
 
 
2443
 
  table_list.table_name= table_name->str;
2444
 
  table_list.db= db_name->str;
2445
 
 
2446
 
  key_length= create_table_def_key(thd, key, &table_list, 0);
2447
 
  pthread_mutex_lock(&LOCK_open);
2448
 
  share= get_table_share(thd, &table_list, key,
2449
 
                         key_length, OPEN_VIEW, &error);
2450
 
  if (!share)
2451
 
  {
2452
 
    res= 0;
2453
 
    goto err;
2454
 
  }
2455
 
 
2456
 
  {
2457
 
    tbl.s= share;
2458
 
    table_list.table= &tbl;
2459
 
    res= schema_table->process_table(thd, &table_list, table,
2460
 
                                     res, db_name, table_name);
2461
 
  }
2462
 
 
2463
 
  release_table_share(share, RELEASE_NORMAL);
2464
 
 
2465
 
err:
2466
 
  pthread_mutex_unlock(&LOCK_open);
2467
 
  thd->clear_error();
2468
 
  return res;
2469
 
}
2470
 
 
2471
 
 
2472
 
 
2473
 
/**
2474
 
  @brief          Fill I_S tables whose data are retrieved
2475
 
                  from frm files and storage engine
2476
 
 
2477
 
  @details        The information schema tables are internally represented as
2478
 
                  temporary tables that are filled at query execution time.
2479
 
                  Those I_S tables whose data are retrieved
2480
 
                  from frm files and storage engine are filled by the function
2481
 
                  get_all_tables().
2482
 
 
2483
 
  @param[in]      thd                      thread handler
2484
 
  @param[in]      tables                   I_S table
2485
 
  @param[in]      cond                     'WHERE' condition
2486
 
 
2487
 
  @return         Operation status
2488
 
    @retval       0                        success
2489
 
    @retval       1                        error
2490
 
*/
2491
 
 
2492
 
int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
2493
 
{
2494
 
  LEX *lex= thd->lex;
2495
 
  TABLE *table= tables->table;
2496
 
  SELECT_LEX *old_all_select_lex= lex->all_selects_list;
2497
 
  enum_sql_command save_sql_command= lex->sql_command;
2498
 
  SELECT_LEX *lsel= tables->schema_select_lex;
2499
 
  ST_SCHEMA_TABLE *schema_table= tables->schema_table;
2500
 
  SELECT_LEX sel;
2501
 
  LOOKUP_FIELD_VALUES lookup_field_vals;
2502
 
  LEX_STRING *db_name, *table_name;
2503
 
  bool with_i_schema;
2504
 
  enum enum_schema_tables schema_table_idx;
2505
 
  List<LEX_STRING> db_names;
2506
 
  List_iterator_fast<LEX_STRING> it(db_names);
2507
 
  COND *partial_cond= 0;
2508
 
  uint derived_tables= lex->derived_tables; 
2509
 
  int error= 1;
2510
 
  Open_tables_state open_tables_state_backup;
2511
 
  Query_tables_list query_tables_list_backup;
2512
 
  uint table_open_method;
2513
 
  bool old_value= thd->no_warnings_for_error;
2514
 
 
2515
 
  lex->reset_n_backup_query_tables_list(&query_tables_list_backup);
2516
 
 
2517
 
  /*
2518
 
    We should not introduce deadlocks even if we already have some
2519
 
    tables open and locked, since we won't lock tables which we will
2520
 
    open and will ignore possible name-locks for these tables.
2521
 
  */
2522
 
  thd->reset_n_backup_open_tables_state(&open_tables_state_backup);
2523
 
 
2524
 
  schema_table_idx= get_schema_table_idx(schema_table);
2525
 
  tables->table_open_method= table_open_method=
2526
 
    get_table_open_method(tables, schema_table, schema_table_idx);
2527
 
  /* 
2528
 
    this branch processes SHOW FIELDS, SHOW INDEXES commands.
2529
 
    see sql_parse.cc, prepare_schema_table() function where
2530
 
    this values are initialized
2531
 
  */
2532
 
  if (lsel && lsel->table_list.first)
2533
 
  {
2534
 
    error= fill_schema_show_cols_or_idxs(thd, tables, schema_table,
2535
 
                                         &open_tables_state_backup);
2536
 
    goto err;
2537
 
  }
2538
 
 
2539
 
  if (get_lookup_field_values(thd, cond, tables, &lookup_field_vals))
2540
 
  {
2541
 
    error= 0;
2542
 
    goto err;
2543
 
  }
2544
 
 
2545
 
  if (!lookup_field_vals.wild_db_value && !lookup_field_vals.wild_table_value)
2546
 
  {
2547
 
    /* 
2548
 
      if lookup value is empty string then
2549
 
      it's impossible table name or db name
2550
 
    */
2551
 
    if ((lookup_field_vals.db_value.str && !lookup_field_vals.db_value.str[0]) ||
2552
 
        (lookup_field_vals.table_value.str && !lookup_field_vals.table_value.str[0]))
2553
 
    {
2554
 
      error= 0;
2555
 
      goto err;
2556
 
    }
2557
 
  }
2558
 
 
2559
 
  if (lookup_field_vals.db_value.length &&
2560
 
      !lookup_field_vals.wild_db_value)
2561
 
    tables->has_db_lookup_value= true;
2562
 
  if (lookup_field_vals.table_value.length &&
2563
 
      !lookup_field_vals.wild_table_value) 
2564
 
    tables->has_table_lookup_value= true;
2565
 
 
2566
 
  if (tables->has_db_lookup_value && tables->has_table_lookup_value)
2567
 
    partial_cond= 0;
2568
 
  else
2569
 
    partial_cond= make_cond_for_info_schema(cond, tables);
2570
 
 
2571
 
  if (lex->describe)
2572
 
  {
2573
 
    /* EXPLAIN SELECT */
2574
 
    error= 0;
2575
 
    goto err;
2576
 
  }
2577
 
 
2578
 
  if (make_db_list(thd, &db_names, &lookup_field_vals, &with_i_schema))
2579
 
    goto err;
2580
 
  it.rewind(); /* To get access to new elements in basis list */
2581
 
  while ((db_name= it++))
2582
 
  {
2583
 
    {
2584
 
      thd->no_warnings_for_error= 1;
2585
 
      List<LEX_STRING> table_names;
2586
 
      int res= make_table_name_list(thd, &table_names, lex,
2587
 
                                    &lookup_field_vals,
2588
 
                                    with_i_schema, db_name);
2589
 
      if (res == 2)   /* Not fatal error, continue */
2590
 
        continue;
2591
 
      if (res)
2592
 
        goto err;
2593
 
 
2594
 
      List_iterator_fast<LEX_STRING> it_files(table_names);
2595
 
      while ((table_name= it_files++))
2596
 
      {
2597
 
        restore_record(table, s->default_values);
2598
 
        table->field[schema_table->idx_field1]->
2599
 
          store(db_name->str, db_name->length, system_charset_info);
2600
 
        table->field[schema_table->idx_field2]->
2601
 
          store(table_name->str, table_name->length, system_charset_info);
2602
 
 
2603
 
        if (!partial_cond || partial_cond->val_int())
2604
 
        {
2605
 
          /*
2606
 
            If table is I_S.tables and open_table_method is 0 (eg SKIP_OPEN)
2607
 
            we can skip table opening and we don't have lookup value for 
2608
 
            table name or lookup value is wild string(table name list is
2609
 
            already created by make_table_name_list() function).
2610
 
          */
2611
 
          if (!table_open_method && schema_table_idx == SCH_TABLES &&
2612
 
              (!lookup_field_vals.table_value.length ||
2613
 
               lookup_field_vals.wild_table_value))
2614
 
          {
2615
 
            if (schema_table_store_record(thd, table))
2616
 
              goto err;      /* Out of space in temporary table */
2617
 
            continue;
2618
 
          }
2619
 
 
2620
 
          /* SHOW TABLE NAMES command */
2621
 
          if (schema_table_idx == SCH_TABLE_NAMES)
2622
 
          {
2623
 
            if (fill_schema_table_names(thd, tables->table, db_name,
2624
 
                                        table_name, with_i_schema))
2625
 
              continue;
2626
 
          }
2627
 
          else
2628
 
          {
2629
 
            if (!(table_open_method & ~OPEN_FRM_ONLY) &&
2630
 
                !with_i_schema)
2631
 
            {
2632
 
              if (!fill_schema_table_from_frm(thd, tables, schema_table, db_name,
2633
 
                                              table_name, schema_table_idx))
2634
 
                continue;
2635
 
            }
2636
 
 
2637
 
            int res;
2638
 
            LEX_STRING tmp_lex_string, orig_db_name;
2639
 
            /*
2640
 
              Set the parent lex of 'sel' because it is needed by
2641
 
              sel.init_query() which is called inside make_table_list.
2642
 
            */
2643
 
            thd->no_warnings_for_error= 1;
2644
 
            sel.parent_lex= lex;
2645
 
            /* db_name can be changed in make_table_list() func */
2646
 
            if (!thd->make_lex_string(&orig_db_name, db_name->str,
2647
 
                                      db_name->length, false))
2648
 
              goto err;
2649
 
            if (make_table_list(thd, &sel, db_name, table_name))
2650
 
              goto err;
2651
 
            TABLE_LIST *show_table_list= (TABLE_LIST*) sel.table_list.first;
2652
 
            lex->all_selects_list= &sel;
2653
 
            lex->derived_tables= 0;
2654
 
            lex->sql_command= SQLCOM_SHOW_FIELDS;
2655
 
            show_table_list->i_s_requested_object=
2656
 
              schema_table->i_s_requested_object;
2657
 
            res= open_normal_and_derived_tables(thd, show_table_list,
2658
 
                                                DRIZZLE_LOCK_IGNORE_FLUSH);
2659
 
            lex->sql_command= save_sql_command;
2660
 
            /*
2661
 
              XXX:  show_table_list has a flag i_is_requested,
2662
 
              and when it's set, open_normal_and_derived_tables()
2663
 
              can return an error without setting an error message
2664
 
              in THD, which is a hack. This is why we have to
2665
 
              check for res, then for thd->is_error() only then
2666
 
              for thd->main_da.sql_errno().
2667
 
            */
2668
 
            if (res && thd->is_error() &&
2669
 
                thd->main_da.sql_errno() == ER_NO_SUCH_TABLE)
2670
 
            {
2671
 
              /*
2672
 
                Hide error for not existing table.
2673
 
                This error can occur for example when we use
2674
 
                where condition with db name and table name and this
2675
 
                table does not exist.
2676
 
              */
2677
 
              res= 0;
2678
 
              thd->clear_error();
2679
 
            }
2680
 
            else
2681
 
            {
2682
 
              /*
2683
 
                We should use show_table_list->alias instead of 
2684
 
                show_table_list->table_name because table_name
2685
 
                could be changed during opening of I_S tables. It's safe
2686
 
                to use alias because alias contains original table name 
2687
 
                in this case.
2688
 
              */
2689
 
              thd->make_lex_string(&tmp_lex_string, show_table_list->alias,
2690
 
                                   strlen(show_table_list->alias), false);
2691
 
              res= schema_table->process_table(thd, show_table_list, table,
2692
 
                                               res, &orig_db_name,
2693
 
                                               &tmp_lex_string);
2694
 
              close_tables_for_reopen(thd, &show_table_list);
2695
 
            }
2696
 
            assert(!lex->query_tables_own_last);
2697
 
            if (res)
2698
 
              goto err;
2699
 
          }
2700
 
        }
2701
 
      }
2702
 
      /*
2703
 
        If we have information schema its always the first table and only
2704
 
        the first table. Reset for other tables.
2705
 
      */
2706
 
      with_i_schema= 0;
2707
 
    }
2708
 
  }
2709
 
 
2710
 
  error= 0;
2711
 
err:
2712
 
  thd->restore_backup_open_tables_state(&open_tables_state_backup);
2713
 
  lex->restore_backup_query_tables_list(&query_tables_list_backup);
2714
 
  lex->derived_tables= derived_tables;
2715
 
  lex->all_selects_list= old_all_select_lex;
2716
 
  lex->sql_command= save_sql_command;
2717
 
  thd->no_warnings_for_error= old_value;
2718
 
  return(error);
2719
 
}
2720
 
 
2721
 
 
2722
 
bool store_schema_shemata(THD* thd, TABLE *table, LEX_STRING *db_name,
2723
 
                          const CHARSET_INFO * const cs)
2724
 
{
2725
 
  restore_record(table, s->default_values);
2726
 
  table->field[1]->store(db_name->str, db_name->length, system_charset_info);
2727
 
  table->field[2]->store(cs->csname, strlen(cs->csname), system_charset_info);
2728
 
  table->field[3]->store(cs->name, strlen(cs->name), system_charset_info);
2729
 
  return schema_table_store_record(thd, table);
2730
 
}
2731
 
 
2732
 
 
2733
 
int fill_schema_schemata(THD *thd, TABLE_LIST *tables, COND *cond)
2734
 
{
2735
 
  /*
2736
 
    TODO: fill_schema_shemata() is called when new client is connected.
2737
 
    Returning error status in this case leads to client hangup.
2738
 
  */
2739
 
 
2740
 
  LOOKUP_FIELD_VALUES lookup_field_vals;
2741
 
  List<LEX_STRING> db_names;
2742
 
  LEX_STRING *db_name;
2743
 
  bool with_i_schema;
2744
 
  HA_CREATE_INFO create;
2745
 
  TABLE *table= tables->table;
2746
 
 
2747
 
  if (get_lookup_field_values(thd, cond, tables, &lookup_field_vals))
2748
 
    return(0);
2749
 
  if (make_db_list(thd, &db_names, &lookup_field_vals,
2750
 
                   &with_i_schema))
2751
 
    return(1);
2752
 
 
2753
 
  /*
2754
 
    If we have lookup db value we should check that the database exists
2755
 
  */
2756
 
  if(lookup_field_vals.db_value.str && !lookup_field_vals.wild_db_value &&
2757
 
     !with_i_schema)
2758
 
  {
2759
 
    char path[FN_REFLEN+16];
2760
 
    uint path_len;
2761
 
    struct stat stat_info;
2762
 
    if (!lookup_field_vals.db_value.str[0])
2763
 
      return(0);
2764
 
    path_len= build_table_filename(path, sizeof(path),
2765
 
                                   lookup_field_vals.db_value.str, "", "", 0);
2766
 
    path[path_len-1]= 0;
2767
 
    if (stat(path,&stat_info))
2768
 
      return(0);
2769
 
  }
2770
 
 
2771
 
  List_iterator_fast<LEX_STRING> it(db_names);
2772
 
  while ((db_name=it++))
2773
 
  {
2774
 
    if (with_i_schema)       // information schema name is always first in list
2775
 
    {
2776
 
      if (store_schema_shemata(thd, table, db_name,
2777
 
                               system_charset_info))
2778
 
        return(1);
2779
 
      with_i_schema= 0;
2780
 
      continue;
2781
 
    }
2782
 
    {
2783
 
      load_db_opt_by_name(thd, db_name->str, &create);
2784
 
      if (store_schema_shemata(thd, table, db_name,
2785
 
                               create.default_table_charset))
2786
 
        return(1);
2787
 
    }
2788
 
  }
2789
 
  return(0);
2790
 
}
2791
 
 
2792
 
 
2793
 
static int get_schema_tables_record(THD *thd, TABLE_LIST *tables,
2794
 
                                    TABLE *table, bool res,
2795
 
                                    LEX_STRING *db_name,
2796
 
                                    LEX_STRING *table_name)
2797
 
{
2798
 
  const char *tmp_buff;
2799
 
  DRIZZLE_TIME time;
2800
 
  const CHARSET_INFO * const cs= system_charset_info;
2801
 
 
2802
 
  restore_record(table, s->default_values);
2803
 
  table->field[1]->store(db_name->str, db_name->length, cs);
2804
 
  table->field[2]->store(table_name->str, table_name->length, cs);
2805
 
  if (res)
2806
 
  {
2807
 
    /*
2808
 
      there was errors during opening tables
2809
 
    */
2810
 
    const char *error= thd->is_error() ? thd->main_da.message() : "";
2811
 
    if (tables->schema_table)
2812
 
      table->field[3]->store(STRING_WITH_LEN("SYSTEM VIEW"), cs);
2813
 
    else
2814
 
      table->field[3]->store(STRING_WITH_LEN("BASE TABLE"), cs);
2815
 
    table->field[20]->store(error, strlen(error), cs);
2816
 
    thd->clear_error();
2817
 
  }
2818
 
  else
2819
 
  {
2820
 
    char option_buff[400],*ptr;
2821
 
    TABLE *show_table= tables->table;
2822
 
    TABLE_SHARE *share= show_table->s;
2823
 
    handler *file= show_table->file;
2824
 
    handlerton *tmp_db_type= share->db_type();
2825
 
    if (share->tmp_table == SYSTEM_TMP_TABLE)
2826
 
      table->field[3]->store(STRING_WITH_LEN("SYSTEM VIEW"), cs);
2827
 
    else if (share->tmp_table)
2828
 
      table->field[3]->store(STRING_WITH_LEN("LOCAL TEMPORARY"), cs);
2829
 
    else
2830
 
      table->field[3]->store(STRING_WITH_LEN("BASE TABLE"), cs);
2831
 
 
2832
 
    for (int i= 4; i < 20; i++)
2833
 
    {
2834
 
      if (i == 7 || (i > 12 && i < 17) || i == 18)
2835
 
        continue;
2836
 
      table->field[i]->set_notnull();
2837
 
    }
2838
 
    tmp_buff= (char *) ha_resolve_storage_engine_name(tmp_db_type);
2839
 
    table->field[4]->store(tmp_buff, strlen(tmp_buff), cs);
2840
 
    table->field[5]->store((int64_t) share->frm_version, true);
2841
 
 
2842
 
    ptr=option_buff;
2843
 
    if (share->min_rows)
2844
 
    {
2845
 
      ptr=stpcpy(ptr," min_rows=");
2846
 
      ptr=int64_t10_to_str(share->min_rows,ptr,10);
2847
 
    }
2848
 
    if (share->max_rows)
2849
 
    {
2850
 
      ptr=stpcpy(ptr," max_rows=");
2851
 
      ptr=int64_t10_to_str(share->max_rows,ptr,10);
2852
 
    }
2853
 
    if (share->avg_row_length)
2854
 
    {
2855
 
      ptr=stpcpy(ptr," avg_row_length=");
2856
 
      ptr=int64_t10_to_str(share->avg_row_length,ptr,10);
2857
 
    }
2858
 
    if (share->db_create_options & HA_OPTION_PACK_KEYS)
2859
 
      ptr=stpcpy(ptr," pack_keys=1");
2860
 
    if (share->db_create_options & HA_OPTION_NO_PACK_KEYS)
2861
 
      ptr=stpcpy(ptr," pack_keys=0");
2862
 
    /* We use CHECKSUM, instead of TABLE_CHECKSUM, for backward compability */
2863
 
    if (share->db_create_options & HA_OPTION_CHECKSUM)
2864
 
      ptr=stpcpy(ptr," checksum=1");
2865
 
    if (share->page_checksum != HA_CHOICE_UNDEF)
2866
 
      ptr= strxmov(ptr, " page_checksum=",
2867
 
                   ha_choice_values[(uint) share->page_checksum], NullS);
2868
 
    if (share->db_create_options & HA_OPTION_DELAY_KEY_WRITE)
2869
 
      ptr=stpcpy(ptr," delay_key_write=1");
2870
 
    if (share->row_type != ROW_TYPE_DEFAULT)
2871
 
      ptr=strxmov(ptr, " row_format=", 
2872
 
                  ha_row_type[(uint) share->row_type],
2873
 
                  NullS);
2874
 
    if (share->block_size)
2875
 
    {
2876
 
      ptr= stpcpy(ptr, " block_size=");
2877
 
      ptr= int64_t10_to_str(share->block_size, ptr, 10);
2878
 
    }
2879
 
    
2880
 
    if (share->transactional != HA_CHOICE_UNDEF)
2881
 
    {
2882
 
      ptr= strxmov(ptr, " TRANSACTIONAL=",
2883
 
                   (share->transactional == HA_CHOICE_YES ? "1" : "0"),
2884
 
                   NullS);
2885
 
    }
2886
 
    if (share->transactional != HA_CHOICE_UNDEF)
2887
 
      ptr= strxmov(ptr, " transactional=",
2888
 
                   ha_choice_values[(uint) share->transactional], NullS);
2889
 
    table->field[19]->store(option_buff+1,
2890
 
                            (ptr == option_buff ? 0 : 
2891
 
                             (uint) (ptr-option_buff)-1), cs);
2892
 
 
2893
 
    tmp_buff= (share->table_charset ?
2894
 
               share->table_charset->name : "default");
2895
 
    table->field[17]->store(tmp_buff, strlen(tmp_buff), cs);
2896
 
 
2897
 
    if (share->comment.str)
2898
 
      table->field[20]->store(share->comment.str, share->comment.length, cs);
2899
 
 
2900
 
    if(file)
2901
 
    {
2902
 
      file->info(HA_STATUS_VARIABLE | HA_STATUS_TIME | HA_STATUS_AUTO |
2903
 
                 HA_STATUS_NO_LOCK);
2904
 
      enum row_type row_type = file->get_row_type();
2905
 
      switch (row_type) {
2906
 
      case ROW_TYPE_NOT_USED:
2907
 
      case ROW_TYPE_DEFAULT:
2908
 
        tmp_buff= ((share->db_options_in_use &
2909
 
                    HA_OPTION_COMPRESS_RECORD) ? "Compressed" :
2910
 
                   (share->db_options_in_use & HA_OPTION_PACK_RECORD) ?
2911
 
                   "Dynamic" : "Fixed");
2912
 
        break;
2913
 
      case ROW_TYPE_FIXED:
2914
 
        tmp_buff= "Fixed";
2915
 
        break;
2916
 
      case ROW_TYPE_DYNAMIC:
2917
 
        tmp_buff= "Dynamic";
2918
 
        break;
2919
 
      case ROW_TYPE_COMPRESSED:
2920
 
        tmp_buff= "Compressed";
2921
 
        break;
2922
 
      case ROW_TYPE_REDUNDANT:
2923
 
        tmp_buff= "Redundant";
2924
 
        break;
2925
 
      case ROW_TYPE_COMPACT:
2926
 
        tmp_buff= "Compact";
2927
 
        break;
2928
 
      case ROW_TYPE_PAGE:
2929
 
        tmp_buff= "Paged";
2930
 
        break;
2931
 
      }
2932
 
      table->field[6]->store(tmp_buff, strlen(tmp_buff), cs);
2933
 
      if (!tables->schema_table)
2934
 
      {
2935
 
        table->field[7]->store((int64_t) file->stats.records, true);
2936
 
        table->field[7]->set_notnull();
2937
 
      }
2938
 
      table->field[8]->store((int64_t) file->stats.mean_rec_length, true);
2939
 
      table->field[9]->store((int64_t) file->stats.data_file_length, true);
2940
 
      if (file->stats.max_data_file_length)
2941
 
      {
2942
 
        table->field[10]->store((int64_t) file->stats.max_data_file_length,
2943
 
                                true);
2944
 
      }
2945
 
      table->field[11]->store((int64_t) file->stats.index_file_length, true);
2946
 
      table->field[12]->store((int64_t) file->stats.delete_length, true);
2947
 
      if (show_table->found_next_number_field)
2948
 
      {
2949
 
        table->field[13]->store((int64_t) file->stats.auto_increment_value,
2950
 
                                true);
2951
 
        table->field[13]->set_notnull();
2952
 
      }
2953
 
      if (file->stats.create_time)
2954
 
      {
2955
 
        thd->variables.time_zone->gmt_sec_to_TIME(&time,
2956
 
                                                  (my_time_t) file->stats.create_time);
2957
 
        table->field[14]->store_time(&time, DRIZZLE_TIMESTAMP_DATETIME);
2958
 
        table->field[14]->set_notnull();
2959
 
      }
2960
 
      if (file->stats.update_time)
2961
 
      {
2962
 
        thd->variables.time_zone->gmt_sec_to_TIME(&time,
2963
 
                                                  (my_time_t) file->stats.update_time);
2964
 
        table->field[15]->store_time(&time, DRIZZLE_TIMESTAMP_DATETIME);
2965
 
        table->field[15]->set_notnull();
2966
 
      }
2967
 
      if (file->stats.check_time)
2968
 
      {
2969
 
        thd->variables.time_zone->gmt_sec_to_TIME(&time,
2970
 
                                                  (my_time_t) file->stats.check_time);
2971
 
        table->field[16]->store_time(&time, DRIZZLE_TIMESTAMP_DATETIME);
2972
 
        table->field[16]->set_notnull();
2973
 
      }
2974
 
      if (file->ha_table_flags() & (ulong) HA_HAS_CHECKSUM)
2975
 
      {
2976
 
        table->field[18]->store((int64_t) file->checksum(), true);
2977
 
        table->field[18]->set_notnull();
2978
 
      }
2979
 
    }
2980
 
  }
2981
 
  return(schema_table_store_record(thd, table));
2982
 
}
2983
 
 
2984
 
 
2985
 
/**
2986
 
  @brief    Store field characteristics into appropriate I_S table columns
2987
 
 
2988
 
  @param[in]      table             I_S table
2989
 
  @param[in]      field             processed field
2990
 
  @param[in]      cs                I_S table charset
2991
 
  @param[in]      offset            offset from beginning of table
2992
 
                                    to DATE_TYPE column in I_S table
2993
 
                                    
2994
 
  @return         void
2995
 
*/
2996
 
 
2997
 
void store_column_type(TABLE *table, Field *field, const CHARSET_INFO * const cs,
2998
 
                       uint offset)
2999
 
{
3000
 
  bool is_blob;
3001
 
  int decimals, field_length;
3002
 
  const char *tmp_buff;
3003
 
  char column_type_buff[MAX_FIELD_WIDTH];
3004
 
  String column_type(column_type_buff, sizeof(column_type_buff), cs);
3005
 
 
3006
 
  field->sql_type(column_type);
3007
 
  /* DTD_IDENTIFIER column */
3008
 
  table->field[offset + 7]->store(column_type.ptr(), column_type.length(), cs);
3009
 
  table->field[offset + 7]->set_notnull();
3010
 
  tmp_buff= strchr(column_type.ptr(), '(');
3011
 
  /* DATA_TYPE column */
3012
 
  table->field[offset]->store(column_type.ptr(),
3013
 
                         (tmp_buff ? tmp_buff - column_type.ptr() :
3014
 
                          column_type.length()), cs);
3015
 
  is_blob= (field->type() == DRIZZLE_TYPE_BLOB);
3016
 
  if (field->has_charset() || is_blob ||
3017
 
      field->real_type() == DRIZZLE_TYPE_VARCHAR)  // For varbinary type
3018
 
  {
3019
 
    uint32_t octet_max_length= field->max_display_length();
3020
 
    if (is_blob && octet_max_length != (uint32_t) 4294967295U)
3021
 
      octet_max_length /= field->charset()->mbmaxlen;
3022
 
    int64_t char_max_len= is_blob ? 
3023
 
      (int64_t) octet_max_length / field->charset()->mbminlen :
3024
 
      (int64_t) octet_max_length / field->charset()->mbmaxlen;
3025
 
    /* CHARACTER_MAXIMUM_LENGTH column*/
3026
 
    table->field[offset + 1]->store(char_max_len, true);
3027
 
    table->field[offset + 1]->set_notnull();
3028
 
    /* CHARACTER_OCTET_LENGTH column */
3029
 
    table->field[offset + 2]->store((int64_t) octet_max_length, true);
3030
 
    table->field[offset + 2]->set_notnull();
3031
 
  }
3032
 
 
3033
 
  /*
3034
 
    Calculate field_length and decimals.
3035
 
    They are set to -1 if they should not be set (we should return NULL)
3036
 
  */
3037
 
 
3038
 
  decimals= field->decimals();
3039
 
  switch (field->type()) {
3040
 
  case DRIZZLE_TYPE_NEWDECIMAL:
3041
 
    field_length= ((Field_new_decimal*) field)->precision;
3042
 
    break;
3043
 
  case DRIZZLE_TYPE_TINY:
3044
 
  case DRIZZLE_TYPE_SHORT:
3045
 
  case DRIZZLE_TYPE_LONG:
3046
 
  case DRIZZLE_TYPE_LONGLONG:
3047
 
    field_length= field->max_display_length() - 1;
3048
 
    break;
3049
 
  case DRIZZLE_TYPE_DOUBLE:
3050
 
    field_length= field->field_length;
3051
 
    if (decimals == NOT_FIXED_DEC)
3052
 
      decimals= -1;                           // return NULL
3053
 
    break;
3054
 
  default:
3055
 
    field_length= decimals= -1;
3056
 
    break;
3057
 
  }
3058
 
 
3059
 
  /* NUMERIC_PRECISION column */
3060
 
  if (field_length >= 0)
3061
 
  {
3062
 
    table->field[offset + 3]->store((int64_t) field_length, true);
3063
 
    table->field[offset + 3]->set_notnull();
3064
 
  }
3065
 
  /* NUMERIC_SCALE column */
3066
 
  if (decimals >= 0)
3067
 
  {
3068
 
    table->field[offset + 4]->store((int64_t) decimals, true);
3069
 
    table->field[offset + 4]->set_notnull();
3070
 
  }
3071
 
  if (field->has_charset())
3072
 
  {
3073
 
    /* CHARACTER_SET_NAME column*/
3074
 
    tmp_buff= field->charset()->csname;
3075
 
    table->field[offset + 5]->store(tmp_buff, strlen(tmp_buff), cs);
3076
 
    table->field[offset + 5]->set_notnull();
3077
 
    /* COLLATION_NAME column */
3078
 
    tmp_buff= field->charset()->name;
3079
 
    table->field[offset + 6]->store(tmp_buff, strlen(tmp_buff), cs);
3080
 
    table->field[offset + 6]->set_notnull();
3081
 
  }
3082
 
}
3083
 
 
3084
 
 
3085
 
static int get_schema_column_record(THD *thd, TABLE_LIST *tables,
3086
 
                                    TABLE *table, bool res,
3087
 
                                    LEX_STRING *db_name,
3088
 
                                    LEX_STRING *table_name)
3089
 
{
3090
 
  LEX *lex= thd->lex;
3091
 
  const char *wild= lex->wild ? lex->wild->ptr() : NullS;
3092
 
  const CHARSET_INFO * const cs= system_charset_info;
3093
 
  TABLE *show_table;
3094
 
  TABLE_SHARE *show_table_share;
3095
 
  Field **ptr, *field, *timestamp_field;
3096
 
  int count;
3097
 
 
3098
 
  if (res)
3099
 
  {
3100
 
    if (lex->sql_command != SQLCOM_SHOW_FIELDS)
3101
 
    {
3102
 
      /*
3103
 
        I.e. we are in SELECT FROM INFORMATION_SCHEMA.COLUMS
3104
 
        rather than in SHOW COLUMNS
3105
 
      */ 
3106
 
      if (thd->is_error())
3107
 
        push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
3108
 
                     thd->main_da.sql_errno(), thd->main_da.message());
3109
 
      thd->clear_error();
3110
 
      res= 0;
3111
 
    }
3112
 
    return(res);
3113
 
  }
3114
 
 
3115
 
  show_table= tables->table;
3116
 
  show_table_share= show_table->s;
3117
 
  count= 0;
3118
 
 
3119
 
  if (tables->schema_table)
3120
 
  {
3121
 
    ptr= show_table->field;
3122
 
    timestamp_field= show_table->timestamp_field;
3123
 
    show_table->use_all_columns();               // Required for default
3124
 
  }
3125
 
  else
3126
 
  {
3127
 
    ptr= show_table_share->field;
3128
 
    timestamp_field= show_table_share->timestamp_field;
3129
 
    /*
3130
 
      read_set may be inited in case of
3131
 
      temporary table
3132
 
    */
3133
 
    if (!show_table->read_set)
3134
 
    {
3135
 
      /* to satisfy 'field->val_str' ASSERTs */
3136
 
      uchar *bitmaps;
3137
 
      uint bitmap_size= show_table_share->column_bitmap_size;
3138
 
      if (!(bitmaps= (uchar*) alloc_root(thd->mem_root, bitmap_size)))
3139
 
        return(0);
3140
 
      bitmap_init(&show_table->def_read_set,
3141
 
                  (my_bitmap_map*) bitmaps, show_table_share->fields, false);
3142
 
      bitmap_set_all(&show_table->def_read_set);
3143
 
      show_table->read_set= &show_table->def_read_set;
3144
 
    }
3145
 
    bitmap_set_all(show_table->read_set);
3146
 
  }
3147
 
 
3148
 
  for (; (field= *ptr) ; ptr++)
3149
 
  {
3150
 
    uchar *pos;
3151
 
    char tmp[MAX_FIELD_WIDTH];
3152
 
    String type(tmp,sizeof(tmp), system_charset_info);
3153
 
    char *end;
3154
 
 
3155
 
    /* to satisfy 'field->val_str' ASSERTs */
3156
 
    field->table= show_table;
3157
 
    show_table->in_use= thd;
3158
 
 
3159
 
    if (wild && wild[0] &&
3160
 
        wild_case_compare(system_charset_info, field->field_name,wild))
3161
 
      continue;
3162
 
 
3163
 
    count++;
3164
 
    /* Get default row, with all NULL fields set to NULL */
3165
 
    restore_record(table, s->default_values);
3166
 
 
3167
 
    table->field[1]->store(db_name->str, db_name->length, cs);
3168
 
    table->field[2]->store(table_name->str, table_name->length, cs);
3169
 
    table->field[3]->store(field->field_name, strlen(field->field_name),
3170
 
                           cs);
3171
 
    table->field[4]->store((int64_t) count, true);
3172
 
 
3173
 
    if (get_field_default_value(thd, timestamp_field, field, &type, 0))
3174
 
    {
3175
 
      table->field[5]->store(type.ptr(), type.length(), cs);
3176
 
      table->field[5]->set_notnull();
3177
 
    }
3178
 
    pos=(uchar*) ((field->flags & NOT_NULL_FLAG) ?  "NO" : "YES");
3179
 
    table->field[6]->store((const char*) pos,
3180
 
                           strlen((const char*) pos), cs);
3181
 
    store_column_type(table, field, cs, 7);
3182
 
 
3183
 
    pos=(uchar*) ((field->flags & PRI_KEY_FLAG) ? "PRI" :
3184
 
                 (field->flags & UNIQUE_KEY_FLAG) ? "UNI" :
3185
 
                 (field->flags & MULTIPLE_KEY_FLAG) ? "MUL":"");
3186
 
    table->field[15]->store((const char*) pos,
3187
 
                            strlen((const char*) pos), cs);
3188
 
 
3189
 
    end= tmp;
3190
 
    if (field->unireg_check == Field::NEXT_NUMBER)
3191
 
      table->field[16]->store(STRING_WITH_LEN("auto_increment"), cs);
3192
 
    if (timestamp_field == field &&
3193
 
        field->unireg_check != Field::TIMESTAMP_DN_FIELD)
3194
 
      table->field[16]->store(STRING_WITH_LEN("on update CURRENT_TIMESTAMP"),
3195
 
                              cs);
3196
 
 
3197
 
    table->field[18]->store(field->comment.str, field->comment.length, cs);
3198
 
    {
3199
 
      enum column_format_type column_format= (enum column_format_type)
3200
 
        ((field->flags >> COLUMN_FORMAT_FLAGS) & COLUMN_FORMAT_MASK);
3201
 
      pos=(uchar*)"Default";
3202
 
      table->field[19]->store((const char*) pos,
3203
 
                              strlen((const char*) pos), cs);
3204
 
      pos=(uchar*)(column_format == COLUMN_FORMAT_TYPE_DEFAULT ? "Default" :
3205
 
                   column_format == COLUMN_FORMAT_TYPE_FIXED ? "Fixed" :
3206
 
                                                             "Dynamic");
3207
 
      table->field[20]->store((const char*) pos,
3208
 
                              strlen((const char*) pos), cs);
3209
 
    }
3210
 
    if (schema_table_store_record(thd, table))
3211
 
      return(1);
3212
 
  }
3213
 
  return(0);
3214
 
}
3215
 
 
3216
 
 
3217
 
 
3218
 
int fill_schema_charsets(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((unused)))
3219
 
{
3220
 
  CHARSET_INFO **cs;
3221
 
  const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS;
3222
 
  TABLE *table= tables->table;
3223
 
  const CHARSET_INFO * const scs= system_charset_info;
3224
 
 
3225
 
  for (cs= all_charsets ; cs < all_charsets+255 ; cs++)
3226
 
  {
3227
 
    const CHARSET_INFO * const tmp_cs= cs[0];
3228
 
    if (tmp_cs && (tmp_cs->state & MY_CS_PRIMARY) && 
3229
 
        (tmp_cs->state & MY_CS_AVAILABLE) &&
3230
 
        !(tmp_cs->state & MY_CS_HIDDEN) &&
3231
 
        !(wild && wild[0] &&
3232
 
          wild_case_compare(scs, tmp_cs->csname,wild)))
3233
 
    {
3234
 
      const char *comment;
3235
 
      restore_record(table, s->default_values);
3236
 
      table->field[0]->store(tmp_cs->csname, strlen(tmp_cs->csname), scs);
3237
 
      table->field[1]->store(tmp_cs->name, strlen(tmp_cs->name), scs);
3238
 
      comment= tmp_cs->comment ? tmp_cs->comment : "";
3239
 
      table->field[2]->store(comment, strlen(comment), scs);
3240
 
      table->field[3]->store((int64_t) tmp_cs->mbmaxlen, true);
3241
 
      if (schema_table_store_record(thd, table))
3242
 
        return 1;
3243
 
    }
3244
 
  }
3245
 
  return 0;
3246
 
}
3247
 
 
3248
 
 
3249
 
int fill_schema_collation(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((unused)))
3250
 
{
3251
 
  CHARSET_INFO **cs;
3252
 
  const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS;
3253
 
  TABLE *table= tables->table;
3254
 
  const CHARSET_INFO * const scs= system_charset_info;
3255
 
  for (cs= all_charsets ; cs < all_charsets+255 ; cs++ )
3256
 
  {
3257
 
    CHARSET_INFO **cl;
3258
 
    const CHARSET_INFO *tmp_cs= cs[0];
3259
 
    if (!tmp_cs || !(tmp_cs->state & MY_CS_AVAILABLE) ||
3260
 
         (tmp_cs->state & MY_CS_HIDDEN) ||
3261
 
        !(tmp_cs->state & MY_CS_PRIMARY))
3262
 
      continue;
3263
 
    for (cl= all_charsets; cl < all_charsets+255 ;cl ++)
3264
 
    {
3265
 
      const CHARSET_INFO *tmp_cl= cl[0];
3266
 
      if (!tmp_cl || !(tmp_cl->state & MY_CS_AVAILABLE) || 
3267
 
          !my_charset_same(tmp_cs, tmp_cl))
3268
 
        continue;
3269
 
      if (!(wild && wild[0] &&
3270
 
          wild_case_compare(scs, tmp_cl->name,wild)))
3271
 
      {
3272
 
        const char *tmp_buff;
3273
 
        restore_record(table, s->default_values);
3274
 
        table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs);
3275
 
        table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs);
3276
 
        table->field[2]->store((int64_t) tmp_cl->number, true);
3277
 
        tmp_buff= (tmp_cl->state & MY_CS_PRIMARY) ? "Yes" : "";
3278
 
        table->field[3]->store(tmp_buff, strlen(tmp_buff), scs);
3279
 
        tmp_buff= (tmp_cl->state & MY_CS_COMPILED)? "Yes" : "";
3280
 
        table->field[4]->store(tmp_buff, strlen(tmp_buff), scs);
3281
 
        table->field[5]->store((int64_t) tmp_cl->strxfrm_multiply, true);
3282
 
        if (schema_table_store_record(thd, table))
3283
 
          return 1;
3284
 
      }
3285
 
    }
3286
 
  }
3287
 
  return 0;
3288
 
}
3289
 
 
3290
 
 
3291
 
int fill_schema_coll_charset_app(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((unused)))
3292
 
{
3293
 
  CHARSET_INFO **cs;
3294
 
  TABLE *table= tables->table;
3295
 
  const CHARSET_INFO * const scs= system_charset_info;
3296
 
  for (cs= all_charsets ; cs < all_charsets+255 ; cs++ )
3297
 
  {
3298
 
    CHARSET_INFO **cl;
3299
 
    const CHARSET_INFO *tmp_cs= cs[0];
3300
 
    if (!tmp_cs || !(tmp_cs->state & MY_CS_AVAILABLE) || 
3301
 
        !(tmp_cs->state & MY_CS_PRIMARY))
3302
 
      continue;
3303
 
    for (cl= all_charsets; cl < all_charsets+255 ;cl ++)
3304
 
    {
3305
 
      const CHARSET_INFO *tmp_cl= cl[0];
3306
 
      if (!tmp_cl || !(tmp_cl->state & MY_CS_AVAILABLE) || 
3307
 
          !my_charset_same(tmp_cs,tmp_cl))
3308
 
        continue;
3309
 
      restore_record(table, s->default_values);
3310
 
      table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs);
3311
 
      table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs);
3312
 
      if (schema_table_store_record(thd, table))
3313
 
        return 1;
3314
 
    }
3315
 
  }
3316
 
  return 0;
3317
 
}
3318
 
 
3319
 
 
3320
 
static int get_schema_stat_record(THD *thd, TABLE_LIST *tables,
3321
 
                                  TABLE *table, bool res,
3322
 
                                  LEX_STRING *db_name,
3323
 
                                  LEX_STRING *table_name)
3324
 
{
3325
 
  const CHARSET_INFO * const cs= system_charset_info;
3326
 
  if (res)
3327
 
  {
3328
 
    if (thd->lex->sql_command != SQLCOM_SHOW_KEYS)
3329
 
    {
3330
 
      /*
3331
 
        I.e. we are in SELECT FROM INFORMATION_SCHEMA.STATISTICS
3332
 
        rather than in SHOW KEYS
3333
 
      */
3334
 
      if (thd->is_error())
3335
 
        push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
3336
 
                     thd->main_da.sql_errno(), thd->main_da.message());
3337
 
      thd->clear_error();
3338
 
      res= 0;
3339
 
    }
3340
 
    return(res);
3341
 
  }
3342
 
  else
3343
 
  {
3344
 
    TABLE *show_table= tables->table;
3345
 
    KEY *key_info=show_table->s->key_info;
3346
 
    if (show_table->file)
3347
 
      show_table->file->info(HA_STATUS_VARIABLE |
3348
 
                             HA_STATUS_NO_LOCK |
3349
 
                             HA_STATUS_TIME);
3350
 
    for (uint i=0 ; i < show_table->s->keys ; i++,key_info++)
3351
 
    {
3352
 
      KEY_PART_INFO *key_part= key_info->key_part;
3353
 
      const char *str;
3354
 
      for (uint j=0 ; j < key_info->key_parts ; j++,key_part++)
3355
 
      {
3356
 
        restore_record(table, s->default_values);
3357
 
        table->field[1]->store(db_name->str, db_name->length, cs);
3358
 
        table->field[2]->store(table_name->str, table_name->length, cs);
3359
 
        table->field[3]->store((int64_t) ((key_info->flags &
3360
 
                                            HA_NOSAME) ? 0 : 1), true);
3361
 
        table->field[4]->store(db_name->str, db_name->length, cs);
3362
 
        table->field[5]->store(key_info->name, strlen(key_info->name), cs);
3363
 
        table->field[6]->store((int64_t) (j+1), true);
3364
 
        str=(key_part->field ? key_part->field->field_name :
3365
 
             "?unknown field?");
3366
 
        table->field[7]->store(str, strlen(str), cs);
3367
 
        if (show_table->file)
3368
 
        {
3369
 
          if (show_table->file->index_flags(i, j, 0) & HA_READ_ORDER)
3370
 
          {
3371
 
            table->field[8]->store(((key_part->key_part_flag &
3372
 
                                     HA_REVERSE_SORT) ?
3373
 
                                    "D" : "A"), 1, cs);
3374
 
            table->field[8]->set_notnull();
3375
 
          }
3376
 
          KEY *key=show_table->key_info+i;
3377
 
          if (key->rec_per_key[j])
3378
 
          {
3379
 
            ha_rows records=(show_table->file->stats.records /
3380
 
                             key->rec_per_key[j]);
3381
 
            table->field[9]->store((int64_t) records, true);
3382
 
            table->field[9]->set_notnull();
3383
 
          }
3384
 
          str= show_table->file->index_type(i);
3385
 
          table->field[13]->store(str, strlen(str), cs);
3386
 
        }
3387
 
        if ((key_part->field &&
3388
 
             key_part->length !=
3389
 
             show_table->s->field[key_part->fieldnr-1]->key_length()))
3390
 
        {
3391
 
          table->field[10]->store((int64_t) key_part->length /
3392
 
                                  key_part->field->charset()->mbmaxlen, true);
3393
 
          table->field[10]->set_notnull();
3394
 
        }
3395
 
        uint flags= key_part->field ? key_part->field->flags : 0;
3396
 
        const char *pos=(char*) ((flags & NOT_NULL_FLAG) ? "" : "YES");
3397
 
        table->field[12]->store(pos, strlen(pos), cs);
3398
 
        if (!show_table->s->keys_in_use.is_set(i))
3399
 
          table->field[14]->store(STRING_WITH_LEN("disabled"), cs);
3400
 
        else
3401
 
          table->field[14]->store("", 0, cs);
3402
 
        table->field[14]->set_notnull();
3403
 
        assert(test(key_info->flags & HA_USES_COMMENT) == 
3404
 
                   (key_info->comment.length > 0));
3405
 
        if (key_info->flags & HA_USES_COMMENT)
3406
 
          table->field[15]->store(key_info->comment.str, 
3407
 
                                  key_info->comment.length, cs);
3408
 
        if (schema_table_store_record(thd, table))
3409
 
          return(1);
3410
 
      }
3411
 
    }
3412
 
  }
3413
 
  return(res);
3414
 
}
3415
 
 
3416
 
 
3417
 
bool store_constraints(THD *thd, TABLE *table, LEX_STRING *db_name,
3418
 
                       LEX_STRING *table_name, const char *key_name,
3419
 
                       uint key_len, const char *con_type, uint con_len)
3420
 
{
3421
 
  const CHARSET_INFO * const cs= system_charset_info;
3422
 
  restore_record(table, s->default_values);
3423
 
  table->field[1]->store(db_name->str, db_name->length, cs);
3424
 
  table->field[2]->store(key_name, key_len, cs);
3425
 
  table->field[3]->store(db_name->str, db_name->length, cs);
3426
 
  table->field[4]->store(table_name->str, table_name->length, cs);
3427
 
  table->field[5]->store(con_type, con_len, cs);
3428
 
  return schema_table_store_record(thd, table);
3429
 
}
3430
 
 
3431
 
 
3432
 
static int get_schema_constraints_record(THD *thd, TABLE_LIST *tables,
3433
 
                                         TABLE *table, bool res,
3434
 
                                         LEX_STRING *db_name,
3435
 
                                         LEX_STRING *table_name)
3436
 
{
3437
 
  if (res)
3438
 
  {
3439
 
    if (thd->is_error())
3440
 
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
3441
 
                   thd->main_da.sql_errno(), thd->main_da.message());
3442
 
    thd->clear_error();
3443
 
    return(0);
3444
 
  }
3445
 
  else
3446
 
  {
3447
 
    List<FOREIGN_KEY_INFO> f_key_list;
3448
 
    TABLE *show_table= tables->table;
3449
 
    KEY *key_info=show_table->key_info;
3450
 
    uint primary_key= show_table->s->primary_key;
3451
 
    show_table->file->info(HA_STATUS_VARIABLE | 
3452
 
                           HA_STATUS_NO_LOCK |
3453
 
                           HA_STATUS_TIME);
3454
 
    for (uint i=0 ; i < show_table->s->keys ; i++, key_info++)
3455
 
    {
3456
 
      if (i != primary_key && !(key_info->flags & HA_NOSAME))
3457
 
        continue;
3458
 
 
3459
 
      if (i == primary_key && !strcmp(key_info->name, primary_key_name))
3460
 
      {
3461
 
        if (store_constraints(thd, table, db_name, table_name, key_info->name,
3462
 
                              strlen(key_info->name),
3463
 
                              STRING_WITH_LEN("PRIMARY KEY")))
3464
 
          return(1);
3465
 
      }
3466
 
      else if (key_info->flags & HA_NOSAME)
3467
 
      {
3468
 
        if (store_constraints(thd, table, db_name, table_name, key_info->name,
3469
 
                              strlen(key_info->name),
3470
 
                              STRING_WITH_LEN("UNIQUE")))
3471
 
          return(1);
3472
 
      }
3473
 
    }
3474
 
 
3475
 
    show_table->file->get_foreign_key_list(thd, &f_key_list);
3476
 
    FOREIGN_KEY_INFO *f_key_info;
3477
 
    List_iterator_fast<FOREIGN_KEY_INFO> it(f_key_list);
3478
 
    while ((f_key_info=it++))
3479
 
    {
3480
 
      if (store_constraints(thd, table, db_name, table_name, 
3481
 
                            f_key_info->forein_id->str,
3482
 
                            strlen(f_key_info->forein_id->str),
3483
 
                            "FOREIGN KEY", 11))
3484
 
        return(1);
3485
 
    }
3486
 
  }
3487
 
  return(res);
3488
 
}
3489
 
 
3490
 
 
3491
 
void store_key_column_usage(TABLE *table, LEX_STRING *db_name,
3492
 
                            LEX_STRING *table_name, const char *key_name,
3493
 
                            uint key_len, const char *con_type, uint con_len,
3494
 
                            int64_t idx)
3495
 
{
3496
 
  const CHARSET_INFO * const cs= system_charset_info;
3497
 
  table->field[1]->store(db_name->str, db_name->length, cs);
3498
 
  table->field[2]->store(key_name, key_len, cs);
3499
 
  table->field[4]->store(db_name->str, db_name->length, cs);
3500
 
  table->field[5]->store(table_name->str, table_name->length, cs);
3501
 
  table->field[6]->store(con_type, con_len, cs);
3502
 
  table->field[7]->store((int64_t) idx, true);
3503
 
}
3504
 
 
3505
 
 
3506
 
static int get_schema_key_column_usage_record(THD *thd,
3507
 
                                              TABLE_LIST *tables,
3508
 
                                              TABLE *table, bool res,
3509
 
                                              LEX_STRING *db_name,
3510
 
                                              LEX_STRING *table_name)
3511
 
{
3512
 
  if (res)
3513
 
  {
3514
 
    if (thd->is_error())
3515
 
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
3516
 
                   thd->main_da.sql_errno(), thd->main_da.message());
3517
 
    thd->clear_error();
3518
 
    return(0);
3519
 
  }
3520
 
  else
3521
 
  {
3522
 
    List<FOREIGN_KEY_INFO> f_key_list;
3523
 
    TABLE *show_table= tables->table;
3524
 
    KEY *key_info=show_table->key_info;
3525
 
    uint primary_key= show_table->s->primary_key;
3526
 
    show_table->file->info(HA_STATUS_VARIABLE | 
3527
 
                           HA_STATUS_NO_LOCK |
3528
 
                           HA_STATUS_TIME);
3529
 
    for (uint i=0 ; i < show_table->s->keys ; i++, key_info++)
3530
 
    {
3531
 
      if (i != primary_key && !(key_info->flags & HA_NOSAME))
3532
 
        continue;
3533
 
      uint f_idx= 0;
3534
 
      KEY_PART_INFO *key_part= key_info->key_part;
3535
 
      for (uint j=0 ; j < key_info->key_parts ; j++,key_part++)
3536
 
      {
3537
 
        if (key_part->field)
3538
 
        {
3539
 
          f_idx++;
3540
 
          restore_record(table, s->default_values);
3541
 
          store_key_column_usage(table, db_name, table_name,
3542
 
                                 key_info->name,
3543
 
                                 strlen(key_info->name), 
3544
 
                                 key_part->field->field_name, 
3545
 
                                 strlen(key_part->field->field_name),
3546
 
                                 (int64_t) f_idx);
3547
 
          if (schema_table_store_record(thd, table))
3548
 
            return(1);
3549
 
        }
3550
 
      }
3551
 
    }
3552
 
 
3553
 
    show_table->file->get_foreign_key_list(thd, &f_key_list);
3554
 
    FOREIGN_KEY_INFO *f_key_info;
3555
 
    List_iterator_fast<FOREIGN_KEY_INFO> fkey_it(f_key_list);
3556
 
    while ((f_key_info= fkey_it++))
3557
 
    {
3558
 
      LEX_STRING *f_info;
3559
 
      LEX_STRING *r_info;
3560
 
      List_iterator_fast<LEX_STRING> it(f_key_info->foreign_fields),
3561
 
        it1(f_key_info->referenced_fields);
3562
 
      uint f_idx= 0;
3563
 
      while ((f_info= it++))
3564
 
      {
3565
 
        r_info= it1++;
3566
 
        f_idx++;
3567
 
        restore_record(table, s->default_values);
3568
 
        store_key_column_usage(table, db_name, table_name,
3569
 
                               f_key_info->forein_id->str,
3570
 
                               f_key_info->forein_id->length,
3571
 
                               f_info->str, f_info->length,
3572
 
                               (int64_t) f_idx);
3573
 
        table->field[8]->store((int64_t) f_idx, true);
3574
 
        table->field[8]->set_notnull();
3575
 
        table->field[9]->store(f_key_info->referenced_db->str,
3576
 
                               f_key_info->referenced_db->length,
3577
 
                               system_charset_info);
3578
 
        table->field[9]->set_notnull();
3579
 
        table->field[10]->store(f_key_info->referenced_table->str,
3580
 
                                f_key_info->referenced_table->length, 
3581
 
                                system_charset_info);
3582
 
        table->field[10]->set_notnull();
3583
 
        table->field[11]->store(r_info->str, r_info->length,
3584
 
                                system_charset_info);
3585
 
        table->field[11]->set_notnull();
3586
 
        if (schema_table_store_record(thd, table))
3587
 
          return(1);
3588
 
      }
3589
 
    }
3590
 
  }
3591
 
  return(res);
3592
 
}
3593
 
 
3594
 
 
3595
 
int fill_open_tables(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((unused)))
3596
 
{
3597
 
  const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS;
3598
 
  TABLE *table= tables->table;
3599
 
  const CHARSET_INFO * const cs= system_charset_info;
3600
 
  OPEN_TABLE_LIST *open_list;
3601
 
  if (!(open_list=list_open_tables(thd,thd->lex->select_lex.db, wild))
3602
 
            && thd->is_fatal_error)
3603
 
    return(1);
3604
 
 
3605
 
  for (; open_list ; open_list=open_list->next)
3606
 
  {
3607
 
    restore_record(table, s->default_values);
3608
 
    table->field[0]->store(open_list->db, strlen(open_list->db), cs);
3609
 
    table->field[1]->store(open_list->table, strlen(open_list->table), cs);
3610
 
    table->field[2]->store((int64_t) open_list->in_use, true);
3611
 
    table->field[3]->store((int64_t) open_list->locked, true);
3612
 
    if (schema_table_store_record(thd, table))
3613
 
      return(1);
3614
 
  }
3615
 
  return(0);
3616
 
}
3617
 
 
3618
 
 
3619
 
int fill_variables(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((unused)))
3620
 
{
3621
 
  int res= 0;
3622
 
  LEX *lex= thd->lex;
3623
 
  const char *wild= lex->wild ? lex->wild->ptr() : NullS;
3624
 
  enum enum_schema_tables schema_table_idx=
3625
 
    get_schema_table_idx(tables->schema_table);
3626
 
  enum enum_var_type option_type= OPT_SESSION;
3627
 
  bool upper_case_names= (schema_table_idx != SCH_VARIABLES);
3628
 
  bool sorted_vars= (schema_table_idx == SCH_VARIABLES);
3629
 
 
3630
 
  if (lex->option_type == OPT_GLOBAL ||
3631
 
      schema_table_idx == SCH_GLOBAL_VARIABLES)
3632
 
    option_type= OPT_GLOBAL;
3633
 
 
3634
 
  rw_rdlock(&LOCK_system_variables_hash);
3635
 
  res= show_status_array(thd, wild, enumerate_sys_vars(thd, sorted_vars),
3636
 
                         option_type, NULL, "", tables->table, upper_case_names);
3637
 
  rw_unlock(&LOCK_system_variables_hash);
3638
 
  return(res);
3639
 
}
3640
 
 
3641
 
 
3642
 
int fill_status(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((unused)))
3643
 
{
3644
 
  LEX *lex= thd->lex;
3645
 
  const char *wild= lex->wild ? lex->wild->ptr() : NullS;
3646
 
  int res= 0;
3647
 
  STATUS_VAR *tmp1, tmp;
3648
 
  enum enum_schema_tables schema_table_idx=
3649
 
    get_schema_table_idx(tables->schema_table);
3650
 
  enum enum_var_type option_type;
3651
 
  bool upper_case_names= (schema_table_idx != SCH_STATUS);
3652
 
 
3653
 
  if (schema_table_idx == SCH_STATUS)
3654
 
  {
3655
 
    option_type= lex->option_type;
3656
 
    if (option_type == OPT_GLOBAL)
3657
 
      tmp1= &tmp;
3658
 
    else
3659
 
      tmp1= thd->initial_status_var;
3660
 
  }
3661
 
  else if (schema_table_idx == SCH_GLOBAL_STATUS)
3662
 
  {
3663
 
    option_type= OPT_GLOBAL;
3664
 
    tmp1= &tmp;
3665
 
  }
3666
 
  else
3667
 
  { 
3668
 
    option_type= OPT_SESSION;
3669
 
    tmp1= &thd->status_var;
3670
 
  }
3671
 
 
3672
 
  pthread_mutex_lock(&LOCK_status);
3673
 
  if (option_type == OPT_GLOBAL)
3674
 
    calc_sum_of_all_status(&tmp);
3675
 
  res= show_status_array(thd, wild,
3676
 
                         (SHOW_VAR *)all_status_vars.buffer,
3677
 
                         option_type, tmp1, "", tables->table,
3678
 
                         upper_case_names);
3679
 
  pthread_mutex_unlock(&LOCK_status);
3680
 
  return(res);
3681
 
}
3682
 
 
3683
 
 
3684
 
/*
3685
 
  Fill and store records into I_S.referential_constraints table
3686
 
 
3687
 
  SYNOPSIS
3688
 
    get_referential_constraints_record()
3689
 
    thd                 thread handle
3690
 
    tables              table list struct(processed table)
3691
 
    table               I_S table
3692
 
    res                 1 means the error during opening of the processed table
3693
 
                        0 means processed table is opened without error
3694
 
    base_name           db name
3695
 
    file_name           table name
3696
 
 
3697
 
  RETURN
3698
 
    0   ok
3699
 
    #   error
3700
 
*/
3701
 
 
3702
 
static int
3703
 
get_referential_constraints_record(THD *thd, TABLE_LIST *tables,
3704
 
                                   TABLE *table, bool res,
3705
 
                                   LEX_STRING *db_name, LEX_STRING *table_name)
3706
 
{
3707
 
  const CHARSET_INFO * const cs= system_charset_info;
3708
 
 
3709
 
  if (res)
3710
 
  {
3711
 
    if (thd->is_error())
3712
 
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
3713
 
                   thd->main_da.sql_errno(), thd->main_da.message());
3714
 
    thd->clear_error();
3715
 
    return(0);
3716
 
  }
3717
 
 
3718
 
  {
3719
 
    List<FOREIGN_KEY_INFO> f_key_list;
3720
 
    TABLE *show_table= tables->table;
3721
 
    show_table->file->info(HA_STATUS_VARIABLE | 
3722
 
                           HA_STATUS_NO_LOCK |
3723
 
                           HA_STATUS_TIME);
3724
 
 
3725
 
    show_table->file->get_foreign_key_list(thd, &f_key_list);
3726
 
    FOREIGN_KEY_INFO *f_key_info;
3727
 
    List_iterator_fast<FOREIGN_KEY_INFO> it(f_key_list);
3728
 
    while ((f_key_info= it++))
3729
 
    {
3730
 
      restore_record(table, s->default_values);
3731
 
      table->field[1]->store(db_name->str, db_name->length, cs);
3732
 
      table->field[9]->store(table_name->str, table_name->length, cs);
3733
 
      table->field[2]->store(f_key_info->forein_id->str,
3734
 
                             f_key_info->forein_id->length, cs);
3735
 
      table->field[4]->store(f_key_info->referenced_db->str, 
3736
 
                             f_key_info->referenced_db->length, cs);
3737
 
      table->field[10]->store(f_key_info->referenced_table->str, 
3738
 
                             f_key_info->referenced_table->length, cs);
3739
 
      if (f_key_info->referenced_key_name)
3740
 
      {
3741
 
        table->field[5]->store(f_key_info->referenced_key_name->str, 
3742
 
                               f_key_info->referenced_key_name->length, cs);
3743
 
        table->field[5]->set_notnull();
3744
 
      }
3745
 
      else
3746
 
        table->field[5]->set_null();
3747
 
      table->field[6]->store(STRING_WITH_LEN("NONE"), cs);
3748
 
      table->field[7]->store(f_key_info->update_method->str, 
3749
 
                             f_key_info->update_method->length, cs);
3750
 
      table->field[8]->store(f_key_info->delete_method->str, 
3751
 
                             f_key_info->delete_method->length, cs);
3752
 
      if (schema_table_store_record(thd, table))
3753
 
        return(1);
3754
 
    }
3755
 
  }
3756
 
  return(0);
3757
 
}
3758
 
 
3759
 
 
3760
 
struct schema_table_ref 
3761
 
{
3762
 
  const char *table_name;
3763
 
  ST_SCHEMA_TABLE *schema_table;
3764
 
};
3765
 
 
3766
 
 
3767
 
/*
3768
 
  Find schema_tables elment by name
3769
 
 
3770
 
  SYNOPSIS
3771
 
    find_schema_table_in_plugin()
3772
 
    thd                 thread handler
3773
 
    plugin              plugin
3774
 
    table_name          table name
3775
 
 
3776
 
  RETURN
3777
 
    0   table not found
3778
 
    1   found the schema table
3779
 
*/
3780
 
static bool find_schema_table_in_plugin(THD *thd __attribute__((unused)),
3781
 
                                           plugin_ref plugin,
3782
 
                                           void* p_table)
3783
 
{
3784
 
  schema_table_ref *p_schema_table= (schema_table_ref *)p_table;
3785
 
  const char* table_name= p_schema_table->table_name;
3786
 
  ST_SCHEMA_TABLE *schema_table= plugin_data(plugin, ST_SCHEMA_TABLE *);
3787
 
 
3788
 
  if (!my_strcasecmp(system_charset_info,
3789
 
                     schema_table->table_name,
3790
 
                     table_name)) {
3791
 
    p_schema_table->schema_table= schema_table;
3792
 
    return(1);
3793
 
  }
3794
 
 
3795
 
  return(0);
3796
 
}
3797
 
 
3798
 
 
3799
 
/*
3800
 
  Find schema_tables elment by name
3801
 
 
3802
 
  SYNOPSIS
3803
 
    find_schema_table()
3804
 
    thd                 thread handler
3805
 
    table_name          table name
3806
 
 
3807
 
  RETURN
3808
 
    0   table not found
3809
 
    #   pointer to 'schema_tables' element
3810
 
*/
3811
 
 
3812
 
ST_SCHEMA_TABLE *find_schema_table(THD *thd, const char* table_name)
3813
 
{
3814
 
  schema_table_ref schema_table_a;
3815
 
  ST_SCHEMA_TABLE *schema_table= schema_tables;
3816
 
 
3817
 
  for (; schema_table->table_name; schema_table++)
3818
 
  {
3819
 
    if (!my_strcasecmp(system_charset_info,
3820
 
                       schema_table->table_name,
3821
 
                       table_name))
3822
 
      return(schema_table);
3823
 
  }
3824
 
 
3825
 
  schema_table_a.table_name= table_name;
3826
 
  if (plugin_foreach(thd, find_schema_table_in_plugin, 
3827
 
                     DRIZZLE_INFORMATION_SCHEMA_PLUGIN, &schema_table_a))
3828
 
    return(schema_table_a.schema_table);
3829
 
 
3830
 
  return(NULL);
3831
 
}
3832
 
 
3833
 
 
3834
 
ST_SCHEMA_TABLE *get_schema_table(enum enum_schema_tables schema_table_idx)
3835
 
{
3836
 
  return &schema_tables[schema_table_idx];
3837
 
}
3838
 
 
3839
 
 
3840
 
/**
3841
 
  Create information_schema table using schema_table data.
3842
 
 
3843
 
  @note
3844
 
 
3845
 
  @param
3846
 
    thd                   thread handler
3847
 
 
3848
 
  @param table_list Used to pass I_S table information(fields info, tables
3849
 
  parameters etc) and table name.
3850
 
 
3851
 
  @retval  \#             Pointer to created table
3852
 
  @retval  NULL           Can't create table
3853
 
*/
3854
 
 
3855
 
TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
3856
 
{
3857
 
  int field_count= 0;
3858
 
  Item *item;
3859
 
  TABLE *table;
3860
 
  List<Item> field_list;
3861
 
  ST_SCHEMA_TABLE *schema_table= table_list->schema_table;
3862
 
  ST_FIELD_INFO *fields_info= schema_table->fields_info;
3863
 
  const CHARSET_INFO * const cs= system_charset_info;
3864
 
 
3865
 
  for (; fields_info->field_name; fields_info++)
3866
 
  {
3867
 
    switch (fields_info->field_type) {
3868
 
    case DRIZZLE_TYPE_TINY:
3869
 
    case DRIZZLE_TYPE_LONG:
3870
 
    case DRIZZLE_TYPE_SHORT:
3871
 
    case DRIZZLE_TYPE_LONGLONG:
3872
 
      if (!(item= new Item_return_int(fields_info->field_name,
3873
 
                                      fields_info->field_length,
3874
 
                                      fields_info->field_type,
3875
 
                                      fields_info->value)))
3876
 
      {
3877
 
        return(0);
3878
 
      }
3879
 
      item->unsigned_flag= (fields_info->field_flags & MY_I_S_UNSIGNED);
3880
 
      break;
3881
 
    case DRIZZLE_TYPE_NEWDATE:
3882
 
    case DRIZZLE_TYPE_TIME:
3883
 
    case DRIZZLE_TYPE_TIMESTAMP:
3884
 
    case DRIZZLE_TYPE_DATETIME:
3885
 
      if (!(item=new Item_return_date_time(fields_info->field_name,
3886
 
                                           fields_info->field_type)))
3887
 
      {
3888
 
        return(0);
3889
 
      }
3890
 
      break;
3891
 
    case DRIZZLE_TYPE_DOUBLE:
3892
 
      if ((item= new Item_float(fields_info->field_name, 0.0, NOT_FIXED_DEC, 
3893
 
                           fields_info->field_length)) == NULL)
3894
 
        return(NULL);
3895
 
      break;
3896
 
    case DRIZZLE_TYPE_NEWDECIMAL:
3897
 
      if (!(item= new Item_decimal((int64_t) fields_info->value, false)))
3898
 
      {
3899
 
        return(0);
3900
 
      }
3901
 
      item->unsigned_flag= (fields_info->field_flags & MY_I_S_UNSIGNED);
3902
 
      item->decimals= fields_info->field_length%10;
3903
 
      item->max_length= (fields_info->field_length/100)%100;
3904
 
      if (item->unsigned_flag == 0)
3905
 
        item->max_length+= 1;
3906
 
      if (item->decimals > 0)
3907
 
        item->max_length+= 1;
3908
 
      item->set_name(fields_info->field_name,
3909
 
                     strlen(fields_info->field_name), cs);
3910
 
      break;
3911
 
    case DRIZZLE_TYPE_BLOB:
3912
 
      if (!(item= new Item_blob(fields_info->field_name,
3913
 
                                fields_info->field_length)))
3914
 
      {
3915
 
        return(0);
3916
 
      }
3917
 
      break;
3918
 
    default:
3919
 
      if (!(item= new Item_empty_string("", fields_info->field_length, cs)))
3920
 
      {
3921
 
        return(0);
3922
 
      }
3923
 
      item->set_name(fields_info->field_name,
3924
 
                     strlen(fields_info->field_name), cs);
3925
 
      break;
3926
 
    }
3927
 
    field_list.push_back(item);
3928
 
    item->maybe_null= (fields_info->field_flags & MY_I_S_MAYBE_NULL);
3929
 
    field_count++;
3930
 
  }
3931
 
  TMP_TABLE_PARAM *tmp_table_param =
3932
 
    (TMP_TABLE_PARAM*) (thd->alloc(sizeof(TMP_TABLE_PARAM)));
3933
 
  tmp_table_param->init();
3934
 
  tmp_table_param->table_charset= cs;
3935
 
  tmp_table_param->field_count= field_count;
3936
 
  tmp_table_param->schema_table= 1;
3937
 
  SELECT_LEX *select_lex= thd->lex->current_select;
3938
 
  if (!(table= create_tmp_table(thd, tmp_table_param,
3939
 
                                field_list, (ORDER*) 0, 0, 0, 
3940
 
                                (select_lex->options | thd->options |
3941
 
                                 TMP_TABLE_ALL_COLUMNS),
3942
 
                                HA_POS_ERROR, table_list->alias)))
3943
 
    return(0);
3944
 
  my_bitmap_map* bitmaps=
3945
 
    (my_bitmap_map*) thd->alloc(bitmap_buffer_size(field_count));
3946
 
  bitmap_init(&table->def_read_set, (my_bitmap_map*) bitmaps, field_count,
3947
 
              false);
3948
 
  table->read_set= &table->def_read_set;
3949
 
  bitmap_clear_all(table->read_set);
3950
 
  table_list->schema_table_param= tmp_table_param;
3951
 
  return(table);
3952
 
}
3953
 
 
3954
 
 
3955
 
/*
3956
 
  For old SHOW compatibility. It is used when
3957
 
  old SHOW doesn't have generated column names
3958
 
  Make list of fields for SHOW
3959
 
 
3960
 
  SYNOPSIS
3961
 
    make_old_format()
3962
 
    thd                 thread handler
3963
 
    schema_table        pointer to 'schema_tables' element
3964
 
 
3965
 
  RETURN
3966
 
   1    error
3967
 
   0    success
3968
 
*/
3969
 
 
3970
 
int make_old_format(THD *thd, ST_SCHEMA_TABLE *schema_table)
3971
 
{
3972
 
  ST_FIELD_INFO *field_info= schema_table->fields_info;
3973
 
  Name_resolution_context *context= &thd->lex->select_lex.context;
3974
 
  for (; field_info->field_name; field_info++)
3975
 
  {
3976
 
    if (field_info->old_name)
3977
 
    {
3978
 
      Item_field *field= new Item_field(context,
3979
 
                                        NullS, NullS, field_info->field_name);
3980
 
      if (field)
3981
 
      {
3982
 
        field->set_name(field_info->old_name,
3983
 
                        strlen(field_info->old_name),
3984
 
                        system_charset_info);
3985
 
        if (add_item_to_list(thd, field))
3986
 
          return 1;
3987
 
      }
3988
 
    }
3989
 
  }
3990
 
  return 0;
3991
 
}
3992
 
 
3993
 
 
3994
 
int make_schemata_old_format(THD *thd, ST_SCHEMA_TABLE *schema_table)
3995
 
{
3996
 
  char tmp[128];
3997
 
  LEX *lex= thd->lex;
3998
 
  SELECT_LEX *sel= lex->current_select;
3999
 
  Name_resolution_context *context= &sel->context;
4000
 
 
4001
 
  if (!sel->item_list.elements)
4002
 
  {
4003
 
    ST_FIELD_INFO *field_info= &schema_table->fields_info[1];
4004
 
    String buffer(tmp,sizeof(tmp), system_charset_info);
4005
 
    Item_field *field= new Item_field(context,
4006
 
                                      NullS, NullS, field_info->field_name);
4007
 
    if (!field || add_item_to_list(thd, field))
4008
 
      return 1;
4009
 
    buffer.length(0);
4010
 
    buffer.append(field_info->old_name);
4011
 
    if (lex->wild && lex->wild->ptr())
4012
 
    {
4013
 
      buffer.append(STRING_WITH_LEN(" ("));
4014
 
      buffer.append(lex->wild->ptr());
4015
 
      buffer.append(')');
4016
 
    }
4017
 
    field->set_name(buffer.ptr(), buffer.length(), system_charset_info);
4018
 
  }
4019
 
  return 0;
4020
 
}
4021
 
 
4022
 
 
4023
 
int make_table_names_old_format(THD *thd, ST_SCHEMA_TABLE *schema_table)
4024
 
{
4025
 
  char tmp[128];
4026
 
  String buffer(tmp,sizeof(tmp), thd->charset());
4027
 
  LEX *lex= thd->lex;
4028
 
  Name_resolution_context *context= &lex->select_lex.context;
4029
 
 
4030
 
  ST_FIELD_INFO *field_info= &schema_table->fields_info[2];
4031
 
  buffer.length(0);
4032
 
  buffer.append(field_info->old_name);
4033
 
  buffer.append(lex->select_lex.db);
4034
 
  if (lex->wild && lex->wild->ptr())
4035
 
  {
4036
 
    buffer.append(STRING_WITH_LEN(" ("));
4037
 
    buffer.append(lex->wild->ptr());
4038
 
    buffer.append(')');
4039
 
  }
4040
 
  Item_field *field= new Item_field(context,
4041
 
                                    NullS, NullS, field_info->field_name);
4042
 
  if (add_item_to_list(thd, field))
4043
 
    return 1;
4044
 
  field->set_name(buffer.ptr(), buffer.length(), system_charset_info);
4045
 
  if (thd->lex->verbose)
4046
 
  {
4047
 
    field->set_name(buffer.ptr(), buffer.length(), system_charset_info);
4048
 
    field_info= &schema_table->fields_info[3];
4049
 
    field= new Item_field(context, NullS, NullS, field_info->field_name);
4050
 
    if (add_item_to_list(thd, field))
4051
 
      return 1;
4052
 
    field->set_name(field_info->old_name, strlen(field_info->old_name),
4053
 
                    system_charset_info);
4054
 
  }
4055
 
  return 0;
4056
 
}
4057
 
 
4058
 
 
4059
 
int make_columns_old_format(THD *thd, ST_SCHEMA_TABLE *schema_table)
4060
 
{
4061
 
  int fields_arr[]= {3, 14, 13, 6, 15, 5, 16, 17, 18, -1};
4062
 
  int *field_num= fields_arr;
4063
 
  ST_FIELD_INFO *field_info;
4064
 
  Name_resolution_context *context= &thd->lex->select_lex.context;
4065
 
 
4066
 
  for (; *field_num >= 0; field_num++)
4067
 
  {
4068
 
    field_info= &schema_table->fields_info[*field_num];
4069
 
    if (!thd->lex->verbose && (*field_num == 13 ||
4070
 
                               *field_num == 17 ||
4071
 
                               *field_num == 18))
4072
 
      continue;
4073
 
    Item_field *field= new Item_field(context,
4074
 
                                      NullS, NullS, field_info->field_name);
4075
 
    if (field)
4076
 
    {
4077
 
      field->set_name(field_info->old_name,
4078
 
                      strlen(field_info->old_name),
4079
 
                      system_charset_info);
4080
 
      if (add_item_to_list(thd, field))
4081
 
        return 1;
4082
 
    }
4083
 
  }
4084
 
  return 0;
4085
 
}
4086
 
 
4087
 
 
4088
 
int make_character_sets_old_format(THD *thd, ST_SCHEMA_TABLE *schema_table)
4089
 
{
4090
 
  int fields_arr[]= {0, 2, 1, 3, -1};
4091
 
  int *field_num= fields_arr;
4092
 
  ST_FIELD_INFO *field_info;
4093
 
  Name_resolution_context *context= &thd->lex->select_lex.context;
4094
 
 
4095
 
  for (; *field_num >= 0; field_num++)
4096
 
  {
4097
 
    field_info= &schema_table->fields_info[*field_num];
4098
 
    Item_field *field= new Item_field(context,
4099
 
                                      NullS, NullS, field_info->field_name);
4100
 
    if (field)
4101
 
    {
4102
 
      field->set_name(field_info->old_name,
4103
 
                      strlen(field_info->old_name),
4104
 
                      system_charset_info);
4105
 
      if (add_item_to_list(thd, field))
4106
 
        return 1;
4107
 
    }
4108
 
  }
4109
 
  return 0;
4110
 
}
4111
 
 
4112
 
 
4113
 
/*
4114
 
  Create information_schema table
4115
 
 
4116
 
  SYNOPSIS
4117
 
  mysql_schema_table()
4118
 
    thd                thread handler
4119
 
    lex                pointer to LEX
4120
 
    table_list         pointer to table_list
4121
 
 
4122
 
  RETURN
4123
 
    0   success
4124
 
    1   error
4125
 
*/
4126
 
 
4127
 
int mysql_schema_table(THD *thd, LEX *lex, TABLE_LIST *table_list)
4128
 
{
4129
 
  TABLE *table;
4130
 
  if (!(table= table_list->schema_table->create_table(thd, table_list)))
4131
 
    return(1);
4132
 
  table->s->tmp_table= SYSTEM_TMP_TABLE;
4133
 
  /*
4134
 
    This test is necessary to make
4135
 
    case insensitive file systems +
4136
 
    upper case table names(information schema tables) +
4137
 
    views
4138
 
    working correctly
4139
 
  */
4140
 
  if (table_list->schema_table_name)
4141
 
    table->alias_name_used= my_strcasecmp(table_alias_charset,
4142
 
                                          table_list->schema_table_name,
4143
 
                                          table_list->alias);
4144
 
  table_list->table_name= table->s->table_name.str;
4145
 
  table_list->table_name_length= table->s->table_name.length;
4146
 
  table_list->table= table;
4147
 
  table->next= thd->derived_tables;
4148
 
  thd->derived_tables= table;
4149
 
  table_list->select_lex->options |= OPTION_SCHEMA_TABLE;
4150
 
 
4151
 
  if (table_list->schema_table_reformed) // show command
4152
 
  {
4153
 
    SELECT_LEX *sel= lex->current_select;
4154
 
    Item *item;
4155
 
    Field_translator *transl, *org_transl;
4156
 
 
4157
 
    if (table_list->field_translation)
4158
 
    {
4159
 
      Field_translator *end= table_list->field_translation_end;
4160
 
      for (transl= table_list->field_translation; transl < end; transl++)
4161
 
      {
4162
 
        if (!transl->item->fixed &&
4163
 
            transl->item->fix_fields(thd, &transl->item))
4164
 
          return(1);
4165
 
      }
4166
 
      return(0);
4167
 
    }
4168
 
    List_iterator_fast<Item> it(sel->item_list);
4169
 
    if (!(transl=
4170
 
          (Field_translator*)(thd->stmt_arena->
4171
 
                              alloc(sel->item_list.elements *
4172
 
                                    sizeof(Field_translator)))))
4173
 
    {
4174
 
      return(1);
4175
 
    }
4176
 
    for (org_transl= transl; (item= it++); transl++)
4177
 
    {
4178
 
      transl->item= item;
4179
 
      transl->name= item->name;
4180
 
      if (!item->fixed && item->fix_fields(thd, &transl->item))
4181
 
      {
4182
 
        return(1);
4183
 
      }
4184
 
    }
4185
 
    table_list->field_translation= org_transl;
4186
 
    table_list->field_translation_end= transl;
4187
 
  }
4188
 
 
4189
 
  return(0);
4190
 
}
4191
 
 
4192
 
 
4193
 
/*
4194
 
  Generate select from information_schema table
4195
 
 
4196
 
  SYNOPSIS
4197
 
    make_schema_select()
4198
 
    thd                  thread handler
4199
 
    sel                  pointer to SELECT_LEX
4200
 
    schema_table_idx     index of 'schema_tables' element
4201
 
 
4202
 
  RETURN
4203
 
    0   success
4204
 
    1   error
4205
 
*/
4206
 
 
4207
 
int make_schema_select(THD *thd, SELECT_LEX *sel,
4208
 
                       enum enum_schema_tables schema_table_idx)
4209
 
{
4210
 
  ST_SCHEMA_TABLE *schema_table= get_schema_table(schema_table_idx);
4211
 
  LEX_STRING db, table;
4212
 
  /*
4213
 
     We have to make non const db_name & table_name
4214
 
     because of lower_case_table_names
4215
 
  */
4216
 
  thd->make_lex_string(&db, INFORMATION_SCHEMA_NAME.str,
4217
 
                       INFORMATION_SCHEMA_NAME.length, 0);
4218
 
  thd->make_lex_string(&table, schema_table->table_name,
4219
 
                       strlen(schema_table->table_name), 0);
4220
 
  if (schema_table->old_format(thd, schema_table) ||   /* Handle old syntax */
4221
 
      !sel->add_table_to_list(thd, new Table_ident(thd, db, table, 0),
4222
 
                              0, 0, TL_READ))
4223
 
  {
4224
 
    return(1);
4225
 
  }
4226
 
  return(0);
4227
 
}
4228
 
 
4229
 
 
4230
 
/*
4231
 
  Fill temporary schema tables before SELECT
4232
 
 
4233
 
  SYNOPSIS
4234
 
    get_schema_tables_result()
4235
 
    join  join which use schema tables
4236
 
    executed_place place where I_S table processed
4237
 
 
4238
 
  RETURN
4239
 
    false success
4240
 
    true  error
4241
 
*/
4242
 
 
4243
 
bool get_schema_tables_result(JOIN *join,
4244
 
                              enum enum_schema_table_state executed_place)
4245
 
{
4246
 
  JOIN_TAB *tmp_join_tab= join->join_tab+join->tables;
4247
 
  THD *thd= join->thd;
4248
 
  LEX *lex= thd->lex;
4249
 
  bool result= 0;
4250
 
 
4251
 
  thd->no_warnings_for_error= 1;
4252
 
  for (JOIN_TAB *tab= join->join_tab; tab < tmp_join_tab; tab++)
4253
 
  {
4254
 
    if (!tab->table || !tab->table->pos_in_table_list)
4255
 
      break;
4256
 
 
4257
 
    TABLE_LIST *table_list= tab->table->pos_in_table_list;
4258
 
    if (table_list->schema_table)
4259
 
    {
4260
 
      bool is_subselect= (&lex->unit != lex->current_select->master_unit() &&
4261
 
                          lex->current_select->master_unit()->item);
4262
 
 
4263
 
 
4264
 
      /* skip I_S optimizations specific to get_all_tables */
4265
 
      if (thd->lex->describe &&
4266
 
          (table_list->schema_table->fill_table != get_all_tables))
4267
 
        continue;
4268
 
 
4269
 
      /*
4270
 
        If schema table is already processed and
4271
 
        the statement is not a subselect then
4272
 
        we don't need to fill this table again.
4273
 
        If schema table is already processed and
4274
 
        schema_table_state != executed_place then
4275
 
        table is already processed and
4276
 
        we should skip second data processing.
4277
 
      */
4278
 
      if (table_list->schema_table_state &&
4279
 
          (!is_subselect || table_list->schema_table_state != executed_place))
4280
 
        continue;
4281
 
 
4282
 
      /*
4283
 
        if table is used in a subselect and
4284
 
        table has been processed earlier with the same
4285
 
        'executed_place' value then we should refresh the table.
4286
 
      */
4287
 
      if (table_list->schema_table_state && is_subselect)
4288
 
      {
4289
 
        table_list->table->file->extra(HA_EXTRA_NO_CACHE);
4290
 
        table_list->table->file->extra(HA_EXTRA_RESET_STATE);
4291
 
        table_list->table->file->ha_delete_all_rows();
4292
 
        free_io_cache(table_list->table);
4293
 
        filesort_free_buffers(table_list->table,1);
4294
 
        table_list->table->null_row= 0;
4295
 
      }
4296
 
      else
4297
 
        table_list->table->file->stats.records= 0;
4298
 
 
4299
 
      if (table_list->schema_table->fill_table(thd, table_list,
4300
 
                                               tab->select_cond))
4301
 
      {
4302
 
        result= 1;
4303
 
        join->error= 1;
4304
 
        tab->read_record.file= table_list->table->file;
4305
 
        table_list->schema_table_state= executed_place;
4306
 
        break;
4307
 
      }
4308
 
      tab->read_record.file= table_list->table->file;
4309
 
      table_list->schema_table_state= executed_place;
4310
 
    }
4311
 
  }
4312
 
  thd->no_warnings_for_error= 0;
4313
 
  return(result);
4314
 
}
4315
 
 
4316
 
ST_FIELD_INFO schema_fields_info[]=
4317
 
{
4318
 
  {"CATALOG_NAME", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, SKIP_OPEN_TABLE},
4319
 
  {"SCHEMA_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Database",
4320
 
   SKIP_OPEN_TABLE},
4321
 
  {"DEFAULT_CHARACTER_SET_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4322
 
   SKIP_OPEN_TABLE},
4323
 
  {"DEFAULT_COLLATION_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE},
4324
 
  {"SQL_PATH", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, SKIP_OPEN_TABLE},
4325
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4326
 
};
4327
 
 
4328
 
 
4329
 
ST_FIELD_INFO tables_fields_info[]=
4330
 
{
4331
 
  {"TABLE_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, SKIP_OPEN_TABLE},
4332
 
  {"TABLE_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE},
4333
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Name",
4334
 
   SKIP_OPEN_TABLE},
4335
 
  {"TABLE_TYPE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FRM_ONLY},
4336
 
  {"ENGINE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, "Engine", OPEN_FRM_ONLY},
4337
 
  {"VERSION", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0,
4338
 
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Version", OPEN_FRM_ONLY},
4339
 
  {"ROW_FORMAT", 10, DRIZZLE_TYPE_VARCHAR, 0, 1, "Row_format", OPEN_FULL_TABLE},
4340
 
  {"TABLE_ROWS", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0,
4341
 
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Rows", OPEN_FULL_TABLE},
4342
 
  {"AVG_ROW_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0, 
4343
 
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Avg_row_length", OPEN_FULL_TABLE},
4344
 
  {"DATA_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0, 
4345
 
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Data_length", OPEN_FULL_TABLE},
4346
 
  {"MAX_DATA_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0,
4347
 
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Max_data_length", OPEN_FULL_TABLE},
4348
 
  {"INDEX_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0, 
4349
 
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Index_length", OPEN_FULL_TABLE},
4350
 
  {"DATA_FREE", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0,
4351
 
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Data_free", OPEN_FULL_TABLE},
4352
 
  {"AUTO_INCREMENT", MY_INT64_NUM_DECIMAL_DIGITS , DRIZZLE_TYPE_LONGLONG, 0, 
4353
 
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Auto_increment", OPEN_FULL_TABLE},
4354
 
  {"CREATE_TIME", 0, DRIZZLE_TYPE_DATETIME, 0, 1, "Create_time", OPEN_FULL_TABLE},
4355
 
  {"UPDATE_TIME", 0, DRIZZLE_TYPE_DATETIME, 0, 1, "Update_time", OPEN_FULL_TABLE},
4356
 
  {"CHECK_TIME", 0, DRIZZLE_TYPE_DATETIME, 0, 1, "Check_time", OPEN_FULL_TABLE},
4357
 
  {"TABLE_COLLATION", 64, DRIZZLE_TYPE_VARCHAR, 0, 1, "Collation", OPEN_FRM_ONLY},
4358
 
  {"CHECKSUM", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0,
4359
 
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Checksum", OPEN_FULL_TABLE},
4360
 
  {"CREATE_OPTIONS", 255, DRIZZLE_TYPE_VARCHAR, 0, 1, "Create_options",
4361
 
   OPEN_FRM_ONLY},
4362
 
  {"TABLE_COMMENT", TABLE_COMMENT_MAXLEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Comment", OPEN_FRM_ONLY},
4363
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4364
 
};
4365
 
 
4366
 
 
4367
 
ST_FIELD_INFO columns_fields_info[]=
4368
 
{
4369
 
  {"TABLE_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FRM_ONLY},
4370
 
  {"TABLE_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FRM_ONLY},
4371
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FRM_ONLY},
4372
 
  {"COLUMN_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Field",
4373
 
   OPEN_FRM_ONLY},
4374
 
  {"ORDINAL_POSITION", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0,
4375
 
   MY_I_S_UNSIGNED, 0, OPEN_FRM_ONLY},
4376
 
  {"COLUMN_DEFAULT", MAX_FIELD_VARCHARLENGTH, DRIZZLE_TYPE_VARCHAR, 0,
4377
 
   1, "Default", OPEN_FRM_ONLY},
4378
 
  {"IS_NULLABLE", 3, DRIZZLE_TYPE_VARCHAR, 0, 0, "Null", OPEN_FRM_ONLY},
4379
 
  {"DATA_TYPE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FRM_ONLY},
4380
 
  {"CHARACTER_MAXIMUM_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG,
4381
 
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
4382
 
  {"CHARACTER_OCTET_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS , DRIZZLE_TYPE_LONGLONG,
4383
 
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
4384
 
  {"NUMERIC_PRECISION", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG,
4385
 
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
4386
 
  {"NUMERIC_SCALE", MY_INT64_NUM_DECIMAL_DIGITS , DRIZZLE_TYPE_LONGLONG,
4387
 
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
4388
 
  {"CHARACTER_SET_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FRM_ONLY},
4389
 
  {"COLLATION_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 1, "Collation", OPEN_FRM_ONLY},
4390
 
  {"COLUMN_TYPE", 65535, DRIZZLE_TYPE_VARCHAR, 0, 0, "Type", OPEN_FRM_ONLY},
4391
 
  {"COLUMN_KEY", 3, DRIZZLE_TYPE_VARCHAR, 0, 0, "Key", OPEN_FRM_ONLY},
4392
 
  {"EXTRA", 27, DRIZZLE_TYPE_VARCHAR, 0, 0, "Extra", OPEN_FRM_ONLY},
4393
 
  {"PRIVILEGES", 80, DRIZZLE_TYPE_VARCHAR, 0, 0, "Privileges", OPEN_FRM_ONLY},
4394
 
  {"COLUMN_COMMENT", COLUMN_COMMENT_MAXLEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Comment", OPEN_FRM_ONLY},
4395
 
  {"STORAGE", 8, DRIZZLE_TYPE_VARCHAR, 0, 0, "Storage", OPEN_FRM_ONLY},
4396
 
  {"FORMAT", 8, DRIZZLE_TYPE_VARCHAR, 0, 0, "Format", OPEN_FRM_ONLY},
4397
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4398
 
};
4399
 
 
4400
 
 
4401
 
ST_FIELD_INFO charsets_fields_info[]=
4402
 
{
4403
 
  {"CHARACTER_SET_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, "Charset",
4404
 
   SKIP_OPEN_TABLE},
4405
 
  {"DEFAULT_COLLATE_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, "Default collation",
4406
 
   SKIP_OPEN_TABLE},
4407
 
  {"DESCRIPTION", 60, DRIZZLE_TYPE_VARCHAR, 0, 0, "Description",
4408
 
   SKIP_OPEN_TABLE},
4409
 
  {"MAXLEN", 3, DRIZZLE_TYPE_LONGLONG, 0, 0, "Maxlen", SKIP_OPEN_TABLE},
4410
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4411
 
};
4412
 
 
4413
 
 
4414
 
ST_FIELD_INFO collation_fields_info[]=
4415
 
{
4416
 
  {"COLLATION_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, "Collation", SKIP_OPEN_TABLE},
4417
 
  {"CHARACTER_SET_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, "Charset",
4418
 
   SKIP_OPEN_TABLE},
4419
 
  {"ID", MY_INT32_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0, 0, "Id",
4420
 
   SKIP_OPEN_TABLE},
4421
 
  {"IS_DEFAULT", 3, DRIZZLE_TYPE_VARCHAR, 0, 0, "Default", SKIP_OPEN_TABLE},
4422
 
  {"IS_COMPILED", 3, DRIZZLE_TYPE_VARCHAR, 0, 0, "Compiled", SKIP_OPEN_TABLE},
4423
 
  {"SORTLEN", 3, DRIZZLE_TYPE_LONGLONG, 0, 0, "Sortlen", SKIP_OPEN_TABLE},
4424
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4425
 
};
4426
 
 
4427
 
 
4428
 
 
4429
 
ST_FIELD_INFO coll_charset_app_fields_info[]=
4430
 
{
4431
 
  {"COLLATION_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE},
4432
 
  {"CHARACTER_SET_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE},
4433
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4434
 
};
4435
 
 
4436
 
 
4437
 
ST_FIELD_INFO stat_fields_info[]=
4438
 
{
4439
 
  {"TABLE_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FRM_ONLY},
4440
 
  {"TABLE_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FRM_ONLY},
4441
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Table", OPEN_FRM_ONLY},
4442
 
  {"NON_UNIQUE", 1, DRIZZLE_TYPE_LONGLONG, 0, 0, "Non_unique", OPEN_FRM_ONLY},
4443
 
  {"INDEX_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FRM_ONLY},
4444
 
  {"INDEX_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Key_name",
4445
 
   OPEN_FRM_ONLY},
4446
 
  {"SEQ_IN_INDEX", 2, DRIZZLE_TYPE_LONGLONG, 0, 0, "Seq_in_index", OPEN_FRM_ONLY},
4447
 
  {"COLUMN_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Column_name",
4448
 
   OPEN_FRM_ONLY},
4449
 
  {"COLLATION", 1, DRIZZLE_TYPE_VARCHAR, 0, 1, "Collation", OPEN_FRM_ONLY},
4450
 
  {"CARDINALITY", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0, 1,
4451
 
   "Cardinality", OPEN_FULL_TABLE},
4452
 
  {"SUB_PART", 3, DRIZZLE_TYPE_LONGLONG, 0, 1, "Sub_part", OPEN_FRM_ONLY},
4453
 
  {"PACKED", 10, DRIZZLE_TYPE_VARCHAR, 0, 1, "Packed", OPEN_FRM_ONLY},
4454
 
  {"NULLABLE", 3, DRIZZLE_TYPE_VARCHAR, 0, 0, "Null", OPEN_FRM_ONLY},
4455
 
  {"INDEX_TYPE", 16, DRIZZLE_TYPE_VARCHAR, 0, 0, "Index_type", OPEN_FULL_TABLE},
4456
 
  {"COMMENT", 16, DRIZZLE_TYPE_VARCHAR, 0, 1, "Comment", OPEN_FRM_ONLY},
4457
 
  {"INDEX_COMMENT", INDEX_COMMENT_MAXLEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Index_Comment", OPEN_FRM_ONLY},
4458
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4459
 
};
4460
 
 
4461
 
 
4462
 
ST_FIELD_INFO table_constraints_fields_info[]=
4463
 
{
4464
 
  {"CONSTRAINT_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FULL_TABLE},
4465
 
  {"CONSTRAINT_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4466
 
   OPEN_FULL_TABLE},
4467
 
  {"CONSTRAINT_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4468
 
   OPEN_FULL_TABLE},
4469
 
  {"TABLE_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4470
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4471
 
  {"CONSTRAINT_TYPE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4472
 
   OPEN_FULL_TABLE},
4473
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4474
 
};
4475
 
 
4476
 
 
4477
 
ST_FIELD_INFO key_column_usage_fields_info[]=
4478
 
{
4479
 
  {"CONSTRAINT_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FULL_TABLE},
4480
 
  {"CONSTRAINT_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4481
 
   OPEN_FULL_TABLE},
4482
 
  {"CONSTRAINT_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4483
 
   OPEN_FULL_TABLE},
4484
 
  {"TABLE_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FULL_TABLE},
4485
 
  {"TABLE_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4486
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4487
 
  {"COLUMN_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4488
 
  {"ORDINAL_POSITION", 10 ,DRIZZLE_TYPE_LONGLONG, 0, 0, 0, OPEN_FULL_TABLE},
4489
 
  {"POSITION_IN_UNIQUE_CONSTRAINT", 10 ,DRIZZLE_TYPE_LONGLONG, 0, 1, 0,
4490
 
   OPEN_FULL_TABLE},
4491
 
  {"REFERENCED_TABLE_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0,
4492
 
   OPEN_FULL_TABLE},
4493
 
  {"REFERENCED_TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0,
4494
 
   OPEN_FULL_TABLE},
4495
 
  {"REFERENCED_COLUMN_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0,
4496
 
   OPEN_FULL_TABLE},
4497
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4498
 
};
4499
 
 
4500
 
 
4501
 
ST_FIELD_INFO table_names_fields_info[]=
4502
 
{
4503
 
  {"TABLE_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, SKIP_OPEN_TABLE},
4504
 
  {"TABLE_SCHEMA",NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE},
4505
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Tables_in_",
4506
 
   SKIP_OPEN_TABLE},
4507
 
  {"TABLE_TYPE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Table_type",
4508
 
   OPEN_FRM_ONLY},
4509
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4510
 
};
4511
 
 
4512
 
 
4513
 
ST_FIELD_INFO open_tables_fields_info[]=
4514
 
{
4515
 
  {"Database", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Database",
4516
 
   SKIP_OPEN_TABLE},
4517
 
  {"Table",NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Table", SKIP_OPEN_TABLE},
4518
 
  {"In_use", 1, DRIZZLE_TYPE_LONGLONG, 0, 0, "In_use", SKIP_OPEN_TABLE},
4519
 
  {"Name_locked", 4, DRIZZLE_TYPE_LONGLONG, 0, 0, "Name_locked", SKIP_OPEN_TABLE},
4520
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4521
 
};
4522
 
 
4523
 
 
4524
 
ST_FIELD_INFO variables_fields_info[]=
4525
 
{
4526
 
  {"VARIABLE_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, "Variable_name",
4527
 
   SKIP_OPEN_TABLE},
4528
 
  {"VARIABLE_VALUE", 16300, DRIZZLE_TYPE_VARCHAR, 0, 1, "Value", SKIP_OPEN_TABLE},
4529
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4530
 
};
4531
 
 
4532
 
 
4533
 
ST_FIELD_INFO processlist_fields_info[]=
4534
 
{
4535
 
  {"ID", 4, DRIZZLE_TYPE_LONGLONG, 0, 0, "Id", SKIP_OPEN_TABLE},
4536
 
  {"USER", 16, DRIZZLE_TYPE_VARCHAR, 0, 0, "User", SKIP_OPEN_TABLE},
4537
 
  {"HOST", LIST_PROCESS_HOST_LEN,  DRIZZLE_TYPE_VARCHAR, 0, 0, "Host",
4538
 
   SKIP_OPEN_TABLE},
4539
 
  {"DB", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, "Db", SKIP_OPEN_TABLE},
4540
 
  {"COMMAND", 16, DRIZZLE_TYPE_VARCHAR, 0, 0, "Command", SKIP_OPEN_TABLE},
4541
 
  {"TIME", 7, DRIZZLE_TYPE_LONGLONG, 0, 0, "Time", SKIP_OPEN_TABLE},
4542
 
  {"STATE", 64, DRIZZLE_TYPE_VARCHAR, 0, 1, "State", SKIP_OPEN_TABLE},
4543
 
  {"INFO", PROCESS_LIST_INFO_WIDTH, DRIZZLE_TYPE_VARCHAR, 0, 1, "Info",
4544
 
   SKIP_OPEN_TABLE},
4545
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4546
 
};
4547
 
 
4548
 
 
4549
 
ST_FIELD_INFO plugin_fields_info[]=
4550
 
{
4551
 
  {"PLUGIN_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Name", 
4552
 
   SKIP_OPEN_TABLE},
4553
 
  {"PLUGIN_VERSION", 20, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE},
4554
 
  {"PLUGIN_STATUS", 10, DRIZZLE_TYPE_VARCHAR, 0, 0, "Status", SKIP_OPEN_TABLE},
4555
 
  {"PLUGIN_TYPE", 80, DRIZZLE_TYPE_VARCHAR, 0, 0, "Type", SKIP_OPEN_TABLE},
4556
 
  {"PLUGIN_LIBRARY", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, "Library",
4557
 
   SKIP_OPEN_TABLE},
4558
 
  {"PLUGIN_AUTHOR", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, SKIP_OPEN_TABLE},
4559
 
  {"PLUGIN_DESCRIPTION", 65535, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, SKIP_OPEN_TABLE},
4560
 
  {"PLUGIN_LICENSE", 80, DRIZZLE_TYPE_VARCHAR, 0, 1, "License", SKIP_OPEN_TABLE},
4561
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4562
 
};
4563
 
 
4564
 
ST_FIELD_INFO referential_constraints_fields_info[]=
4565
 
{
4566
 
  {"CONSTRAINT_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FULL_TABLE},
4567
 
  {"CONSTRAINT_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4568
 
   OPEN_FULL_TABLE},
4569
 
  {"CONSTRAINT_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4570
 
   OPEN_FULL_TABLE},
4571
 
  {"UNIQUE_CONSTRAINT_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0,
4572
 
   OPEN_FULL_TABLE},
4573
 
  {"UNIQUE_CONSTRAINT_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4574
 
   OPEN_FULL_TABLE},
4575
 
  {"UNIQUE_CONSTRAINT_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0,
4576
 
   MY_I_S_MAYBE_NULL, 0, OPEN_FULL_TABLE},
4577
 
  {"MATCH_OPTION", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4578
 
  {"UPDATE_RULE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4579
 
  {"DELETE_RULE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4580
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4581
 
  {"REFERENCED_TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4582
 
   OPEN_FULL_TABLE},
4583
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
4584
 
};
4585
 
 
4586
 
 
4587
 
/*
4588
 
  Description of ST_FIELD_INFO in table.h
4589
 
 
4590
 
  Make sure that the order of schema_tables and enum_schema_tables are the same.
4591
 
 
4592
 
*/
4593
 
 
4594
 
ST_SCHEMA_TABLE schema_tables[]=
4595
 
{
4596
 
  {"CHARACTER_SETS", charsets_fields_info, create_schema_table, 
4597
 
   fill_schema_charsets, make_character_sets_old_format, 0, -1, -1, 0, 0},
4598
 
  {"COLLATIONS", collation_fields_info, create_schema_table, 
4599
 
   fill_schema_collation, make_old_format, 0, -1, -1, 0, 0},
4600
 
  {"COLLATION_CHARACTER_SET_APPLICABILITY", coll_charset_app_fields_info,
4601
 
   create_schema_table, fill_schema_coll_charset_app, 0, 0, -1, -1, 0, 0},
4602
 
  {"COLUMNS", columns_fields_info, create_schema_table, 
4603
 
   get_all_tables, make_columns_old_format, get_schema_column_record, 1, 2, 0,
4604
 
   OPTIMIZE_I_S_TABLE|OPEN_VIEW_FULL},
4605
 
  {"GLOBAL_STATUS", variables_fields_info, create_schema_table,
4606
 
   fill_status, make_old_format, 0, -1, -1, 0, 0},
4607
 
  {"GLOBAL_VARIABLES", variables_fields_info, create_schema_table,
4608
 
   fill_variables, make_old_format, 0, -1, -1, 0, 0},
4609
 
  {"KEY_COLUMN_USAGE", key_column_usage_fields_info, create_schema_table,
4610
 
   get_all_tables, 0, get_schema_key_column_usage_record, 4, 5, 0,
4611
 
   OPEN_TABLE_ONLY},
4612
 
  {"OPEN_TABLES", open_tables_fields_info, create_schema_table,
4613
 
   fill_open_tables, make_old_format, 0, -1, -1, 1, 0},
4614
 
  {"PLUGINS", plugin_fields_info, create_schema_table,
4615
 
   fill_plugins, make_old_format, 0, -1, -1, 0, 0},
4616
 
  {"PROCESSLIST", processlist_fields_info, create_schema_table,
4617
 
   fill_schema_processlist, make_old_format, 0, -1, -1, 0, 0},
4618
 
  {"REFERENTIAL_CONSTRAINTS", referential_constraints_fields_info,
4619
 
   create_schema_table, get_all_tables, 0, get_referential_constraints_record,
4620
 
   1, 9, 0, OPEN_TABLE_ONLY},
4621
 
  {"SCHEMATA", schema_fields_info, create_schema_table,
4622
 
   fill_schema_schemata, make_schemata_old_format, 0, 1, -1, 0, 0},
4623
 
  {"SESSION_STATUS", variables_fields_info, create_schema_table,
4624
 
   fill_status, make_old_format, 0, -1, -1, 0, 0},
4625
 
  {"SESSION_VARIABLES", variables_fields_info, create_schema_table,
4626
 
   fill_variables, make_old_format, 0, -1, -1, 0, 0},
4627
 
  {"STATISTICS", stat_fields_info, create_schema_table, 
4628
 
   get_all_tables, make_old_format, get_schema_stat_record, 1, 2, 0,
4629
 
   OPEN_TABLE_ONLY|OPTIMIZE_I_S_TABLE},
4630
 
  {"STATUS", variables_fields_info, create_schema_table, fill_status, 
4631
 
   make_old_format, 0, -1, -1, 1, 0},
4632
 
  {"TABLES", tables_fields_info, create_schema_table, 
4633
 
   get_all_tables, make_old_format, get_schema_tables_record, 1, 2, 0,
4634
 
   OPTIMIZE_I_S_TABLE},
4635
 
  {"TABLE_CONSTRAINTS", table_constraints_fields_info, create_schema_table,
4636
 
   get_all_tables, 0, get_schema_constraints_record, 3, 4, 0, OPEN_TABLE_ONLY},
4637
 
  {"TABLE_NAMES", table_names_fields_info, create_schema_table,
4638
 
   get_all_tables, make_table_names_old_format, 0, 1, 2, 1, 0},
4639
 
  {"VARIABLES", variables_fields_info, create_schema_table, fill_variables,
4640
 
   make_old_format, 0, -1, -1, 1, 0},
4641
 
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
4642
 
};
4643
 
 
4644
 
 
4645
 
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
4646
 
template class List_iterator_fast<char>;
4647
 
template class List<char>;
4648
 
#endif
4649
 
 
4650
 
int initialize_schema_table(st_plugin_int *plugin)
4651
 
{
4652
 
  ST_SCHEMA_TABLE *schema_table;
4653
 
 
4654
 
  if (!(schema_table= (ST_SCHEMA_TABLE *)my_malloc(sizeof(ST_SCHEMA_TABLE),
4655
 
                                MYF(MY_WME | MY_ZEROFILL))))
4656
 
      return(1);
4657
 
  /* Historical Requirement */
4658
 
  plugin->data= schema_table; // shortcut for the future
4659
 
  if (plugin->plugin->init)
4660
 
  {
4661
 
    schema_table->create_table= create_schema_table;
4662
 
    schema_table->old_format= make_old_format;
4663
 
    schema_table->idx_field1= -1, 
4664
 
    schema_table->idx_field2= -1; 
4665
 
 
4666
 
    /* Make the name available to the init() function. */
4667
 
    schema_table->table_name= plugin->name.str;
4668
 
 
4669
 
    if (plugin->plugin->init(schema_table))
4670
 
    {
4671
 
      sql_print_error("Plugin '%s' init function returned error.",
4672
 
                      plugin->name.str);
4673
 
      goto err;
4674
 
    }
4675
 
    
4676
 
    /* Make sure the plugin name is not set inside the init() function. */
4677
 
    schema_table->table_name= plugin->name.str;
4678
 
  }
4679
 
 
4680
 
  return(0);
4681
 
err:
4682
 
  my_free(schema_table, MYF(0));
4683
 
  return(1);
4684
 
}
4685
 
 
4686
 
int finalize_schema_table(st_plugin_int *plugin)
4687
 
{
4688
 
  ST_SCHEMA_TABLE *schema_table= (ST_SCHEMA_TABLE *)plugin->data;
4689
 
 
4690
 
  if (schema_table && plugin->plugin->deinit)
4691
 
    my_free(schema_table, MYF(0));
4692
 
 
4693
 
  return(0);
4694
 
}
 
837
} /* namespace drizzled */