← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/sql_show.cc

  • Committer: Brian Aker
  • Date: 2008-07-14 16:24:25 UTC
  • Revision ID: brian@tangent.org-20080714162425-juw3vw221gs9kysh
Cleanup around intptr_t

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/sql_show.cc
15
15
 
16
16
 
17
17
/* Function with list databases, tables or fields */
18
 
#include <drizzled/server_includes.h>
19
 
#include <drizzled/sql_select.h>
20
 
#include <drizzled/sql_show.h>
 
18
 
 
19
#include "mysql_priv.h"
 
20
#include "sql_select.h"                         // For select_describe
 
21
#include "sql_show.h"
21
22
#include "repl_failsafe.h"
22
 
#include <mysys/my_dir.h>
23
 
#include <libdrizzle/gettext.h>
 
23
#include <my_dir.h>
24
24
 
25
 
inline const char *
26
 
str_or_nil(const char *str)
27
 
{
28
 
  return str ? str : "<nil>";
29
 
}
 
25
#define STR_OR_NIL(S) ((S) ? (S) : "<nil>")
30
26
 
31
27
/* Match the values of enum ha_choice */
32
28
static const char *ha_choice_values[] = {"", "0", "1"};
33
29
 
34
 
static void store_key_options(THD *thd, String *packet, Table *table,
 
30
static void store_key_options(THD *thd, String *packet, TABLE *table,
35
31
                              KEY *key_info);
36
32
 
37
33
 
38
34
 
39
 
int wild_case_compare(const CHARSET_INFO * const cs, const char *str,const char *wildstr)
 
35
int wild_case_compare(CHARSET_INFO *cs, const char *str,const char *wildstr)
40
36
{
41
37
  register int flag;
42
38
  while (*wildstr)
86
82
** List all table types supported
87
83
***************************************************************************/
88
84
 
 
85
static int make_version_string(char *buf, int buf_length, uint version)
 
86
{
 
87
  return snprintf(buf, buf_length, "%d.%d", version>>8,version&0xff);
 
88
}
 
89
 
89
90
static bool show_plugins(THD *thd, plugin_ref plugin,
90
91
                            void *arg)
91
92
{
92
 
  Table *table= (Table*) arg;
 
93
  TABLE *table= (TABLE*) arg;
93
94
  struct st_mysql_plugin *plug= plugin_decl(plugin);
94
95
  struct st_plugin_dl *plugin_dl= plugin_dlib(plugin);
95
 
  const CHARSET_INFO * const cs= system_charset_info;
 
96
  CHARSET_INFO *cs= system_charset_info;
 
97
  char version_buf[20];
96
98
 
97
99
  restore_record(table, s->default_values);
98
100
 
99
101
  table->field[0]->store(plugin_name(plugin)->str,
100
102
                         plugin_name(plugin)->length, cs);
101
103
 
102
 
  if (plug->version)
103
 
  {
104
 
    table->field[1]->store(plug->version, strlen(plug->version), cs);
105
 
    table->field[1]->set_notnull();
106
 
  }
107
 
  else
108
 
    table->field[1]->set_null();
 
104
  table->field[1]->store(version_buf,
 
105
        make_version_string(version_buf, sizeof(version_buf), plug->version),
 
106
        cs);
 
107
 
109
108
 
110
109
  switch (plugin_state(plugin)) {
111
110
  /* case PLUGIN_IS_FREED: does not happen */
125
124
  table->field[3]->store(plugin_type_names[plug->type].str,
126
125
                         plugin_type_names[plug->type].length,
127
126
                         cs);
 
127
  table->field[4]->store(version_buf,
 
128
        make_version_string(version_buf, sizeof(version_buf),
 
129
                            *(uint *)plug->info), cs);
128
130
 
129
131
  if (plugin_dl)
130
132
  {
131
 
    table->field[4]->store(plugin_dl->dl.str, plugin_dl->dl.length, cs);
132
 
    table->field[4]->set_notnull();
133
 
  }
134
 
  else
135
 
  {
136
 
    table->field[4]->set_null();
137
 
  }
138
 
 
139
 
  if (plug->author)
140
 
  {
141
 
    table->field[5]->store(plug->author, strlen(plug->author), cs);
 
133
    table->field[5]->store(plugin_dl->dl.str, plugin_dl->dl.length, cs);
142
134
    table->field[5]->set_notnull();
 
135
    table->field[6]->store(version_buf,
 
136
          make_version_string(version_buf, sizeof(version_buf),
 
137
                              plugin_dl->version),
 
138
          cs);
 
139
    table->field[6]->set_notnull();
143
140
  }
144
141
  else
 
142
  {
145
143
    table->field[5]->set_null();
 
144
    table->field[6]->set_null();
 
145
  }
 
146
 
 
147
 
 
148
  if (plug->author)
 
149
  {
 
150
    table->field[7]->store(plug->author, strlen(plug->author), cs);
 
151
    table->field[7]->set_notnull();
 
152
  }
 
153
  else
 
154
    table->field[7]->set_null();
146
155
 
147
156
  if (plug->descr)
148
157
  {
149
 
    table->field[6]->store(plug->descr, strlen(plug->descr), cs);
150
 
    table->field[6]->set_notnull();
 
158
    table->field[8]->store(plug->descr, strlen(plug->descr), cs);
 
159
    table->field[8]->set_notnull();
151
160
  }
152
161
  else
153
 
    table->field[6]->set_null();
 
162
    table->field[8]->set_null();
154
163
 
155
164
  switch (plug->license) {
156
165
  case PLUGIN_LICENSE_GPL:
157
 
    table->field[7]->store(PLUGIN_LICENSE_GPL_STRING, 
 
166
    table->field[9]->store(PLUGIN_LICENSE_GPL_STRING, 
158
167
                           strlen(PLUGIN_LICENSE_GPL_STRING), cs);
159
168
    break;
160
169
  case PLUGIN_LICENSE_BSD:
161
 
    table->field[7]->store(PLUGIN_LICENSE_BSD_STRING, 
 
170
    table->field[9]->store(PLUGIN_LICENSE_BSD_STRING, 
162
171
                           strlen(PLUGIN_LICENSE_BSD_STRING), cs);
163
172
    break;
164
173
  default:
165
 
    table->field[7]->store(PLUGIN_LICENSE_PROPRIETARY_STRING, 
 
174
    table->field[9]->store(PLUGIN_LICENSE_PROPRIETARY_STRING, 
166
175
                           strlen(PLUGIN_LICENSE_PROPRIETARY_STRING), cs);
167
176
    break;
168
177
  }
169
 
  table->field[7]->set_notnull();
 
178
  table->field[9]->set_notnull();
170
179
 
171
180
  return schema_table_store_record(thd, table);
172
181
}
173
182
 
174
183
 
175
 
int fill_plugins(THD *thd, TableList *tables, COND *cond __attribute__((unused)))
 
184
int fill_plugins(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((__unused__)))
176
185
{
177
 
  Table *table= tables->table;
 
186
  TABLE *table= tables->table;
178
187
 
179
 
  if (plugin_foreach_with_mask(thd, show_plugins, DRIZZLE_ANY_PLUGIN,
 
188
  if (plugin_foreach_with_mask(thd, show_plugins, MYSQL_ANY_PLUGIN,
180
189
                               ~PLUGIN_IS_FREED, table))
181
190
    return(1);
182
191
 
191
200
    find_files()
192
201
    thd                 thread handler
193
202
    files               put found files in this list
194
 
    db                  database name to set in TableList structure
 
203
    db                  database name to set in TABLE_LIST structure
195
204
    path                path to database
196
205
    wild                filter for found files
197
 
    dir                 read databases in path if true, read .frm files in
 
206
    dir                 read databases in path if TRUE, read .frm files in
198
207
                        database otherwise
199
208
 
200
209
  RETURN
208
217
find_files(THD *thd, List<LEX_STRING> *files, const char *db,
209
218
           const char *path, const char *wild, bool dir)
210
219
{
211
 
  uint32_t i;
 
220
  uint i;
212
221
  char *ext;
213
222
  MY_DIR *dirp;
214
223
  FILEINFO *file;
215
224
  LEX_STRING *file_name= 0;
216
 
  uint32_t file_name_len;
217
 
  TableList table_list;
 
225
  uint file_name_len;
 
226
  TABLE_LIST table_list;
218
227
 
219
228
  if (wild && !wild[0])
220
229
    wild=0;
221
230
 
222
 
  memset(&table_list, 0, sizeof(table_list));
 
231
  bzero((char*) &table_list,sizeof(table_list));
223
232
 
224
233
  if (!(dirp = my_dir(path,MYF(dir ? MY_WANT_STAT : 0))))
225
234
  {
249
258
        char *end;
250
259
        *ext=0;                                 /* Remove extension */
251
260
        unpack_dirname(buff, file->name);
252
 
        end= strchr(buff, '\0');
 
261
        end= strend(buff);
253
262
        if (end != buff && end[-1] == FN_LIBCHAR)
254
263
          end[-1]= 0;                           // Remove end FN_LIBCHAR
255
264
        if (stat(buff, file->mystat))
256
265
               continue;
257
266
       }
258
267
#endif
259
 
      if (!S_ISDIR(file->mystat->st_mode))
 
268
      if (!MY_S_ISDIR(file->mystat->st_mode))
260
269
        continue;
261
270
 
262
271
      file_name_len= filename_to_tablename(file->name, uname, sizeof(uname));
263
272
      if (wild && wild_compare(uname, wild, 0))
264
273
        continue;
265
274
      if (!(file_name= 
266
 
            thd->make_lex_string(file_name, uname, file_name_len, true)))
 
275
            thd->make_lex_string(file_name, uname, file_name_len, TRUE)))
267
276
      {
268
277
        my_dirend(dirp);
269
278
        return(FIND_FILES_OOM);
289
298
      }
290
299
    }
291
300
    if (!(file_name= 
292
 
          thd->make_lex_string(file_name, uname, file_name_len, true)) ||
 
301
          thd->make_lex_string(file_name, uname, file_name_len, TRUE)) ||
293
302
        files->push_back(file_name))
294
303
    {
295
304
      my_dirend(dirp);
303
312
 
304
313
 
305
314
bool
306
 
mysqld_show_create(THD *thd, TableList *table_list)
 
315
mysqld_show_create(THD *thd, TABLE_LIST *table_list)
307
316
{
308
317
  Protocol *protocol= thd->protocol;
309
318
  char buff[2048];
313
322
  if (open_normal_and_derived_tables(thd, table_list, 0))
314
323
  {
315
324
    if (thd->is_error() && thd->main_da.sql_errno() != ER_VIEW_INVALID)
316
 
      return(true);
 
325
      return(TRUE);
317
326
 
318
327
    /*
319
328
      Clear all messages with 'error' level status and
320
329
      issue a warning with 'warning' level status in 
321
330
      case of invalid view and last error is ER_VIEW_INVALID
322
331
    */
323
 
    drizzle_reset_errors(thd, true);
 
332
    mysql_reset_errors(thd, true);
324
333
    thd->clear_error();
325
334
  }
326
335
 
327
336
  buffer.length(0);
328
337
 
329
338
  if (store_create_info(thd, table_list, &buffer, NULL))
330
 
    return(true);
 
339
    return(TRUE);
331
340
 
332
341
  List<Item> field_list;
333
342
  {
334
343
    field_list.push_back(new Item_empty_string("Table",NAME_CHAR_LEN));
335
344
    // 1024 is for not to confuse old clients
336
345
    field_list.push_back(new Item_empty_string("Create Table",
337
 
                                               cmax(buffer.length(),(uint32_t)1024)));
 
346
                                               max(buffer.length(),1024)));
338
347
  }
339
348
 
340
349
  if (protocol->send_fields(&field_list,
341
350
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
342
 
    return(true);
 
351
    return(TRUE);
343
352
  protocol->prepare_for_resend();
344
353
  {
345
354
    if (table_list->schema_table)
352
361
  protocol->store(buffer.ptr(), buffer.length(), buffer.charset());
353
362
 
354
363
  if (protocol->write())
355
 
    return(true);
 
364
    return(TRUE);
356
365
 
357
366
  my_eof(thd);
358
 
  return(false);
 
367
  return(FALSE);
359
368
}
360
369
 
361
370
bool mysqld_show_create_db(THD *thd, char *dbname,
372
381
      can fail is incorrect database name (which is the case now).
373
382
    */
374
383
    my_error(ER_BAD_DB_ERROR, MYF(0), dbname);
375
 
    return(true);    
 
384
    return(TRUE);    
376
385
  }
377
386
 
378
387
  List<Item> field_list;
381
390
 
382
391
  if (protocol->send_fields(&field_list,
383
392
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
384
 
    return(true);
 
393
    return(TRUE);
385
394
 
386
395
  protocol->prepare_for_resend();
387
396
  protocol->store(dbname, strlen(dbname), system_charset_info);
388
397
  protocol->store(buffer.ptr(), buffer.length(), buffer.charset());
389
398
 
390
399
  if (protocol->write())
391
 
    return(true);
 
400
    return(TRUE);
392
401
  my_eof(thd);
393
 
  return(false);
 
402
  return(FALSE);
394
403
}
395
404
 
396
405
 
401
410
****************************************************************************/
402
411
 
403
412
void
404
 
mysqld_list_fields(THD *thd, TableList *table_list, const char *wild)
 
413
mysqld_list_fields(THD *thd, TABLE_LIST *table_list, const char *wild)
405
414
{
406
 
  Table *table;
 
415
  TABLE *table;
407
416
 
408
417
  if (open_normal_and_derived_tables(thd, table_list, 0))
409
418
    return;
443
452
    0   No conflicting character
444
453
*/
445
454
 
446
 
static const char *require_quotes(const char *name, uint32_t name_length)
 
455
static const char *require_quotes(const char *name, uint name_length)
447
456
{
448
 
  uint32_t length;
449
 
  bool pure_digit= true;
 
457
  uint length;
 
458
  bool pure_digit= TRUE;
450
459
  const char *end= name + name_length;
451
460
 
452
461
  for (; name < end ; name++)
453
462
  {
454
 
    unsigned char chr= (unsigned char) *name;
 
463
    uchar chr= (uchar) *name;
455
464
    length= my_mbcharlen(system_charset_info, chr);
456
465
    if (length == 1 && !system_charset_info->ident_map[chr])
457
466
      return name;
458
467
    if (length == 1 && (chr < '0' || chr > '9'))
459
 
      pure_digit= false;
 
468
      pure_digit= FALSE;
460
469
  }
461
470
  if (pure_digit)
462
471
    return name;
477
486
*/
478
487
 
479
488
void
480
 
append_identifier(THD *thd, String *packet, const char *name, uint32_t length)
 
489
append_identifier(THD *thd, String *packet, const char *name, uint length)
481
490
{
482
491
  const char *name_end;
483
492
  char quote_char;
494
503
   it's a keyword
495
504
  */
496
505
 
497
 
  packet->reserve(length*2 + 2);
 
506
  VOID(packet->reserve(length*2 + 2));
498
507
  quote_char= (char) q;
499
508
  packet->append(&quote_char, 1, system_charset_info);
500
509
 
501
510
  for (name_end= name+length ; name < name_end ; name+= length)
502
511
  {
503
 
    unsigned char chr= (unsigned char) *name;
 
512
    uchar chr= (uchar) *name;
504
513
    length= my_mbcharlen(system_charset_info, chr);
505
514
    /*
506
515
      my_mbcharlen can return 0 on a wrong multibyte
511
520
    */
512
521
    if (!length)
513
522
      length= 1;
514
 
    if (length == 1 && chr == (unsigned char) quote_char)
 
523
    if (length == 1 && chr == (uchar) quote_char)
515
524
      packet->append(&quote_char, 1, system_charset_info);
516
525
    packet->append(name, length, system_charset_info);
517
526
  }
542
551
    #     Quote character
543
552
*/
544
553
 
545
 
int get_quote_char_for_identifier(THD *thd, const char *name, uint32_t length)
 
554
int get_quote_char_for_identifier(THD *thd, const char *name, uint length)
546
555
{
547
556
  if (length &&
548
557
      !is_keyword(name,length) &&
549
558
      !require_quotes(name, length) &&
550
559
      !(thd->options & OPTION_QUOTE_SHOW_CREATE))
551
560
    return EOF;
552
 
  return '`';
 
561
  return '"';
553
562
}
554
563
 
555
564
 
556
565
/* Append directory name (if exists) to CREATE INFO */
557
566
 
558
 
static void append_directory(THD *thd __attribute__((unused)),
 
567
static void append_directory(THD *thd __attribute__((__unused__)),
559
568
                             String *packet, const char *dir_type,
560
569
                             const char *filename)
561
570
{
562
571
  if (filename)
563
572
  {
564
 
    uint32_t length= dirname_length(filename);
 
573
    uint length= dirname_length(filename);
565
574
    packet->append(' ');
566
575
    packet->append(dir_type);
567
576
    packet->append(STRING_WITH_LEN(" DIRECTORY='"));
573
582
 
574
583
#define LIST_PROCESS_HOST_LEN 64
575
584
 
576
 
static bool get_field_default_value(THD *thd __attribute__((unused)),
 
585
static bool get_field_default_value(THD *thd __attribute__((__unused__)),
577
586
                                    Field *timestamp_field,
578
587
                                    Field *field, String *def_value,
579
588
                                    bool quoted)
588
597
  has_now_default= (timestamp_field == field &&
589
598
                    field->unireg_check != Field::TIMESTAMP_UN_FIELD);
590
599
    
591
 
  has_default= (field->type() != DRIZZLE_TYPE_BLOB &&
 
600
  has_default= (field->type() != FIELD_TYPE_BLOB &&
592
601
                !(field->flags & NO_DEFAULT_VALUE_FLAG) &&
593
602
                field->unireg_check != Field::NEXT_NUMBER
594
603
                  && has_now_default);
606
615
      if (type.length())
607
616
      {
608
617
        String def_val;
609
 
        uint32_t dummy_errors;
 
618
        uint dummy_errors;
610
619
        /* convert to system_charset_info == utf8 */
611
620
        def_val.copy(type.ptr(), type.length(), field->charset(),
612
621
                     system_charset_info, &dummy_errors);
650
659
    0       OK
651
660
 */
652
661
 
653
 
int store_create_info(THD *thd, TableList *table_list, String *packet,
 
662
int store_create_info(THD *thd, TABLE_LIST *table_list, String *packet,
654
663
                      HA_CREATE_INFO *create_info_arg)
655
664
{
656
665
  List<Item> field_list;
659
668
  String type(tmp, sizeof(tmp), system_charset_info);
660
669
  String def_value(def_value_buf, sizeof(def_value_buf), system_charset_info);
661
670
  Field **ptr,*field;
662
 
  uint32_t primary_key;
 
671
  uint primary_key;
663
672
  KEY *key_info;
664
 
  Table *table= table_list->table;
 
673
  TABLE *table= table_list->table;
665
674
  handler *file= table->file;
666
675
  TABLE_SHARE *share= table->s;
667
676
  HA_CREATE_INFO create_info;
668
 
  bool show_table_options= false;
 
677
  bool show_table_options= FALSE;
669
678
  my_bitmap_map *old_map;
670
679
 
671
680
  restore_record(table, s->default_values); // Get empty record
695
704
    We have to restore the read_set if we are called from insert in case
696
705
    of row based replication.
697
706
  */
698
 
  old_map= table->use_all_columns(table->read_set);
 
707
  old_map= tmp_use_all_columns(table, table->read_set);
699
708
 
700
709
  for (ptr=table->field ; (field= *ptr); ptr++)
701
710
  {
702
 
    uint32_t flags = field->flags;
 
711
    uint flags = field->flags;
703
712
 
704
713
    if (ptr != table->field)
705
714
      packet->append(STRING_WITH_LEN(",\n"));
736
745
 
737
746
    if (flags & NOT_NULL_FLAG)
738
747
      packet->append(STRING_WITH_LEN(" NOT NULL"));
739
 
    else if (field->type() == DRIZZLE_TYPE_TIMESTAMP)
 
748
    else if (field->type() == MYSQL_TYPE_TIMESTAMP)
740
749
    {
741
750
      /*
742
751
        TIMESTAMP field require explicit NULL flag, because unlike
754
763
      if (column_format)
755
764
      {
756
765
        packet->append(STRING_WITH_LEN(" /*!"));
757
 
        packet->append(STRING_WITH_LEN(DRIZZLE_VERSION_TABLESPACE_IN_FRM_STR));
 
766
        packet->append(STRING_WITH_LEN(MYSQL_VERSION_TABLESPACE_IN_FRM_STR));
758
767
        packet->append(STRING_WITH_LEN(" COLUMN_FORMAT"));
759
768
        if (column_format == COLUMN_FORMAT_TYPE_FIXED)
760
769
          packet->append(STRING_WITH_LEN(" FIXED */"));
783
792
  }
784
793
 
785
794
  key_info= table->key_info;
786
 
  memset(&create_info, 0, sizeof(create_info));
 
795
  bzero((char*) &create_info, sizeof(create_info));
787
796
  /* Allow update_create_info to update row type */
788
797
  create_info.row_type= share->row_type;
789
798
  file->update_create_info(&create_info);
790
799
  primary_key= share->primary_key;
791
800
 
792
 
  for (uint32_t i=0 ; i < share->keys ; i++,key_info++)
 
801
  for (uint i=0 ; i < share->keys ; i++,key_info++)
793
802
  {
794
803
    KEY_PART_INFO *key_part= key_info->key_part;
795
804
    bool found_primary=0;
814
823
 
815
824
    packet->append(STRING_WITH_LEN(" ("));
816
825
 
817
 
    for (uint32_t j=0 ; j < key_info->key_parts ; j++,key_part++)
 
826
    for (uint j=0 ; j < key_info->key_parts ; j++,key_part++)
818
827
    {
819
828
      if (j)
820
829
        packet->append(',');
852
861
 
853
862
  packet->append(STRING_WITH_LEN("\n)"));
854
863
  {
855
 
    show_table_options= true;
 
864
    show_table_options= TRUE;
856
865
    /*
857
866
      Get possible table space definitions and append them
858
867
      to the CREATE TABLE statement
888
897
      packet->append(buff, (uint) (end - buff));
889
898
    }
890
899
 
 
900
    
 
901
    if (share->table_charset)
 
902
    {
 
903
      /*
 
904
        IF   check_create_info
 
905
        THEN add DEFAULT CHARSET only if it was used when creating the table
 
906
      */
 
907
      if (!create_info_arg ||
 
908
          (create_info_arg->used_fields & HA_CREATE_USED_DEFAULT_CHARSET))
 
909
      {
 
910
        packet->append(STRING_WITH_LEN(" DEFAULT CHARSET="));
 
911
        packet->append(share->table_charset->csname);
 
912
        if (!(share->table_charset->state & MY_CS_PRIMARY))
 
913
        {
 
914
          packet->append(STRING_WITH_LEN(" COLLATE="));
 
915
          packet->append(table->s->table_charset->name);
 
916
        }
 
917
      }
 
918
    }
 
919
 
891
920
    if (share->min_rows)
892
921
    {
893
922
      char *end;
943
972
      end= int64_t10_to_str(table->s->key_block_size, buff, 10);
944
973
      packet->append(buff, (uint) (end - buff));
945
974
    }
946
 
    if (share->block_size)
947
 
    {
948
 
      char *end;
949
 
      packet->append(STRING_WITH_LEN(" BLOCK_SIZE="));
950
 
      end= int64_t10_to_str(share->block_size, buff,10);
951
 
      packet->append(buff, (uint) (end - buff));
952
 
    }
953
975
    table->file->append_create_info(packet);
954
976
    if (share->comment.length)
955
977
    {
964
986
    append_directory(thd, packet, "DATA",  create_info.data_file_name);
965
987
    append_directory(thd, packet, "INDEX", create_info.index_file_name);
966
988
  }
967
 
  table->restore_column_map(old_map);
 
989
  tmp_restore_column_map(table->read_set, old_map);
968
990
  return(0);
969
991
}
970
992
 
987
1009
  @param  create_info   If not NULL, the options member influences the resulting 
988
1010
                        CRATE statement.
989
1011
 
990
 
  @returns true if errors are detected, false otherwise.
 
1012
  @returns TRUE if errors are detected, FALSE otherwise.
991
1013
*/
992
1014
 
993
1015
bool store_db_create_info(THD *thd, const char *dbname, String *buffer,
994
1016
                          HA_CREATE_INFO *create_info)
995
1017
{
996
1018
  HA_CREATE_INFO create;
997
 
  uint32_t create_options = create_info ? create_info->options : 0;
 
1019
  uint create_options = create_info ? create_info->options : 0;
998
1020
 
999
1021
  if (!my_strcasecmp(system_charset_info, dbname,
1000
1022
                     INFORMATION_SCHEMA_NAME.str))
1005
1027
  else
1006
1028
  {
1007
1029
    if (check_db_dir_existence(dbname))
1008
 
      return(true);
 
1030
      return(TRUE);
1009
1031
 
1010
1032
    load_db_opt_by_name(thd, dbname, &create);
1011
1033
  }
1033
1055
    buffer->append(STRING_WITH_LEN(" */"));
1034
1056
  }
1035
1057
 
1036
 
  return(false);
 
1058
  return(FALSE);
1037
1059
}
1038
1060
 
1039
 
static void store_key_options(THD *thd __attribute__((unused)),
1040
 
                              String *packet, Table *table,
 
1061
static void store_key_options(THD *thd __attribute__((__unused__)),
 
1062
                              String *packet, TABLE *table,
1041
1063
                              KEY *key_info)
1042
1064
{
1043
1065
  char *end, buff[32];
1084
1106
 
1085
1107
  ulong thread_id;
1086
1108
  time_t start_time;
1087
 
  uint32_t   command;
 
1109
  uint   command;
1088
1110
  const char *user,*host,*db,*proc_info,*state_info;
1089
1111
  char *query;
1090
1112
};
1108
1130
  field_list.push_back(field=new Item_empty_string("db",NAME_CHAR_LEN));
1109
1131
  field->maybe_null=1;
1110
1132
  field_list.push_back(new Item_empty_string("Command",16));
1111
 
  field_list.push_back(new Item_return_int("Time",7, DRIZZLE_TYPE_LONG));
 
1133
  field_list.push_back(new Item_return_int("Time",7, MYSQL_TYPE_LONG));
1112
1134
  field_list.push_back(field=new Item_empty_string("State",30));
1113
1135
  field->maybe_null=1;
1114
1136
  field_list.push_back(field=new Item_empty_string("Info",max_query_length));
1117
1139
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
1118
1140
    return;
1119
1141
 
1120
 
  pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
 
1142
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
1121
1143
  if (!thd->killed)
1122
1144
  {
1123
1145
    I_List_iterator<THD> it(threads);
1134
1156
        thd_info->user= thd->strdup(tmp_sctx->user ? tmp_sctx->user :
1135
1157
                                    (tmp->system_thread ?
1136
1158
                                     "system user" : "unauthenticated user"));
1137
 
        thd_info->host= thd->strdup(tmp_sctx->ip);
 
1159
        thd_info->host= thd->strdup(tmp_sctx->host_or_ip[0] ? 
 
1160
                                    tmp_sctx->host_or_ip : 
 
1161
                                    tmp_sctx->host ? tmp_sctx->host : "");
1138
1162
        if ((thd_info->db=tmp->db))             // Safe test
1139
1163
          thd_info->db=thd->strdup(thd_info->db);
1140
1164
        thd_info->command=(int) tmp->command;
1144
1168
        thd_info->state_info= (char*) (tmp->net.reading_or_writing ?
1145
1169
                                       (tmp->net.reading_or_writing == 2 ?
1146
1170
                                        "Writing to net" :
1147
 
                                        thd_info->command == COM_SLEEP ? NULL :
 
1171
                                        thd_info->command == COM_SLEEP ? NullS :
1148
1172
                                        "Reading from net") :
1149
 
                                       tmp->get_proc_info() ? tmp->get_proc_info() :
 
1173
                                       tmp->proc_info ? tmp->proc_info :
1150
1174
                                       tmp->mysys_var &&
1151
1175
                                       tmp->mysys_var->current_cond ?
1152
 
                                       "Waiting on cond" : NULL);
 
1176
                                       "Waiting on cond" : NullS);
1153
1177
        if (mysys_var)
1154
1178
          pthread_mutex_unlock(&mysys_var->mutex);
1155
1179
 
1162
1186
            the comment in sql_class.h why this prevents crashes in possible
1163
1187
            races with query_length
1164
1188
          */
1165
 
          uint32_t length= cmin((uint32_t)max_query_length, tmp->query_length);
 
1189
          uint length= min(max_query_length, tmp->query_length);
1166
1190
          thd_info->query=(char*) thd->strmake(tmp->query,length);
1167
1191
        }
1168
1192
        thread_infos.append(thd_info);
1169
1193
      }
1170
1194
    }
1171
1195
  }
1172
 
  pthread_mutex_unlock(&LOCK_thread_count);
 
1196
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
1173
1197
 
1174
1198
  thread_info *thd_info;
1175
1199
  time_t now= my_time(0);
1185
1209
    else
1186
1210
      protocol->store(command_name[thd_info->command].str, system_charset_info);
1187
1211
    if (thd_info->start_time)
1188
 
      protocol->store((uint32_t) (now - thd_info->start_time));
 
1212
      protocol->store((uint32) (now - thd_info->start_time));
1189
1213
    else
1190
1214
      protocol->store_null();
1191
1215
    protocol->store(thd_info->state_info, system_charset_info);
1197
1221
  return;
1198
1222
}
1199
1223
 
1200
 
int fill_schema_processlist(THD* thd, TableList* tables,
1201
 
                            COND* cond __attribute__((unused)))
 
1224
int fill_schema_processlist(THD* thd, TABLE_LIST* tables,
 
1225
                            COND* cond __attribute__((__unused__)))
1202
1226
{
1203
 
  Table *table= tables->table;
1204
 
  const CHARSET_INFO * const cs= system_charset_info;
 
1227
  TABLE *table= tables->table;
 
1228
  CHARSET_INFO *cs= system_charset_info;
1205
1229
  char *user;
1206
1230
  time_t now= my_time(0);
1207
1231
 
1208
 
  user= NULL;
 
1232
  user= NullS;
1209
1233
 
1210
 
  pthread_mutex_lock(&LOCK_thread_count);
 
1234
  VOID(pthread_mutex_lock(&LOCK_thread_count));
1211
1235
 
1212
1236
  if (!thd->killed)
1213
1237
  {
1225
1249
 
1226
1250
      restore_record(table, s->default_values);
1227
1251
      /* ID */
1228
 
      table->field[0]->store((int64_t) tmp->thread_id, true);
 
1252
      table->field[0]->store((int64_t) tmp->thread_id, TRUE);
1229
1253
      /* USER */
1230
1254
      val= tmp_sctx->user ? tmp_sctx->user :
1231
1255
            (tmp->system_thread ? "system user" : "unauthenticated user");
1232
1256
      table->field[1]->store(val, strlen(val), cs);
1233
1257
      /* HOST */
1234
 
      table->field[2]->store(tmp_sctx->ip, strlen(tmp_sctx->ip), cs);
 
1258
      table->field[2]->store(tmp_sctx->host_or_ip,
 
1259
                             strlen(tmp_sctx->host_or_ip), cs);
1235
1260
      /* DB */
1236
1261
      if (tmp->db)
1237
1262
      {
1247
1272
      else
1248
1273
        table->field[4]->store(command_name[tmp->command].str,
1249
1274
                               command_name[tmp->command].length, cs);
1250
 
      /* DRIZZLE_TIME */
1251
 
      table->field[5]->store((uint32_t)(tmp->start_time ?
1252
 
                                      now - tmp->start_time : 0), true);
 
1275
      /* MYSQL_TIME */
 
1276
      table->field[5]->store((uint32)(tmp->start_time ?
 
1277
                                      now - tmp->start_time : 0), TRUE);
1253
1278
      /* STATE */
1254
1279
      val= (char*) (tmp->net.reading_or_writing ?
1255
1280
                    (tmp->net.reading_or_writing == 2 ?
1256
1281
                     "Writing to net" :
1257
 
                     tmp->command == COM_SLEEP ? NULL :
 
1282
                     tmp->command == COM_SLEEP ? NullS :
1258
1283
                     "Reading from net") :
1259
 
                    tmp->get_proc_info() ? tmp->get_proc_info() :
 
1284
                    tmp->proc_info ? tmp->proc_info :
1260
1285
                    tmp->mysys_var &&
1261
1286
                    tmp->mysys_var->current_cond ?
1262
 
                    "Waiting on cond" : NULL);
 
1287
                    "Waiting on cond" : NullS);
1263
1288
      if (val)
1264
1289
      {
1265
1290
        table->field[6]->store(val, strlen(val), cs);
1273
1298
      if (tmp->query)
1274
1299
      {
1275
1300
        table->field[7]->store(tmp->query,
1276
 
                               cmin((uint32_t)PROCESS_LIST_INFO_WIDTH,
 
1301
                               min(PROCESS_LIST_INFO_WIDTH,
1277
1302
                                   tmp->query_length), cs);
1278
1303
        table->field[7]->set_notnull();
1279
1304
      }
1280
1305
 
1281
1306
      if (schema_table_store_record(thd, table))
1282
1307
      {
1283
 
        pthread_mutex_unlock(&LOCK_thread_count);
 
1308
        VOID(pthread_mutex_unlock(&LOCK_thread_count));
1284
1309
        return(1);
1285
1310
      }
1286
1311
    }
1287
1312
  }
1288
1313
 
1289
 
  pthread_mutex_unlock(&LOCK_thread_count);
 
1314
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
1290
1315
  return(0);
1291
1316
}
1292
1317
 
1307
1332
*/
1308
1333
static void shrink_var_array(DYNAMIC_ARRAY *array)
1309
1334
{
1310
 
  uint32_t a,b;
 
1335
  uint a,b;
1311
1336
  SHOW_VAR *all= dynamic_element(array, 0, SHOW_VAR *);
1312
1337
 
1313
1338
  for (a= b= 0; b < array->elements; b++)
1315
1340
      all[a++]= all[b];
1316
1341
  if (a)
1317
1342
  {
1318
 
    memset(all+a, 0, sizeof(SHOW_VAR)); // writing NULL-element to the end
 
1343
    bzero(all+a, sizeof(SHOW_VAR)); // writing NULL-element to the end
1319
1344
    array->elements= a;
1320
1345
  }
1321
1346
  else // array is completely empty - delete it
1353
1378
    goto err;
1354
1379
  }
1355
1380
  while (list->name)
1356
 
    res|= insert_dynamic(&all_status_vars, (unsigned char*)list++);
1357
 
  res|= insert_dynamic(&all_status_vars, (unsigned char*)list); // appending NULL-element
 
1381
    res|= insert_dynamic(&all_status_vars, (uchar*)list++);
 
1382
  res|= insert_dynamic(&all_status_vars, (uchar*)list); // appending NULL-element
1358
1383
  all_status_vars.elements--; // but next insert_dynamic should overwite it
1359
1384
  if (status_vars_inited)
1360
1385
    sort_dynamic(&all_status_vars, show_var_cmp);
1448
1473
  else
1449
1474
  {
1450
1475
    SHOW_VAR *all= dynamic_element(&all_status_vars, 0, SHOW_VAR *);
1451
 
    uint32_t i;
 
1476
    uint i;
1452
1477
    for (; list->name; list++)
1453
1478
    {
1454
1479
      for (i= 0; i < all_status_vars.elements; i++)
1473
1498
                              SHOW_VAR *variables,
1474
1499
                              enum enum_var_type value_type,
1475
1500
                              struct system_status_var *status_var,
1476
 
                              const char *prefix, Table *table,
 
1501
                              const char *prefix, TABLE *table,
1477
1502
                              bool ucase_names)
1478
1503
{
1479
1504
  MY_ALIGNED_BYTE_ARRAY(buff_data, SHOW_VAR_FUNC_BUFF_SIZE, long);
1488
1513
  null_lex_str.str= 0;                          // For sys_var->value_ptr()
1489
1514
  null_lex_str.length= 0;
1490
1515
 
1491
 
  prefix_end=my_stpncpy(name_buffer, prefix, sizeof(name_buffer)-1);
 
1516
  prefix_end=strnmov(name_buffer, prefix, sizeof(name_buffer)-1);
1492
1517
  if (*prefix)
1493
1518
    *prefix_end++= '_';
1494
1519
  len=name_buffer + sizeof(name_buffer) - prefix_end;
1495
1520
 
1496
1521
  for (; variables->name; variables++)
1497
1522
  {
1498
 
    my_stpncpy(prefix_end, variables->name, len);
 
1523
    strnmov(prefix_end, variables->name, len);
1499
1524
    name_buffer[sizeof(name_buffer)-1]=0;       /* Safety */
1500
1525
    if (ucase_names)
1501
1526
      make_upper(name_buffer);
1560
1585
          end= int64_t10_to_str((int64_t) *(ha_rows*) value, buff, 10);
1561
1586
          break;
1562
1587
        case SHOW_BOOL:
1563
 
          end= my_stpcpy(buff, *(bool*) value ? "ON" : "OFF");
 
1588
          end= strmov(buff, *(bool*) value ? "ON" : "OFF");
1564
1589
          break;
1565
1590
        case SHOW_MY_BOOL:
1566
 
          end= my_stpcpy(buff, *(bool*) value ? "ON" : "OFF");
 
1591
          end= strmov(buff, *(bool*) value ? "ON" : "OFF");
1567
1592
          break;
1568
1593
        case SHOW_INT:
1569
 
          end= int10_to_str((long) *(uint32_t*) value, buff, 10);
 
1594
          end= int10_to_str((long) *(uint32*) value, buff, 10);
1570
1595
          break;
1571
1596
        case SHOW_HAVE:
1572
1597
        {
1573
1598
          SHOW_COMP_OPTION tmp= *(SHOW_COMP_OPTION*) value;
1574
1599
          pos= show_comp_option_name[(int) tmp];
1575
 
          end= strchr(pos, '\0');
 
1600
          end= strend(pos);
1576
1601
          break;
1577
1602
        }
1578
1603
        case SHOW_CHAR:
1579
1604
        {
1580
1605
          if (!(pos= value))
1581
1606
            pos= "";
1582
 
          end= strchr(pos, '\0');
 
1607
          end= strend(pos);
1583
1608
          break;
1584
1609
        }
1585
1610
       case SHOW_CHAR_PTR:
1586
1611
        {
1587
1612
          if (!(pos= *(char**) value))
1588
1613
            pos= "";
1589
 
          end= strchr(pos, '\0');
 
1614
          end= strend(pos);
1590
1615
          break;
1591
1616
        }
1592
1617
        case SHOW_KEY_CACHE_LONG:
1607
1632
        restore_record(table, s->default_values);
1608
1633
        table->field[0]->store(name_buffer, strlen(name_buffer),
1609
1634
                               system_charset_info);
1610
 
        table->field[1]->store(pos, (uint32_t) (end - pos), system_charset_info);
 
1635
        table->field[1]->store(pos, (uint32) (end - pos), system_charset_info);
1611
1636
        table->field[1]->set_notnull();
1612
1637
 
1613
1638
        pthread_mutex_unlock(&LOCK_global_system_variables);
1614
1639
 
1615
1640
        if (schema_table_store_record(thd, table))
1616
 
          return(true);
 
1641
          return(TRUE);
1617
1642
      }
1618
1643
    }
1619
1644
  }
1620
1645
 
1621
 
  return(false);
 
1646
  return(FALSE);
1622
1647
}
1623
1648
 
1624
1649
 
1628
1653
{
1629
1654
 
1630
1655
  /* Ensure that thread id not killed during loop */
1631
 
  pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
 
1656
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
1632
1657
 
1633
1658
  I_List_iterator<THD> it(threads);
1634
1659
  THD *tmp;
1640
1665
  while ((tmp= it++))
1641
1666
    add_to_status(to, &tmp->status_var);
1642
1667
  
1643
 
  pthread_mutex_unlock(&LOCK_thread_count);
 
1668
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
1644
1669
  return;
1645
1670
}
1646
1671
 
1669
1694
    1                     error
1670
1695
*/
1671
1696
 
1672
 
bool schema_table_store_record(THD *thd, Table *table)
 
1697
bool schema_table_store_record(THD *thd, TABLE *table)
1673
1698
{
1674
1699
  int error;
1675
1700
  if ((error= table->file->ha_write_row(table->record[0])))
1715
1740
*/
1716
1741
 
1717
1742
bool get_lookup_value(THD *thd, Item_func *item_func,
1718
 
                      TableList *table, 
 
1743
                      TABLE_LIST *table, 
1719
1744
                      LOOKUP_FIELD_VALUES *lookup_field_vals)
1720
1745
{
1721
1746
  ST_SCHEMA_TABLE *schema_table= table->schema_table;
1732
1757
    char tmp[MAX_FIELD_WIDTH];
1733
1758
    String *tmp_str, str_buff(tmp, sizeof(tmp), system_charset_info);
1734
1759
    Item_field *item_field;
1735
 
    const CHARSET_INFO * const cs= system_charset_info;
 
1760
    CHARSET_INFO *cs= system_charset_info;
1736
1761
 
1737
1762
    if (item_func->arguments()[0]->type() == Item::FIELD_ITEM &&
1738
1763
        item_func->arguments()[1]->const_item())
1759
1784
      return 1;
1760
1785
 
1761
1786
    /* Lookup value is database name */
1762
 
    if (!cs->coll->strnncollsp(cs, (unsigned char *) field_name1, strlen(field_name1),
1763
 
                               (unsigned char *) item_field->field_name,
 
1787
    if (!cs->coll->strnncollsp(cs, (uchar *) field_name1, strlen(field_name1),
 
1788
                               (uchar *) item_field->field_name,
1764
1789
                               strlen(item_field->field_name), 0))
1765
1790
    {
1766
1791
      thd->make_lex_string(&lookup_field_vals->db_value, tmp_str->ptr(),
1767
 
                           tmp_str->length(), false);
 
1792
                           tmp_str->length(), FALSE);
1768
1793
    }
1769
1794
    /* Lookup value is table name */
1770
 
    else if (!cs->coll->strnncollsp(cs, (unsigned char *) field_name2,
 
1795
    else if (!cs->coll->strnncollsp(cs, (uchar *) field_name2,
1771
1796
                                    strlen(field_name2),
1772
 
                                    (unsigned char *) item_field->field_name,
 
1797
                                    (uchar *) item_field->field_name,
1773
1798
                                    strlen(item_field->field_name), 0))
1774
1799
    {
1775
1800
      thd->make_lex_string(&lookup_field_vals->table_value, tmp_str->ptr(),
1776
 
                           tmp_str->length(), false);
 
1801
                           tmp_str->length(), FALSE);
1777
1802
    }
1778
1803
  }
1779
1804
  return 0;
1797
1822
    1             error, there can be no matching records for the condition
1798
1823
*/
1799
1824
 
1800
 
bool calc_lookup_values_from_cond(THD *thd, COND *cond, TableList *table,
 
1825
bool calc_lookup_values_from_cond(THD *thd, COND *cond, TABLE_LIST *table,
1801
1826
                                  LOOKUP_FIELD_VALUES *lookup_field_vals)
1802
1827
{
1803
1828
  if (!cond)
1832
1857
}
1833
1858
 
1834
1859
 
1835
 
bool uses_only_table_name_fields(Item *item, TableList *table)
 
1860
bool uses_only_table_name_fields(Item *item, TABLE_LIST *table)
1836
1861
{
1837
1862
  if (item->type() == Item::FUNC_ITEM)
1838
1863
  {
1839
1864
    Item_func *item_func= (Item_func*)item;
1840
 
    for (uint32_t i=0; i<item_func->argument_count(); i++)
 
1865
    for (uint i=0; i<item_func->argument_count(); i++)
1841
1866
    {
1842
1867
      if (!uses_only_table_name_fields(item_func->arguments()[i], table))
1843
1868
        return 0;
1846
1871
  else if (item->type() == Item::FIELD_ITEM)
1847
1872
  {
1848
1873
    Item_field *item_field= (Item_field*)item;
1849
 
    const CHARSET_INFO * const cs= system_charset_info;
 
1874
    CHARSET_INFO *cs= system_charset_info;
1850
1875
    ST_SCHEMA_TABLE *schema_table= table->schema_table;
1851
1876
    ST_FIELD_INFO *field_info= schema_table->fields_info;
1852
1877
    const char *field_name1= schema_table->idx_field1 >= 0 ?
1854
1879
    const char *field_name2= schema_table->idx_field2 >= 0 ?
1855
1880
      field_info[schema_table->idx_field2].field_name : "";
1856
1881
    if (table->table != item_field->field->table ||
1857
 
        (cs->coll->strnncollsp(cs, (unsigned char *) field_name1, strlen(field_name1),
1858
 
                               (unsigned char *) item_field->field_name,
 
1882
        (cs->coll->strnncollsp(cs, (uchar *) field_name1, strlen(field_name1),
 
1883
                               (uchar *) item_field->field_name,
1859
1884
                               strlen(item_field->field_name), 0) &&
1860
 
         cs->coll->strnncollsp(cs, (unsigned char *) field_name2, strlen(field_name2),
1861
 
                               (unsigned char *) item_field->field_name,
 
1885
         cs->coll->strnncollsp(cs, (uchar *) field_name2, strlen(field_name2),
 
1886
                               (uchar *) item_field->field_name,
1862
1887
                               strlen(item_field->field_name), 0)))
1863
1888
      return 0;
1864
1889
  }
1872
1897
}
1873
1898
 
1874
1899
 
1875
 
static COND * make_cond_for_info_schema(COND *cond, TableList *table)
 
1900
static COND * make_cond_for_info_schema(COND *cond, TABLE_LIST *table)
1876
1901
{
1877
1902
  if (!cond)
1878
1903
    return (COND*) 0;
1946
1971
    1             error, there can be no matching records for the condition
1947
1972
*/
1948
1973
 
1949
 
bool get_lookup_field_values(THD *thd, COND *cond, TableList *tables,
 
1974
bool get_lookup_field_values(THD *thd, COND *cond, TABLE_LIST *tables,
1950
1975
                             LOOKUP_FIELD_VALUES *lookup_field_values)
1951
1976
{
1952
1977
  LEX *lex= thd->lex;
1953
 
  const char *wild= lex->wild ? lex->wild->ptr() : NULL;
1954
 
  memset(lookup_field_values, 0, sizeof(LOOKUP_FIELD_VALUES));
 
1978
  const char *wild= lex->wild ? lex->wild->ptr() : NullS;
 
1979
  bzero((char*) lookup_field_values, sizeof(LOOKUP_FIELD_VALUES));
1955
1980
  switch (lex->sql_command) {
1956
1981
  case SQLCOM_SHOW_DATABASES:
1957
1982
    if (wild)
2013
2038
  LEX_STRING *i_s_name_copy= 0;
2014
2039
  i_s_name_copy= thd->make_lex_string(i_s_name_copy,
2015
2040
                                      INFORMATION_SCHEMA_NAME.str,
2016
 
                                      INFORMATION_SCHEMA_NAME.length, true);
 
2041
                                      INFORMATION_SCHEMA_NAME.length, TRUE);
2017
2042
  *with_i_schema= 0;
2018
2043
  if (lookup_field_vals->wild_db_value)
2019
2044
  {
2031
2056
      if (files->push_back(i_s_name_copy))
2032
2057
        return 1;
2033
2058
    }
2034
 
    return (find_files(thd, files, NULL, mysql_data_home,
 
2059
    return (find_files(thd, files, NullS, mysql_data_home,
2035
2060
                       lookup_field_vals->db_value.str, 1) != FIND_FILES_OK);
2036
2061
  }
2037
2062
 
2062
2087
  if (files->push_back(i_s_name_copy))
2063
2088
    return 1;
2064
2089
  *with_i_schema= 1;
2065
 
  return (find_files(thd, files, NULL,
2066
 
                     mysql_data_home, NULL, 1) != FIND_FILES_OK);
 
2090
  return (find_files(thd, files, NullS,
 
2091
                     mysql_data_home, NullS, 1) != FIND_FILES_OK);
2067
2092
}
2068
2093
 
2069
2094
 
2100
2125
 
2101
2126
  if ((file_name= thd->make_lex_string(file_name, schema_table->table_name,
2102
2127
                                       strlen(schema_table->table_name),
2103
 
                                       true)) &&
 
2128
                                       TRUE)) &&
2104
2129
      !file_list->push_back(file_name))
2105
2130
    return(0);
2106
2131
  return(1);
2131
2156
    }
2132
2157
    if ((file_name= 
2133
2158
         thd->make_lex_string(file_name, tmp_schema_table->table_name,
2134
 
                              strlen(tmp_schema_table->table_name), true)) &&
 
2159
                              strlen(tmp_schema_table->table_name), TRUE)) &&
2135
2160
        !files->push_back(file_name))
2136
2161
      continue;
2137
2162
    return(1);
2140
2165
  add_data.files= files;
2141
2166
  add_data.wild= wild;
2142
2167
  if (plugin_foreach(thd, add_schema_table,
2143
 
                     DRIZZLE_INFORMATION_SCHEMA_PLUGIN, &add_data))
2144
 
    return(1);
 
2168
                     MYSQL_INFORMATION_SCHEMA_PLUGIN, &add_data))
 
2169
      return(1);
2145
2170
 
2146
2171
  return(0);
2147
2172
}
2157
2182
  @param[in]      table_names           List of table names in database
2158
2183
  @param[in]      lex                   pointer to LEX struct
2159
2184
  @param[in]      lookup_field_vals     pointer to LOOKUP_FIELD_VALUE struct
2160
 
  @param[in]      with_i_schema         true means that we add I_S tables to list
 
2185
  @param[in]      with_i_schema         TRUE means that we add I_S tables to list
2161
2186
  @param[in]      db_name               database name
2162
2187
 
2163
2188
  @return         Operation status
2227
2252
  @brief          Fill I_S table for SHOW COLUMNS|INDEX commands
2228
2253
 
2229
2254
  @param[in]      thd                      thread handler
2230
 
  @param[in]      tables                   TableList for I_S table
 
2255
  @param[in]      tables                   TABLE_LIST for I_S table
2231
2256
  @param[in]      schema_table             pointer to I_S structure
2232
2257
  @param[in]      open_tables_state_backup pointer to Open_tables_state object
2233
2258
                                           which is used to save|restore original
2240
2265
*/
2241
2266
 
2242
2267
static int 
2243
 
fill_schema_show_cols_or_idxs(THD *thd, TableList *tables,
 
2268
fill_schema_show_cols_or_idxs(THD *thd, TABLE_LIST *tables,
2244
2269
                              ST_SCHEMA_TABLE *schema_table,
2245
2270
                              Open_tables_state *open_tables_state_backup)
2246
2271
{
2248
2273
  bool res;
2249
2274
  LEX_STRING tmp_lex_string, tmp_lex_string1, *db_name, *table_name;
2250
2275
  enum_sql_command save_sql_command= lex->sql_command;
2251
 
  TableList *show_table_list= (TableList*) tables->schema_select_lex->
 
2276
  TABLE_LIST *show_table_list= (TABLE_LIST*) tables->schema_select_lex->
2252
2277
    table_list.first;
2253
 
  Table *table= tables->table;
 
2278
  TABLE *table= tables->table;
2254
2279
  int error= 1;
2255
2280
 
2256
2281
  lex->all_selects_list= tables->schema_select_lex;
2269
2294
  */
2270
2295
  lex->sql_command= SQLCOM_SHOW_FIELDS;
2271
2296
  res= open_normal_and_derived_tables(thd, show_table_list,
2272
 
                                      DRIZZLE_LOCK_IGNORE_FLUSH);
 
2297
                                      MYSQL_LOCK_IGNORE_FLUSH);
2273
2298
  lex->sql_command= save_sql_command;
2274
2299
  /*
2275
2300
    get_all_tables() returns 1 on failure and 0 on success thus
2283
2308
    'show columns' & 'show statistics' commands).
2284
2309
  */
2285
2310
   table_name= thd->make_lex_string(&tmp_lex_string1, show_table_list->alias,
2286
 
                                    strlen(show_table_list->alias), false);
 
2311
                                    strlen(show_table_list->alias), FALSE);
2287
2312
   db_name= thd->make_lex_string(&tmp_lex_string, show_table_list->db,
2288
 
                                 show_table_list->db_length, false);
 
2313
                                 show_table_list->db_length, FALSE);
2289
2314
      
2290
2315
 
2291
2316
   error= test(schema_table->process_table(thd, show_table_list,
2298
2323
 
2299
2324
 
2300
2325
/**
2301
 
  @brief          Fill I_S table for SHOW Table NAMES commands
 
2326
  @brief          Fill I_S table for SHOW TABLE NAMES commands
2302
2327
 
2303
2328
  @param[in]      thd                      thread handler
2304
 
  @param[in]      table                    Table struct for I_S table
 
2329
  @param[in]      table                    TABLE struct for I_S table
2305
2330
  @param[in]      db_name                  database name
2306
2331
  @param[in]      table_name               table name
2307
 
  @param[in]      with_i_schema            I_S table if true
 
2332
  @param[in]      with_i_schema            I_S table if TRUE
2308
2333
 
2309
2334
  @return         Operation status
2310
2335
    @retval       0           success
2311
2336
    @retval       1           error
2312
2337
*/
2313
2338
 
2314
 
static int fill_schema_table_names(THD *thd, Table *table,
 
2339
static int fill_schema_table_names(THD *thd, TABLE *table,
2315
2340
                                   LEX_STRING *db_name, LEX_STRING *table_name,
2316
2341
                                   bool with_i_schema)
2317
2342
{
2326
2351
    char path[FN_REFLEN];
2327
2352
    (void) build_table_filename(path, sizeof(path), db_name->str, 
2328
2353
                                table_name->str, reg_ext, 0);
2329
 
    if (mysql_frm_type(thd, path, &not_used)) 
2330
 
    {
2331
 
      table->field[3]->store(STRING_WITH_LEN("BASE Table"),
2332
 
                             system_charset_info);
2333
 
    }
2334
 
    else
2335
 
    {
 
2354
    switch (mysql_frm_type(thd, path, &not_used)) {
 
2355
    case FRMTYPE_ERROR:
2336
2356
      table->field[3]->store(STRING_WITH_LEN("ERROR"),
2337
2357
                             system_charset_info);
 
2358
      break;
 
2359
    case FRMTYPE_TABLE:
 
2360
      table->field[3]->store(STRING_WITH_LEN("BASE TABLE"),
 
2361
                             system_charset_info);
 
2362
      break;
 
2363
    default:
 
2364
      assert(0);
2338
2365
    }
2339
 
 
2340
2366
    if (thd->is_error() && thd->main_da.sql_errno() == ER_NO_SUCH_TABLE)
2341
2367
    {
2342
2368
      thd->clear_error();
2365
2391
    @retval       SKIP_OPEN_TABLE | OPEN_FRM_ONLY | OPEN_FULL_TABLE
2366
2392
*/
2367
2393
 
2368
 
static uint32_t get_table_open_method(TableList *tables,
 
2394
static uint get_table_open_method(TABLE_LIST *tables,
2369
2395
                                  ST_SCHEMA_TABLE *schema_table,
2370
 
                                  enum enum_schema_tables schema_table_idx __attribute__((unused)))
 
2396
                                  enum enum_schema_tables schema_table_idx __attribute__((__unused__)))
2371
2397
{
2372
2398
  /*
2373
2399
    determine which method will be used for table opening
2393
2419
  @brief          Fill I_S table with data from FRM file only
2394
2420
 
2395
2421
  @param[in]      thd                      thread handler
2396
 
  @param[in]      table                    Table struct for I_S table
 
2422
  @param[in]      table                    TABLE struct for I_S table
2397
2423
  @param[in]      schema_table             I_S table struct
2398
2424
  @param[in]      db_name                  database name
2399
2425
  @param[in]      table_name               table name
2406
2432
                              open_tables function for this table
2407
2433
*/
2408
2434
 
2409
 
static int fill_schema_table_from_frm(THD *thd,TableList *tables,
 
2435
static int fill_schema_table_from_frm(THD *thd,TABLE_LIST *tables,
2410
2436
                                      ST_SCHEMA_TABLE *schema_table,
2411
2437
                                      LEX_STRING *db_name,
2412
2438
                                      LEX_STRING *table_name,
2413
 
                                      enum enum_schema_tables schema_table_idx __attribute__((unused)))
 
2439
                                      enum enum_schema_tables schema_table_idx __attribute__((__unused__)))
2414
2440
{
2415
 
  Table *table= tables->table;
 
2441
  TABLE *table= tables->table;
2416
2442
  TABLE_SHARE *share;
2417
 
  Table tbl;
2418
 
  TableList table_list;
2419
 
  uint32_t res= 0;
 
2443
  TABLE tbl;
 
2444
  TABLE_LIST table_list;
 
2445
  uint res= 0;
2420
2446
  int error;
2421
2447
  char key[MAX_DBKEY_LENGTH];
2422
 
  uint32_t key_length;
 
2448
  uint key_length;
2423
2449
 
2424
 
  memset(&table_list, 0, sizeof(TableList));
2425
 
  memset(&tbl, 0, sizeof(Table));
 
2450
  bzero((char*) &table_list, sizeof(TABLE_LIST));
 
2451
  bzero((char*) &tbl, sizeof(TABLE));
2426
2452
 
2427
2453
  table_list.table_name= table_name->str;
2428
2454
  table_list.db= db_name->str;
2430
2456
  key_length= create_table_def_key(thd, key, &table_list, 0);
2431
2457
  pthread_mutex_lock(&LOCK_open);
2432
2458
  share= get_table_share(thd, &table_list, key,
2433
 
                         key_length, 0, &error);
 
2459
                         key_length, OPEN_VIEW, &error);
2434
2460
  if (!share)
2435
2461
  {
2436
2462
    res= 0;
2473
2499
    @retval       1                        error
2474
2500
*/
2475
2501
 
2476
 
int get_all_tables(THD *thd, TableList *tables, COND *cond)
 
2502
int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
2477
2503
{
2478
2504
  LEX *lex= thd->lex;
2479
 
  Table *table= tables->table;
 
2505
  TABLE *table= tables->table;
2480
2506
  SELECT_LEX *old_all_select_lex= lex->all_selects_list;
2481
2507
  enum_sql_command save_sql_command= lex->sql_command;
2482
2508
  SELECT_LEX *lsel= tables->schema_select_lex;
2489
2515
  List<LEX_STRING> db_names;
2490
2516
  List_iterator_fast<LEX_STRING> it(db_names);
2491
2517
  COND *partial_cond= 0;
2492
 
  uint32_t derived_tables= lex->derived_tables; 
 
2518
  uint derived_tables= lex->derived_tables; 
2493
2519
  int error= 1;
2494
2520
  Open_tables_state open_tables_state_backup;
2495
2521
  Query_tables_list query_tables_list_backup;
2496
 
  uint32_t table_open_method;
 
2522
  uint table_open_method;
2497
2523
  bool old_value= thd->no_warnings_for_error;
2498
2524
 
2499
2525
  lex->reset_n_backup_query_tables_list(&query_tables_list_backup);
2542
2568
 
2543
2569
  if (lookup_field_vals.db_value.length &&
2544
2570
      !lookup_field_vals.wild_db_value)
2545
 
    tables->has_db_lookup_value= true;
 
2571
    tables->has_db_lookup_value= TRUE;
2546
2572
  if (lookup_field_vals.table_value.length &&
2547
2573
      !lookup_field_vals.wild_table_value) 
2548
 
    tables->has_table_lookup_value= true;
 
2574
    tables->has_table_lookup_value= TRUE;
2549
2575
 
2550
2576
  if (tables->has_db_lookup_value && tables->has_table_lookup_value)
2551
2577
    partial_cond= 0;
2601
2627
            continue;
2602
2628
          }
2603
2629
 
2604
 
          /* SHOW Table NAMES command */
 
2630
          /* SHOW TABLE NAMES command */
2605
2631
          if (schema_table_idx == SCH_TABLE_NAMES)
2606
2632
          {
2607
2633
            if (fill_schema_table_names(thd, tables->table, db_name,
2628
2654
            sel.parent_lex= lex;
2629
2655
            /* db_name can be changed in make_table_list() func */
2630
2656
            if (!thd->make_lex_string(&orig_db_name, db_name->str,
2631
 
                                      db_name->length, false))
 
2657
                                      db_name->length, FALSE))
2632
2658
              goto err;
2633
2659
            if (make_table_list(thd, &sel, db_name, table_name))
2634
2660
              goto err;
2635
 
            TableList *show_table_list= (TableList*) sel.table_list.first;
 
2661
            TABLE_LIST *show_table_list= (TABLE_LIST*) sel.table_list.first;
2636
2662
            lex->all_selects_list= &sel;
2637
2663
            lex->derived_tables= 0;
2638
2664
            lex->sql_command= SQLCOM_SHOW_FIELDS;
2639
2665
            show_table_list->i_s_requested_object=
2640
2666
              schema_table->i_s_requested_object;
2641
2667
            res= open_normal_and_derived_tables(thd, show_table_list,
2642
 
                                                DRIZZLE_LOCK_IGNORE_FLUSH);
 
2668
                                                MYSQL_LOCK_IGNORE_FLUSH);
2643
2669
            lex->sql_command= save_sql_command;
2644
2670
            /*
2645
2671
              XXX:  show_table_list has a flag i_is_requested,
2671
2697
                in this case.
2672
2698
              */
2673
2699
              thd->make_lex_string(&tmp_lex_string, show_table_list->alias,
2674
 
                                   strlen(show_table_list->alias), false);
 
2700
                                   strlen(show_table_list->alias), FALSE);
2675
2701
              res= schema_table->process_table(thd, show_table_list, table,
2676
2702
                                               res, &orig_db_name,
2677
2703
                                               &tmp_lex_string);
2703
2729
}
2704
2730
 
2705
2731
 
2706
 
bool store_schema_shemata(THD* thd, Table *table, LEX_STRING *db_name,
2707
 
                          const CHARSET_INFO * const cs)
 
2732
bool store_schema_shemata(THD* thd, TABLE *table, LEX_STRING *db_name,
 
2733
                          CHARSET_INFO *cs)
2708
2734
{
2709
2735
  restore_record(table, s->default_values);
2710
2736
  table->field[1]->store(db_name->str, db_name->length, system_charset_info);
2714
2740
}
2715
2741
 
2716
2742
 
2717
 
int fill_schema_schemata(THD *thd, TableList *tables, COND *cond)
 
2743
int fill_schema_schemata(THD *thd, TABLE_LIST *tables, COND *cond)
2718
2744
{
2719
2745
  /*
2720
2746
    TODO: fill_schema_shemata() is called when new client is connected.
2726
2752
  LEX_STRING *db_name;
2727
2753
  bool with_i_schema;
2728
2754
  HA_CREATE_INFO create;
2729
 
  Table *table= tables->table;
 
2755
  TABLE *table= tables->table;
2730
2756
 
2731
2757
  if (get_lookup_field_values(thd, cond, tables, &lookup_field_vals))
2732
2758
    return(0);
2741
2767
     !with_i_schema)
2742
2768
  {
2743
2769
    char path[FN_REFLEN+16];
2744
 
    uint32_t path_len;
 
2770
    uint path_len;
2745
2771
    struct stat stat_info;
2746
2772
    if (!lookup_field_vals.db_value.str[0])
2747
2773
      return(0);
2774
2800
}
2775
2801
 
2776
2802
 
2777
 
static int get_schema_tables_record(THD *thd, TableList *tables,
2778
 
                                    Table *table, bool res,
 
2803
static int get_schema_tables_record(THD *thd, TABLE_LIST *tables,
 
2804
                                    TABLE *table, bool res,
2779
2805
                                    LEX_STRING *db_name,
2780
2806
                                    LEX_STRING *table_name)
2781
2807
{
2782
2808
  const char *tmp_buff;
2783
 
  DRIZZLE_TIME time;
2784
 
  const CHARSET_INFO * const cs= system_charset_info;
 
2809
  MYSQL_TIME time;
 
2810
  CHARSET_INFO *cs= system_charset_info;
2785
2811
 
2786
2812
  restore_record(table, s->default_values);
2787
2813
  table->field[1]->store(db_name->str, db_name->length, cs);
2795
2821
    if (tables->schema_table)
2796
2822
      table->field[3]->store(STRING_WITH_LEN("SYSTEM VIEW"), cs);
2797
2823
    else
2798
 
      table->field[3]->store(STRING_WITH_LEN("BASE Table"), cs);
 
2824
      table->field[3]->store(STRING_WITH_LEN("BASE TABLE"), cs);
2799
2825
    table->field[20]->store(error, strlen(error), cs);
2800
2826
    thd->clear_error();
2801
2827
  }
2802
2828
  else
2803
2829
  {
2804
 
    char option_buff[400],*ptr;
2805
 
    Table *show_table= tables->table;
 
2830
    char option_buff[350],*ptr;
 
2831
    TABLE *show_table= tables->table;
2806
2832
    TABLE_SHARE *share= show_table->s;
2807
2833
    handler *file= show_table->file;
2808
2834
    handlerton *tmp_db_type= share->db_type();
2811
2837
    else if (share->tmp_table)
2812
2838
      table->field[3]->store(STRING_WITH_LEN("LOCAL TEMPORARY"), cs);
2813
2839
    else
2814
 
      table->field[3]->store(STRING_WITH_LEN("BASE Table"), cs);
 
2840
      table->field[3]->store(STRING_WITH_LEN("BASE TABLE"), cs);
2815
2841
 
2816
2842
    for (int i= 4; i < 20; i++)
2817
2843
    {
2821
2847
    }
2822
2848
    tmp_buff= (char *) ha_resolve_storage_engine_name(tmp_db_type);
2823
2849
    table->field[4]->store(tmp_buff, strlen(tmp_buff), cs);
2824
 
    table->field[5]->store((int64_t) share->frm_version, true);
 
2850
    table->field[5]->store((int64_t) share->frm_version, TRUE);
2825
2851
 
2826
2852
    ptr=option_buff;
2827
2853
    if (share->min_rows)
2828
2854
    {
2829
 
      ptr=my_stpcpy(ptr," min_rows=");
 
2855
      ptr=strmov(ptr," min_rows=");
2830
2856
      ptr=int64_t10_to_str(share->min_rows,ptr,10);
2831
2857
    }
2832
2858
    if (share->max_rows)
2833
2859
    {
2834
 
      ptr=my_stpcpy(ptr," max_rows=");
 
2860
      ptr=strmov(ptr," max_rows=");
2835
2861
      ptr=int64_t10_to_str(share->max_rows,ptr,10);
2836
2862
    }
2837
2863
    if (share->avg_row_length)
2838
2864
    {
2839
 
      ptr=my_stpcpy(ptr," avg_row_length=");
 
2865
      ptr=strmov(ptr," avg_row_length=");
2840
2866
      ptr=int64_t10_to_str(share->avg_row_length,ptr,10);
2841
2867
    }
2842
2868
    if (share->db_create_options & HA_OPTION_PACK_KEYS)
2843
 
      ptr=my_stpcpy(ptr," pack_keys=1");
 
2869
      ptr=strmov(ptr," pack_keys=1");
2844
2870
    if (share->db_create_options & HA_OPTION_NO_PACK_KEYS)
2845
 
      ptr=my_stpcpy(ptr," pack_keys=0");
 
2871
      ptr=strmov(ptr," pack_keys=0");
2846
2872
    /* We use CHECKSUM, instead of TABLE_CHECKSUM, for backward compability */
2847
2873
    if (share->db_create_options & HA_OPTION_CHECKSUM)
2848
 
      ptr=my_stpcpy(ptr," checksum=1");
 
2874
      ptr=strmov(ptr," checksum=1");
2849
2875
    if (share->page_checksum != HA_CHOICE_UNDEF)
2850
2876
      ptr= strxmov(ptr, " page_checksum=",
2851
 
                   ha_choice_values[(uint) share->page_checksum], NULL);
 
2877
                   ha_choice_values[(uint) share->page_checksum], NullS);
2852
2878
    if (share->db_create_options & HA_OPTION_DELAY_KEY_WRITE)
2853
 
      ptr=my_stpcpy(ptr," delay_key_write=1");
 
2879
      ptr=strmov(ptr," delay_key_write=1");
2854
2880
    if (share->row_type != ROW_TYPE_DEFAULT)
2855
2881
      ptr=strxmov(ptr, " row_format=", 
2856
2882
                  ha_row_type[(uint) share->row_type],
2857
 
                  NULL);
2858
 
    if (share->block_size)
2859
 
    {
2860
 
      ptr= my_stpcpy(ptr, " block_size=");
2861
 
      ptr= int64_t10_to_str(share->block_size, ptr, 10);
2862
 
    }
2863
 
    
 
2883
                  NullS);
2864
2884
    if (share->transactional != HA_CHOICE_UNDEF)
2865
2885
    {
2866
2886
      ptr= strxmov(ptr, " TRANSACTIONAL=",
2867
2887
                   (share->transactional == HA_CHOICE_YES ? "1" : "0"),
2868
 
                   NULL);
 
2888
                   NullS);
2869
2889
    }
2870
2890
    if (share->transactional != HA_CHOICE_UNDEF)
2871
2891
      ptr= strxmov(ptr, " transactional=",
2872
 
                   ha_choice_values[(uint) share->transactional], NULL);
 
2892
                   ha_choice_values[(uint) share->transactional], NullS);
2873
2893
    table->field[19]->store(option_buff+1,
2874
2894
                            (ptr == option_buff ? 0 : 
2875
2895
                             (uint) (ptr-option_buff)-1), cs);
2916
2936
      table->field[6]->store(tmp_buff, strlen(tmp_buff), cs);
2917
2937
      if (!tables->schema_table)
2918
2938
      {
2919
 
        table->field[7]->store((int64_t) file->stats.records, true);
 
2939
        table->field[7]->store((int64_t) file->stats.records, TRUE);
2920
2940
        table->field[7]->set_notnull();
2921
2941
      }
2922
 
      table->field[8]->store((int64_t) file->stats.mean_rec_length, true);
2923
 
      table->field[9]->store((int64_t) file->stats.data_file_length, true);
 
2942
      table->field[8]->store((int64_t) file->stats.mean_rec_length, TRUE);
 
2943
      table->field[9]->store((int64_t) file->stats.data_file_length, TRUE);
2924
2944
      if (file->stats.max_data_file_length)
2925
2945
      {
2926
2946
        table->field[10]->store((int64_t) file->stats.max_data_file_length,
2927
 
                                true);
 
2947
                                TRUE);
2928
2948
      }
2929
 
      table->field[11]->store((int64_t) file->stats.index_file_length, true);
2930
 
      table->field[12]->store((int64_t) file->stats.delete_length, true);
 
2949
      table->field[11]->store((int64_t) file->stats.index_file_length, TRUE);
 
2950
      table->field[12]->store((int64_t) file->stats.delete_length, TRUE);
2931
2951
      if (show_table->found_next_number_field)
2932
2952
      {
2933
2953
        table->field[13]->store((int64_t) file->stats.auto_increment_value,
2934
 
                                true);
 
2954
                                TRUE);
2935
2955
        table->field[13]->set_notnull();
2936
2956
      }
2937
2957
      if (file->stats.create_time)
2938
2958
      {
2939
2959
        thd->variables.time_zone->gmt_sec_to_TIME(&time,
2940
2960
                                                  (my_time_t) file->stats.create_time);
2941
 
        table->field[14]->store_time(&time, DRIZZLE_TIMESTAMP_DATETIME);
 
2961
        table->field[14]->store_time(&time, MYSQL_TIMESTAMP_DATETIME);
2942
2962
        table->field[14]->set_notnull();
2943
2963
      }
2944
2964
      if (file->stats.update_time)
2945
2965
      {
2946
2966
        thd->variables.time_zone->gmt_sec_to_TIME(&time,
2947
2967
                                                  (my_time_t) file->stats.update_time);
2948
 
        table->field[15]->store_time(&time, DRIZZLE_TIMESTAMP_DATETIME);
 
2968
        table->field[15]->store_time(&time, MYSQL_TIMESTAMP_DATETIME);
2949
2969
        table->field[15]->set_notnull();
2950
2970
      }
2951
2971
      if (file->stats.check_time)
2952
2972
      {
2953
2973
        thd->variables.time_zone->gmt_sec_to_TIME(&time,
2954
2974
                                                  (my_time_t) file->stats.check_time);
2955
 
        table->field[16]->store_time(&time, DRIZZLE_TIMESTAMP_DATETIME);
 
2975
        table->field[16]->store_time(&time, MYSQL_TIMESTAMP_DATETIME);
2956
2976
        table->field[16]->set_notnull();
2957
2977
      }
2958
2978
      if (file->ha_table_flags() & (ulong) HA_HAS_CHECKSUM)
2959
2979
      {
2960
 
        table->field[18]->store((int64_t) file->checksum(), true);
 
2980
        table->field[18]->store((int64_t) file->checksum(), TRUE);
2961
2981
        table->field[18]->set_notnull();
2962
2982
      }
2963
2983
    }
2978
2998
  @return         void
2979
2999
*/
2980
3000
 
2981
 
void store_column_type(Table *table, Field *field, const CHARSET_INFO * const cs,
2982
 
                       uint32_t offset)
 
3001
void store_column_type(TABLE *table, Field *field, CHARSET_INFO *cs,
 
3002
                       uint offset)
2983
3003
{
2984
3004
  bool is_blob;
2985
3005
  int decimals, field_length;
2996
3016
  table->field[offset]->store(column_type.ptr(),
2997
3017
                         (tmp_buff ? tmp_buff - column_type.ptr() :
2998
3018
                          column_type.length()), cs);
2999
 
  is_blob= (field->type() == DRIZZLE_TYPE_BLOB);
 
3019
  is_blob= (field->type() == MYSQL_TYPE_BLOB);
3000
3020
  if (field->has_charset() || is_blob ||
3001
 
      field->real_type() == DRIZZLE_TYPE_VARCHAR)  // For varbinary type
 
3021
      field->real_type() == MYSQL_TYPE_VARCHAR ||  // For varbinary type
 
3022
      field->real_type() == MYSQL_TYPE_STRING)     // For binary type
3002
3023
  {
3003
 
    uint32_t octet_max_length= field->max_display_length();
3004
 
    if (is_blob && octet_max_length != (uint32_t) 4294967295U)
 
3024
    uint32 octet_max_length= field->max_display_length();
 
3025
    if (is_blob && octet_max_length != (uint32) 4294967295U)
3005
3026
      octet_max_length /= field->charset()->mbmaxlen;
3006
3027
    int64_t char_max_len= is_blob ? 
3007
3028
      (int64_t) octet_max_length / field->charset()->mbminlen :
3008
3029
      (int64_t) octet_max_length / field->charset()->mbmaxlen;
3009
3030
    /* CHARACTER_MAXIMUM_LENGTH column*/
3010
 
    table->field[offset + 1]->store(char_max_len, true);
 
3031
    table->field[offset + 1]->store(char_max_len, TRUE);
3011
3032
    table->field[offset + 1]->set_notnull();
3012
3033
    /* CHARACTER_OCTET_LENGTH column */
3013
 
    table->field[offset + 2]->store((int64_t) octet_max_length, true);
 
3034
    table->field[offset + 2]->store((int64_t) octet_max_length, TRUE);
3014
3035
    table->field[offset + 2]->set_notnull();
3015
3036
  }
3016
3037
 
3021
3042
 
3022
3043
  decimals= field->decimals();
3023
3044
  switch (field->type()) {
3024
 
  case DRIZZLE_TYPE_NEWDECIMAL:
 
3045
  case MYSQL_TYPE_NEWDECIMAL:
3025
3046
    field_length= ((Field_new_decimal*) field)->precision;
3026
3047
    break;
3027
 
  case DRIZZLE_TYPE_TINY:
3028
 
  case DRIZZLE_TYPE_LONG:
3029
 
  case DRIZZLE_TYPE_LONGLONG:
 
3048
  case MYSQL_TYPE_TINY:
 
3049
  case MYSQL_TYPE_SHORT:
 
3050
  case MYSQL_TYPE_LONG:
 
3051
  case MYSQL_TYPE_LONGLONG:
3030
3052
    field_length= field->max_display_length() - 1;
3031
3053
    break;
3032
 
  case DRIZZLE_TYPE_DOUBLE:
 
3054
  case MYSQL_TYPE_FLOAT:  
 
3055
  case MYSQL_TYPE_DOUBLE:
3033
3056
    field_length= field->field_length;
3034
3057
    if (decimals == NOT_FIXED_DEC)
3035
3058
      decimals= -1;                           // return NULL
3042
3065
  /* NUMERIC_PRECISION column */
3043
3066
  if (field_length >= 0)
3044
3067
  {
3045
 
    table->field[offset + 3]->store((int64_t) field_length, true);
 
3068
    table->field[offset + 3]->store((int64_t) field_length, TRUE);
3046
3069
    table->field[offset + 3]->set_notnull();
3047
3070
  }
3048
3071
  /* NUMERIC_SCALE column */
3049
3072
  if (decimals >= 0)
3050
3073
  {
3051
 
    table->field[offset + 4]->store((int64_t) decimals, true);
 
3074
    table->field[offset + 4]->store((int64_t) decimals, TRUE);
3052
3075
    table->field[offset + 4]->set_notnull();
3053
3076
  }
3054
3077
  if (field->has_charset())
3065
3088
}
3066
3089
 
3067
3090
 
3068
 
static int get_schema_column_record(THD *thd, TableList *tables,
3069
 
                                    Table *table, bool res,
 
3091
static int get_schema_column_record(THD *thd, TABLE_LIST *tables,
 
3092
                                    TABLE *table, bool res,
3070
3093
                                    LEX_STRING *db_name,
3071
3094
                                    LEX_STRING *table_name)
3072
3095
{
3073
3096
  LEX *lex= thd->lex;
3074
 
  const char *wild= lex->wild ? lex->wild->ptr() : NULL;
3075
 
  const CHARSET_INFO * const cs= system_charset_info;
3076
 
  Table *show_table;
 
3097
  const char *wild= lex->wild ? lex->wild->ptr() : NullS;
 
3098
  CHARSET_INFO *cs= system_charset_info;
 
3099
  TABLE *show_table;
3077
3100
  TABLE_SHARE *show_table_share;
3078
3101
  Field **ptr, *field, *timestamp_field;
3079
3102
  int count;
3087
3110
        rather than in SHOW COLUMNS
3088
3111
      */ 
3089
3112
      if (thd->is_error())
3090
 
        push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
3113
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
3091
3114
                     thd->main_da.sql_errno(), thd->main_da.message());
3092
3115
      thd->clear_error();
3093
3116
      res= 0;
3116
3139
    if (!show_table->read_set)
3117
3140
    {
3118
3141
      /* to satisfy 'field->val_str' ASSERTs */
3119
 
      unsigned char *bitmaps;
3120
 
      uint32_t bitmap_size= show_table_share->column_bitmap_size;
3121
 
      if (!(bitmaps= (unsigned char*) alloc_root(thd->mem_root, bitmap_size)))
 
3142
      uchar *bitmaps;
 
3143
      uint bitmap_size= show_table_share->column_bitmap_size;
 
3144
      if (!(bitmaps= (uchar*) alloc_root(thd->mem_root, bitmap_size)))
3122
3145
        return(0);
3123
3146
      bitmap_init(&show_table->def_read_set,
3124
 
                  (my_bitmap_map*) bitmaps, show_table_share->fields, false);
 
3147
                  (my_bitmap_map*) bitmaps, show_table_share->fields, FALSE);
3125
3148
      bitmap_set_all(&show_table->def_read_set);
3126
3149
      show_table->read_set= &show_table->def_read_set;
3127
3150
    }
3130
3153
 
3131
3154
  for (; (field= *ptr) ; ptr++)
3132
3155
  {
3133
 
    unsigned char *pos;
 
3156
    uchar *pos;
3134
3157
    char tmp[MAX_FIELD_WIDTH];
3135
3158
    String type(tmp,sizeof(tmp), system_charset_info);
3136
3159
    char *end;
3151
3174
    table->field[2]->store(table_name->str, table_name->length, cs);
3152
3175
    table->field[3]->store(field->field_name, strlen(field->field_name),
3153
3176
                           cs);
3154
 
    table->field[4]->store((int64_t) count, true);
 
3177
    table->field[4]->store((int64_t) count, TRUE);
3155
3178
 
3156
3179
    if (get_field_default_value(thd, timestamp_field, field, &type, 0))
3157
3180
    {
3158
3181
      table->field[5]->store(type.ptr(), type.length(), cs);
3159
3182
      table->field[5]->set_notnull();
3160
3183
    }
3161
 
    pos=(unsigned char*) ((field->flags & NOT_NULL_FLAG) ?  "NO" : "YES");
 
3184
    pos=(uchar*) ((field->flags & NOT_NULL_FLAG) ?  "NO" : "YES");
3162
3185
    table->field[6]->store((const char*) pos,
3163
3186
                           strlen((const char*) pos), cs);
3164
3187
    store_column_type(table, field, cs, 7);
3165
3188
 
3166
 
    pos=(unsigned char*) ((field->flags & PRI_KEY_FLAG) ? "PRI" :
 
3189
    pos=(uchar*) ((field->flags & PRI_KEY_FLAG) ? "PRI" :
3167
3190
                 (field->flags & UNIQUE_KEY_FLAG) ? "UNI" :
3168
3191
                 (field->flags & MULTIPLE_KEY_FLAG) ? "MUL":"");
3169
3192
    table->field[15]->store((const char*) pos,
3181
3204
    {
3182
3205
      enum column_format_type column_format= (enum column_format_type)
3183
3206
        ((field->flags >> COLUMN_FORMAT_FLAGS) & COLUMN_FORMAT_MASK);
3184
 
      pos=(unsigned char*)"Default";
 
3207
      pos=(uchar*)"Default";
3185
3208
      table->field[19]->store((const char*) pos,
3186
3209
                              strlen((const char*) pos), cs);
3187
 
      pos=(unsigned char*)(column_format == COLUMN_FORMAT_TYPE_DEFAULT ? "Default" :
 
3210
      pos=(uchar*)(column_format == COLUMN_FORMAT_TYPE_DEFAULT ? "Default" :
3188
3211
                   column_format == COLUMN_FORMAT_TYPE_FIXED ? "Fixed" :
3189
3212
                                                             "Dynamic");
3190
3213
      table->field[20]->store((const char*) pos,
3198
3221
 
3199
3222
 
3200
3223
 
3201
 
int fill_schema_charsets(THD *thd, TableList *tables, COND *cond __attribute__((unused)))
 
3224
int fill_schema_charsets(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((__unused__)))
3202
3225
{
3203
3226
  CHARSET_INFO **cs;
3204
 
  const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NULL;
3205
 
  Table *table= tables->table;
3206
 
  const CHARSET_INFO * const scs= system_charset_info;
 
3227
  const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS;
 
3228
  TABLE *table= tables->table;
 
3229
  CHARSET_INFO *scs= system_charset_info;
3207
3230
 
3208
3231
  for (cs= all_charsets ; cs < all_charsets+255 ; cs++)
3209
3232
  {
3210
 
    const CHARSET_INFO * const tmp_cs= cs[0];
 
3233
    CHARSET_INFO *tmp_cs= cs[0];
3211
3234
    if (tmp_cs && (tmp_cs->state & MY_CS_PRIMARY) && 
3212
3235
        (tmp_cs->state & MY_CS_AVAILABLE) &&
3213
3236
        !(tmp_cs->state & MY_CS_HIDDEN) &&
3214
3237
        !(wild && wild[0] &&
3215
 
          wild_case_compare(scs, tmp_cs->csname,wild)))
 
3238
          wild_case_compare(scs, tmp_cs->csname,wild)))
3216
3239
    {
3217
3240
      const char *comment;
3218
3241
      restore_record(table, s->default_values);
3220
3243
      table->field[1]->store(tmp_cs->name, strlen(tmp_cs->name), scs);
3221
3244
      comment= tmp_cs->comment ? tmp_cs->comment : "";
3222
3245
      table->field[2]->store(comment, strlen(comment), scs);
3223
 
      table->field[3]->store((int64_t) tmp_cs->mbmaxlen, true);
 
3246
      table->field[3]->store((int64_t) tmp_cs->mbmaxlen, TRUE);
3224
3247
      if (schema_table_store_record(thd, table))
3225
3248
        return 1;
3226
3249
    }
3229
3252
}
3230
3253
 
3231
3254
 
3232
 
int fill_schema_collation(THD *thd, TableList *tables, COND *cond __attribute__((unused)))
 
3255
int fill_schema_collation(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((__unused__)))
3233
3256
{
3234
3257
  CHARSET_INFO **cs;
3235
 
  const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NULL;
3236
 
  Table *table= tables->table;
3237
 
  const CHARSET_INFO * const scs= system_charset_info;
 
3258
  const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS;
 
3259
  TABLE *table= tables->table;
 
3260
  CHARSET_INFO *scs= system_charset_info;
3238
3261
  for (cs= all_charsets ; cs < all_charsets+255 ; cs++ )
3239
3262
  {
3240
3263
    CHARSET_INFO **cl;
3241
 
    const CHARSET_INFO *tmp_cs= cs[0];
 
3264
    CHARSET_INFO *tmp_cs= cs[0];
3242
3265
    if (!tmp_cs || !(tmp_cs->state & MY_CS_AVAILABLE) ||
3243
3266
         (tmp_cs->state & MY_CS_HIDDEN) ||
3244
3267
        !(tmp_cs->state & MY_CS_PRIMARY))
3245
3268
      continue;
3246
3269
    for (cl= all_charsets; cl < all_charsets+255 ;cl ++)
3247
3270
    {
3248
 
      const CHARSET_INFO *tmp_cl= cl[0];
 
3271
      CHARSET_INFO *tmp_cl= cl[0];
3249
3272
      if (!tmp_cl || !(tmp_cl->state & MY_CS_AVAILABLE) || 
3250
3273
          !my_charset_same(tmp_cs, tmp_cl))
3251
 
        continue;
 
3274
        continue;
3252
3275
      if (!(wild && wild[0] &&
3253
 
          wild_case_compare(scs, tmp_cl->name,wild)))
 
3276
          wild_case_compare(scs, tmp_cl->name,wild)))
3254
3277
      {
3255
 
        const char *tmp_buff;
3256
 
        restore_record(table, s->default_values);
3257
 
        table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs);
 
3278
        const char *tmp_buff;
 
3279
        restore_record(table, s->default_values);
 
3280
        table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs);
3258
3281
        table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs);
3259
 
        table->field[2]->store((int64_t) tmp_cl->number, true);
 
3282
        table->field[2]->store((int64_t) tmp_cl->number, TRUE);
3260
3283
        tmp_buff= (tmp_cl->state & MY_CS_PRIMARY) ? "Yes" : "";
3261
 
        table->field[3]->store(tmp_buff, strlen(tmp_buff), scs);
 
3284
        table->field[3]->store(tmp_buff, strlen(tmp_buff), scs);
3262
3285
        tmp_buff= (tmp_cl->state & MY_CS_COMPILED)? "Yes" : "";
3263
 
        table->field[4]->store(tmp_buff, strlen(tmp_buff), scs);
3264
 
        table->field[5]->store((int64_t) tmp_cl->strxfrm_multiply, true);
 
3286
        table->field[4]->store(tmp_buff, strlen(tmp_buff), scs);
 
3287
        table->field[5]->store((int64_t) tmp_cl->strxfrm_multiply, TRUE);
3265
3288
        if (schema_table_store_record(thd, table))
3266
3289
          return 1;
3267
3290
      }
3271
3294
}
3272
3295
 
3273
3296
 
3274
 
int fill_schema_coll_charset_app(THD *thd, TableList *tables, COND *cond __attribute__((unused)))
 
3297
int fill_schema_coll_charset_app(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((__unused__)))
3275
3298
{
3276
3299
  CHARSET_INFO **cs;
3277
 
  Table *table= tables->table;
3278
 
  const CHARSET_INFO * const scs= system_charset_info;
 
3300
  TABLE *table= tables->table;
 
3301
  CHARSET_INFO *scs= system_charset_info;
3279
3302
  for (cs= all_charsets ; cs < all_charsets+255 ; cs++ )
3280
3303
  {
3281
3304
    CHARSET_INFO **cl;
3282
 
    const CHARSET_INFO *tmp_cs= cs[0];
 
3305
    CHARSET_INFO *tmp_cs= cs[0];
3283
3306
    if (!tmp_cs || !(tmp_cs->state & MY_CS_AVAILABLE) || 
3284
3307
        !(tmp_cs->state & MY_CS_PRIMARY))
3285
3308
      continue;
3286
3309
    for (cl= all_charsets; cl < all_charsets+255 ;cl ++)
3287
3310
    {
3288
 
      const CHARSET_INFO *tmp_cl= cl[0];
 
3311
      CHARSET_INFO *tmp_cl= cl[0];
3289
3312
      if (!tmp_cl || !(tmp_cl->state & MY_CS_AVAILABLE) || 
3290
3313
          !my_charset_same(tmp_cs,tmp_cl))
3291
3314
        continue;
3300
3323
}
3301
3324
 
3302
3325
 
3303
 
static int get_schema_stat_record(THD *thd, TableList *tables,
3304
 
                                  Table *table, bool res,
 
3326
static int get_schema_stat_record(THD *thd, TABLE_LIST *tables,
 
3327
                                  TABLE *table, bool res,
3305
3328
                                  LEX_STRING *db_name,
3306
3329
                                  LEX_STRING *table_name)
3307
3330
{
3308
 
  const CHARSET_INFO * const cs= system_charset_info;
 
3331
  CHARSET_INFO *cs= system_charset_info;
3309
3332
  if (res)
3310
3333
  {
3311
3334
    if (thd->lex->sql_command != SQLCOM_SHOW_KEYS)
3315
3338
        rather than in SHOW KEYS
3316
3339
      */
3317
3340
      if (thd->is_error())
3318
 
        push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
3341
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
3319
3342
                     thd->main_da.sql_errno(), thd->main_da.message());
3320
3343
      thd->clear_error();
3321
3344
      res= 0;
3324
3347
  }
3325
3348
  else
3326
3349
  {
3327
 
    Table *show_table= tables->table;
 
3350
    TABLE *show_table= tables->table;
3328
3351
    KEY *key_info=show_table->s->key_info;
3329
3352
    if (show_table->file)
3330
3353
      show_table->file->info(HA_STATUS_VARIABLE |
3331
3354
                             HA_STATUS_NO_LOCK |
3332
3355
                             HA_STATUS_TIME);
3333
 
    for (uint32_t i=0 ; i < show_table->s->keys ; i++,key_info++)
 
3356
    for (uint i=0 ; i < show_table->s->keys ; i++,key_info++)
3334
3357
    {
3335
3358
      KEY_PART_INFO *key_part= key_info->key_part;
3336
3359
      const char *str;
3337
 
      for (uint32_t j=0 ; j < key_info->key_parts ; j++,key_part++)
 
3360
      for (uint j=0 ; j < key_info->key_parts ; j++,key_part++)
3338
3361
      {
3339
3362
        restore_record(table, s->default_values);
3340
3363
        table->field[1]->store(db_name->str, db_name->length, cs);
3341
3364
        table->field[2]->store(table_name->str, table_name->length, cs);
3342
3365
        table->field[3]->store((int64_t) ((key_info->flags &
3343
 
                                            HA_NOSAME) ? 0 : 1), true);
 
3366
                                            HA_NOSAME) ? 0 : 1), TRUE);
3344
3367
        table->field[4]->store(db_name->str, db_name->length, cs);
3345
3368
        table->field[5]->store(key_info->name, strlen(key_info->name), cs);
3346
 
        table->field[6]->store((int64_t) (j+1), true);
 
3369
        table->field[6]->store((int64_t) (j+1), TRUE);
3347
3370
        str=(key_part->field ? key_part->field->field_name :
3348
3371
             "?unknown field?");
3349
3372
        table->field[7]->store(str, strlen(str), cs);
3361
3384
          {
3362
3385
            ha_rows records=(show_table->file->stats.records /
3363
3386
                             key->rec_per_key[j]);
3364
 
            table->field[9]->store((int64_t) records, true);
 
3387
            table->field[9]->store((int64_t) records, TRUE);
3365
3388
            table->field[9]->set_notnull();
3366
3389
          }
3367
3390
          str= show_table->file->index_type(i);
3372
3395
             show_table->s->field[key_part->fieldnr-1]->key_length()))
3373
3396
        {
3374
3397
          table->field[10]->store((int64_t) key_part->length /
3375
 
                                  key_part->field->charset()->mbmaxlen, true);
 
3398
                                  key_part->field->charset()->mbmaxlen, TRUE);
3376
3399
          table->field[10]->set_notnull();
3377
3400
        }
3378
 
        uint32_t flags= key_part->field ? key_part->field->flags : 0;
 
3401
        uint flags= key_part->field ? key_part->field->flags : 0;
3379
3402
        const char *pos=(char*) ((flags & NOT_NULL_FLAG) ? "" : "YES");
3380
3403
        table->field[12]->store(pos, strlen(pos), cs);
3381
3404
        if (!show_table->s->keys_in_use.is_set(i))
3397
3420
}
3398
3421
 
3399
3422
 
3400
 
bool store_constraints(THD *thd, Table *table, LEX_STRING *db_name,
 
3423
bool store_constraints(THD *thd, TABLE *table, LEX_STRING *db_name,
3401
3424
                       LEX_STRING *table_name, const char *key_name,
3402
 
                       uint32_t key_len, const char *con_type, uint32_t con_len)
 
3425
                       uint key_len, const char *con_type, uint con_len)
3403
3426
{
3404
 
  const CHARSET_INFO * const cs= system_charset_info;
 
3427
  CHARSET_INFO *cs= system_charset_info;
3405
3428
  restore_record(table, s->default_values);
3406
3429
  table->field[1]->store(db_name->str, db_name->length, cs);
3407
3430
  table->field[2]->store(key_name, key_len, cs);
3412
3435
}
3413
3436
 
3414
3437
 
3415
 
static int get_schema_constraints_record(THD *thd, TableList *tables,
3416
 
                                         Table *table, bool res,
 
3438
static int get_schema_constraints_record(THD *thd, TABLE_LIST *tables,
 
3439
                                         TABLE *table, bool res,
3417
3440
                                         LEX_STRING *db_name,
3418
3441
                                         LEX_STRING *table_name)
3419
3442
{
3420
3443
  if (res)
3421
3444
  {
3422
3445
    if (thd->is_error())
3423
 
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
3446
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
3424
3447
                   thd->main_da.sql_errno(), thd->main_da.message());
3425
3448
    thd->clear_error();
3426
3449
    return(0);
3428
3451
  else
3429
3452
  {
3430
3453
    List<FOREIGN_KEY_INFO> f_key_list;
3431
 
    Table *show_table= tables->table;
 
3454
    TABLE *show_table= tables->table;
3432
3455
    KEY *key_info=show_table->key_info;
3433
 
    uint32_t primary_key= show_table->s->primary_key;
 
3456
    uint primary_key= show_table->s->primary_key;
3434
3457
    show_table->file->info(HA_STATUS_VARIABLE | 
3435
3458
                           HA_STATUS_NO_LOCK |
3436
3459
                           HA_STATUS_TIME);
3437
 
    for (uint32_t i=0 ; i < show_table->s->keys ; i++, key_info++)
 
3460
    for (uint i=0 ; i < show_table->s->keys ; i++, key_info++)
3438
3461
    {
3439
3462
      if (i != primary_key && !(key_info->flags & HA_NOSAME))
3440
3463
        continue;
3471
3494
}
3472
3495
 
3473
3496
 
3474
 
void store_key_column_usage(Table *table, LEX_STRING *db_name,
 
3497
void store_key_column_usage(TABLE *table, LEX_STRING *db_name,
3475
3498
                            LEX_STRING *table_name, const char *key_name,
3476
 
                            uint32_t key_len, const char *con_type, uint32_t con_len,
 
3499
                            uint key_len, const char *con_type, uint con_len,
3477
3500
                            int64_t idx)
3478
3501
{
3479
 
  const CHARSET_INFO * const cs= system_charset_info;
 
3502
  CHARSET_INFO *cs= system_charset_info;
3480
3503
  table->field[1]->store(db_name->str, db_name->length, cs);
3481
3504
  table->field[2]->store(key_name, key_len, cs);
3482
3505
  table->field[4]->store(db_name->str, db_name->length, cs);
3483
3506
  table->field[5]->store(table_name->str, table_name->length, cs);
3484
3507
  table->field[6]->store(con_type, con_len, cs);
3485
 
  table->field[7]->store((int64_t) idx, true);
 
3508
  table->field[7]->store((int64_t) idx, TRUE);
3486
3509
}
3487
3510
 
3488
3511
 
3489
3512
static int get_schema_key_column_usage_record(THD *thd,
3490
 
                                              TableList *tables,
3491
 
                                              Table *table, bool res,
 
3513
                                              TABLE_LIST *tables,
 
3514
                                              TABLE *table, bool res,
3492
3515
                                              LEX_STRING *db_name,
3493
3516
                                              LEX_STRING *table_name)
3494
3517
{
3495
3518
  if (res)
3496
3519
  {
3497
3520
    if (thd->is_error())
3498
 
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
3521
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
3499
3522
                   thd->main_da.sql_errno(), thd->main_da.message());
3500
3523
    thd->clear_error();
3501
3524
    return(0);
3503
3526
  else
3504
3527
  {
3505
3528
    List<FOREIGN_KEY_INFO> f_key_list;
3506
 
    Table *show_table= tables->table;
 
3529
    TABLE *show_table= tables->table;
3507
3530
    KEY *key_info=show_table->key_info;
3508
 
    uint32_t primary_key= show_table->s->primary_key;
 
3531
    uint primary_key= show_table->s->primary_key;
3509
3532
    show_table->file->info(HA_STATUS_VARIABLE | 
3510
3533
                           HA_STATUS_NO_LOCK |
3511
3534
                           HA_STATUS_TIME);
3512
 
    for (uint32_t i=0 ; i < show_table->s->keys ; i++, key_info++)
 
3535
    for (uint i=0 ; i < show_table->s->keys ; i++, key_info++)
3513
3536
    {
3514
3537
      if (i != primary_key && !(key_info->flags & HA_NOSAME))
3515
3538
        continue;
3516
 
      uint32_t f_idx= 0;
 
3539
      uint f_idx= 0;
3517
3540
      KEY_PART_INFO *key_part= key_info->key_part;
3518
 
      for (uint32_t j=0 ; j < key_info->key_parts ; j++,key_part++)
 
3541
      for (uint j=0 ; j < key_info->key_parts ; j++,key_part++)
3519
3542
      {
3520
3543
        if (key_part->field)
3521
3544
        {
3542
3565
      LEX_STRING *r_info;
3543
3566
      List_iterator_fast<LEX_STRING> it(f_key_info->foreign_fields),
3544
3567
        it1(f_key_info->referenced_fields);
3545
 
      uint32_t f_idx= 0;
 
3568
      uint f_idx= 0;
3546
3569
      while ((f_info= it++))
3547
3570
      {
3548
3571
        r_info= it1++;
3553
3576
                               f_key_info->forein_id->length,
3554
3577
                               f_info->str, f_info->length,
3555
3578
                               (int64_t) f_idx);
3556
 
        table->field[8]->store((int64_t) f_idx, true);
 
3579
        table->field[8]->store((int64_t) f_idx, TRUE);
3557
3580
        table->field[8]->set_notnull();
3558
3581
        table->field[9]->store(f_key_info->referenced_db->str,
3559
3582
                               f_key_info->referenced_db->length,
3575
3598
}
3576
3599
 
3577
3600
 
3578
 
int fill_open_tables(THD *thd, TableList *tables, COND *cond __attribute__((unused)))
 
3601
int fill_open_tables(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((__unused__)))
3579
3602
{
3580
 
  const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NULL;
3581
 
  Table *table= tables->table;
3582
 
  const CHARSET_INFO * const cs= system_charset_info;
3583
 
  OPEN_TableList *open_list;
 
3603
  const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS;
 
3604
  TABLE *table= tables->table;
 
3605
  CHARSET_INFO *cs= system_charset_info;
 
3606
  OPEN_TABLE_LIST *open_list;
3584
3607
  if (!(open_list=list_open_tables(thd,thd->lex->select_lex.db, wild))
3585
3608
            && thd->is_fatal_error)
3586
3609
    return(1);
3590
3613
    restore_record(table, s->default_values);
3591
3614
    table->field[0]->store(open_list->db, strlen(open_list->db), cs);
3592
3615
    table->field[1]->store(open_list->table, strlen(open_list->table), cs);
3593
 
    table->field[2]->store((int64_t) open_list->in_use, true);
3594
 
    table->field[3]->store((int64_t) open_list->locked, true);
 
3616
    table->field[2]->store((int64_t) open_list->in_use, TRUE);
 
3617
    table->field[3]->store((int64_t) open_list->locked, TRUE);
3595
3618
    if (schema_table_store_record(thd, table))
3596
3619
      return(1);
3597
3620
  }
3599
3622
}
3600
3623
 
3601
3624
 
3602
 
int fill_variables(THD *thd, TableList *tables, COND *cond __attribute__((unused)))
 
3625
int fill_variables(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((__unused__)))
3603
3626
{
3604
3627
  int res= 0;
3605
3628
  LEX *lex= thd->lex;
3606
 
  const char *wild= lex->wild ? lex->wild->ptr() : NULL;
 
3629
  const char *wild= lex->wild ? lex->wild->ptr() : NullS;
3607
3630
  enum enum_schema_tables schema_table_idx=
3608
3631
    get_schema_table_idx(tables->schema_table);
3609
3632
  enum enum_var_type option_type= OPT_SESSION;
3622
3645
}
3623
3646
 
3624
3647
 
3625
 
int fill_status(THD *thd, TableList *tables, COND *cond __attribute__((unused)))
 
3648
int fill_status(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((__unused__)))
3626
3649
{
3627
3650
  LEX *lex= thd->lex;
3628
 
  const char *wild= lex->wild ? lex->wild->ptr() : NULL;
 
3651
  const char *wild= lex->wild ? lex->wild->ptr() : NullS;
3629
3652
  int res= 0;
3630
3653
  STATUS_VAR *tmp1, tmp;
3631
3654
  enum enum_schema_tables schema_table_idx=
3683
3706
*/
3684
3707
 
3685
3708
static int
3686
 
get_referential_constraints_record(THD *thd, TableList *tables,
3687
 
                                   Table *table, bool res,
 
3709
get_referential_constraints_record(THD *thd, TABLE_LIST *tables,
 
3710
                                   TABLE *table, bool res,
3688
3711
                                   LEX_STRING *db_name, LEX_STRING *table_name)
3689
3712
{
3690
 
  const CHARSET_INFO * const cs= system_charset_info;
 
3713
  CHARSET_INFO *cs= system_charset_info;
3691
3714
 
3692
3715
  if (res)
3693
3716
  {
3694
3717
    if (thd->is_error())
3695
 
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
3718
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
3696
3719
                   thd->main_da.sql_errno(), thd->main_da.message());
3697
3720
    thd->clear_error();
3698
3721
    return(0);
3700
3723
 
3701
3724
  {
3702
3725
    List<FOREIGN_KEY_INFO> f_key_list;
3703
 
    Table *show_table= tables->table;
 
3726
    TABLE *show_table= tables->table;
3704
3727
    show_table->file->info(HA_STATUS_VARIABLE | 
3705
3728
                           HA_STATUS_NO_LOCK |
3706
3729
                           HA_STATUS_TIME);
3760
3783
    0   table not found
3761
3784
    1   found the schema table
3762
3785
*/
3763
 
static bool find_schema_table_in_plugin(THD *thd __attribute__((unused)),
 
3786
static bool find_schema_table_in_plugin(THD *thd __attribute__((__unused__)),
3764
3787
                                           plugin_ref plugin,
3765
3788
                                           void* p_table)
3766
3789
{
3807
3830
 
3808
3831
  schema_table_a.table_name= table_name;
3809
3832
  if (plugin_foreach(thd, find_schema_table_in_plugin, 
3810
 
                     DRIZZLE_INFORMATION_SCHEMA_PLUGIN, &schema_table_a))
 
3833
                     MYSQL_INFORMATION_SCHEMA_PLUGIN, &schema_table_a))
3811
3834
    return(schema_table_a.schema_table);
3812
3835
 
3813
3836
  return(NULL);
3835
3858
  @retval  NULL           Can't create table
3836
3859
*/
3837
3860
 
3838
 
Table *create_schema_table(THD *thd, TableList *table_list)
 
3861
TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
3839
3862
{
3840
3863
  int field_count= 0;
3841
3864
  Item *item;
3842
 
  Table *table;
 
3865
  TABLE *table;
3843
3866
  List<Item> field_list;
3844
3867
  ST_SCHEMA_TABLE *schema_table= table_list->schema_table;
3845
3868
  ST_FIELD_INFO *fields_info= schema_table->fields_info;
3846
 
  const CHARSET_INFO * const cs= system_charset_info;
 
3869
  CHARSET_INFO *cs= system_charset_info;
3847
3870
 
3848
3871
  for (; fields_info->field_name; fields_info++)
3849
3872
  {
3850
3873
    switch (fields_info->field_type) {
3851
 
    case DRIZZLE_TYPE_TINY:
3852
 
    case DRIZZLE_TYPE_LONG:
3853
 
    case DRIZZLE_TYPE_LONGLONG:
 
3874
    case MYSQL_TYPE_TINY:
 
3875
    case MYSQL_TYPE_LONG:
 
3876
    case MYSQL_TYPE_SHORT:
 
3877
    case MYSQL_TYPE_LONGLONG:
3854
3878
      if (!(item= new Item_return_int(fields_info->field_name,
3855
3879
                                      fields_info->field_length,
3856
3880
                                      fields_info->field_type,
3860
3884
      }
3861
3885
      item->unsigned_flag= (fields_info->field_flags & MY_I_S_UNSIGNED);
3862
3886
      break;
3863
 
    case DRIZZLE_TYPE_NEWDATE:
3864
 
    case DRIZZLE_TYPE_TIME:
3865
 
    case DRIZZLE_TYPE_TIMESTAMP:
3866
 
    case DRIZZLE_TYPE_DATETIME:
 
3887
    case MYSQL_TYPE_NEWDATE:
 
3888
    case MYSQL_TYPE_TIME:
 
3889
    case MYSQL_TYPE_TIMESTAMP:
 
3890
    case MYSQL_TYPE_DATETIME:
3867
3891
      if (!(item=new Item_return_date_time(fields_info->field_name,
3868
3892
                                           fields_info->field_type)))
3869
3893
      {
3870
3894
        return(0);
3871
3895
      }
3872
3896
      break;
3873
 
    case DRIZZLE_TYPE_DOUBLE:
 
3897
    case MYSQL_TYPE_FLOAT:
 
3898
    case MYSQL_TYPE_DOUBLE:
3874
3899
      if ((item= new Item_float(fields_info->field_name, 0.0, NOT_FIXED_DEC, 
3875
3900
                           fields_info->field_length)) == NULL)
3876
3901
        return(NULL);
3877
3902
      break;
3878
 
    case DRIZZLE_TYPE_NEWDECIMAL:
 
3903
    case MYSQL_TYPE_NEWDECIMAL:
3879
3904
      if (!(item= new Item_decimal((int64_t) fields_info->value, false)))
3880
3905
      {
3881
3906
        return(0);
3890
3915
      item->set_name(fields_info->field_name,
3891
3916
                     strlen(fields_info->field_name), cs);
3892
3917
      break;
3893
 
    case DRIZZLE_TYPE_BLOB:
 
3918
    case MYSQL_TYPE_BLOB:
3894
3919
      if (!(item= new Item_blob(fields_info->field_name,
3895
3920
                                fields_info->field_length)))
3896
3921
      {
3898
3923
      }
3899
3924
      break;
3900
3925
    default:
 
3926
      /* Don't let unimplemented types pass through. Could be a grave error. */
 
3927
      assert(fields_info->field_type == MYSQL_TYPE_STRING);
 
3928
 
3901
3929
      if (!(item= new Item_empty_string("", fields_info->field_length, cs)))
3902
3930
      {
3903
3931
        return(0);
3918
3946
  tmp_table_param->schema_table= 1;
3919
3947
  SELECT_LEX *select_lex= thd->lex->current_select;
3920
3948
  if (!(table= create_tmp_table(thd, tmp_table_param,
3921
 
                                field_list, (order_st*) 0, 0, 0, 
 
3949
                                field_list, (ORDER*) 0, 0, 0, 
3922
3950
                                (select_lex->options | thd->options |
3923
3951
                                 TMP_TABLE_ALL_COLUMNS),
3924
3952
                                HA_POS_ERROR, table_list->alias)))
3926
3954
  my_bitmap_map* bitmaps=
3927
3955
    (my_bitmap_map*) thd->alloc(bitmap_buffer_size(field_count));
3928
3956
  bitmap_init(&table->def_read_set, (my_bitmap_map*) bitmaps, field_count,
3929
 
              false);
 
3957
              FALSE);
3930
3958
  table->read_set= &table->def_read_set;
3931
3959
  bitmap_clear_all(table->read_set);
3932
3960
  table_list->schema_table_param= tmp_table_param;
3958
3986
    if (field_info->old_name)
3959
3987
    {
3960
3988
      Item_field *field= new Item_field(context,
3961
 
                                        NULL, NULL, field_info->field_name);
 
3989
                                        NullS, NullS, field_info->field_name);
3962
3990
      if (field)
3963
3991
      {
3964
3992
        field->set_name(field_info->old_name,
3985
4013
    ST_FIELD_INFO *field_info= &schema_table->fields_info[1];
3986
4014
    String buffer(tmp,sizeof(tmp), system_charset_info);
3987
4015
    Item_field *field= new Item_field(context,
3988
 
                                      NULL, NULL, field_info->field_name);
 
4016
                                      NullS, NullS, field_info->field_name);
3989
4017
    if (!field || add_item_to_list(thd, field))
3990
4018
      return 1;
3991
4019
    buffer.length(0);
4020
4048
    buffer.append(')');
4021
4049
  }
4022
4050
  Item_field *field= new Item_field(context,
4023
 
                                    NULL, NULL, field_info->field_name);
 
4051
                                    NullS, NullS, field_info->field_name);
4024
4052
  if (add_item_to_list(thd, field))
4025
4053
    return 1;
4026
4054
  field->set_name(buffer.ptr(), buffer.length(), system_charset_info);
4028
4056
  {
4029
4057
    field->set_name(buffer.ptr(), buffer.length(), system_charset_info);
4030
4058
    field_info= &schema_table->fields_info[3];
4031
 
    field= new Item_field(context, NULL, NULL, field_info->field_name);
 
4059
    field= new Item_field(context, NullS, NullS, field_info->field_name);
4032
4060
    if (add_item_to_list(thd, field))
4033
4061
      return 1;
4034
4062
    field->set_name(field_info->old_name, strlen(field_info->old_name),
4053
4081
                               *field_num == 18))
4054
4082
      continue;
4055
4083
    Item_field *field= new Item_field(context,
4056
 
                                      NULL, NULL, field_info->field_name);
 
4084
                                      NullS, NullS, field_info->field_name);
4057
4085
    if (field)
4058
4086
    {
4059
4087
      field->set_name(field_info->old_name,
4078
4106
  {
4079
4107
    field_info= &schema_table->fields_info[*field_num];
4080
4108
    Item_field *field= new Item_field(context,
4081
 
                                      NULL, NULL, field_info->field_name);
 
4109
                                      NullS, NullS, field_info->field_name);
4082
4110
    if (field)
4083
4111
    {
4084
4112
      field->set_name(field_info->old_name,
4106
4134
    1   error
4107
4135
*/
4108
4136
 
4109
 
int mysql_schema_table(THD *thd, LEX *lex, TableList *table_list)
 
4137
int mysql_schema_table(THD *thd, LEX *lex, TABLE_LIST *table_list)
4110
4138
{
4111
 
  Table *table;
 
4139
  TABLE *table;
4112
4140
  if (!(table= table_list->schema_table->create_table(thd, table_list)))
4113
4141
    return(1);
4114
4142
  table->s->tmp_table= SYSTEM_TMP_TABLE;
4149
4177
    }
4150
4178
    List_iterator_fast<Item> it(sel->item_list);
4151
4179
    if (!(transl=
4152
 
          (Field_translator*)(thd->alloc(sel->item_list.elements *
 
4180
          (Field_translator*)(thd->stmt_arena->
 
4181
                              alloc(sel->item_list.elements *
4153
4182
                                    sizeof(Field_translator)))))
4154
4183
    {
4155
4184
      return(1);
4217
4246
    executed_place place where I_S table processed
4218
4247
 
4219
4248
  RETURN
4220
 
    false success
4221
 
    true  error
 
4249
    FALSE success
 
4250
    TRUE  error
4222
4251
*/
4223
4252
 
4224
4253
bool get_schema_tables_result(JOIN *join,
4235
4264
    if (!tab->table || !tab->table->pos_in_table_list)
4236
4265
      break;
4237
4266
 
4238
 
    TableList *table_list= tab->table->pos_in_table_list;
 
4267
    TABLE_LIST *table_list= tab->table->pos_in_table_list;
4239
4268
    if (table_list->schema_table)
4240
4269
    {
4241
4270
      bool is_subselect= (&lex->unit != lex->current_select->master_unit() &&
4296
4325
 
4297
4326
ST_FIELD_INFO schema_fields_info[]=
4298
4327
{
4299
 
  {"CATALOG_NAME", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, SKIP_OPEN_TABLE},
4300
 
  {"SCHEMA_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Database",
4301
 
   SKIP_OPEN_TABLE},
4302
 
  {"DEFAULT_CHARACTER_SET_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4303
 
   SKIP_OPEN_TABLE},
4304
 
  {"DEFAULT_COLLATION_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE},
4305
 
  {"SQL_PATH", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, SKIP_OPEN_TABLE},
4306
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4328
  {"CATALOG_NAME", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4329
  {"SCHEMA_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Database",
 
4330
   SKIP_OPEN_TABLE},
 
4331
  {"DEFAULT_CHARACTER_SET_NAME", 64, MYSQL_TYPE_STRING, 0, 0, 0,
 
4332
   SKIP_OPEN_TABLE},
 
4333
  {"DEFAULT_COLLATION_NAME", 64, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4334
  {"SQL_PATH", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4335
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4307
4336
};
4308
4337
 
4309
4338
 
4310
4339
ST_FIELD_INFO tables_fields_info[]=
4311
4340
{
4312
 
  {"TABLE_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, SKIP_OPEN_TABLE},
4313
 
  {"TABLE_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE},
4314
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Name",
 
4341
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4342
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4343
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Name",
4315
4344
   SKIP_OPEN_TABLE},
4316
 
  {"TABLE_TYPE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FRM_ONLY},
4317
 
  {"ENGINE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, "Engine", OPEN_FRM_ONLY},
4318
 
  {"VERSION", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0,
 
4345
  {"TABLE_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FRM_ONLY},
 
4346
  {"ENGINE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, "Engine", OPEN_FRM_ONLY},
 
4347
  {"VERSION", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0,
4319
4348
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Version", OPEN_FRM_ONLY},
4320
 
  {"ROW_FORMAT", 10, DRIZZLE_TYPE_VARCHAR, 0, 1, "Row_format", OPEN_FULL_TABLE},
4321
 
  {"TABLE_ROWS", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0,
 
4349
  {"ROW_FORMAT", 10, MYSQL_TYPE_STRING, 0, 1, "Row_format", OPEN_FULL_TABLE},
 
4350
  {"TABLE_ROWS", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0,
4322
4351
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Rows", OPEN_FULL_TABLE},
4323
 
  {"AVG_ROW_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0, 
 
4352
  {"AVG_ROW_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0, 
4324
4353
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Avg_row_length", OPEN_FULL_TABLE},
4325
 
  {"DATA_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0, 
 
4354
  {"DATA_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0, 
4326
4355
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Data_length", OPEN_FULL_TABLE},
4327
 
  {"MAX_DATA_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0,
 
4356
  {"MAX_DATA_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0,
4328
4357
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Max_data_length", OPEN_FULL_TABLE},
4329
 
  {"INDEX_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0, 
 
4358
  {"INDEX_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0, 
4330
4359
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Index_length", OPEN_FULL_TABLE},
4331
 
  {"DATA_FREE", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0,
 
4360
  {"DATA_FREE", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0,
4332
4361
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Data_free", OPEN_FULL_TABLE},
4333
 
  {"AUTO_INCREMENT", MY_INT64_NUM_DECIMAL_DIGITS , DRIZZLE_TYPE_LONGLONG, 0, 
 
4362
  {"AUTO_INCREMENT", MY_INT64_NUM_DECIMAL_DIGITS , MYSQL_TYPE_LONGLONG, 0, 
4334
4363
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Auto_increment", OPEN_FULL_TABLE},
4335
 
  {"CREATE_TIME", 0, DRIZZLE_TYPE_DATETIME, 0, 1, "Create_time", OPEN_FULL_TABLE},
4336
 
  {"UPDATE_TIME", 0, DRIZZLE_TYPE_DATETIME, 0, 1, "Update_time", OPEN_FULL_TABLE},
4337
 
  {"CHECK_TIME", 0, DRIZZLE_TYPE_DATETIME, 0, 1, "Check_time", OPEN_FULL_TABLE},
4338
 
  {"TABLE_COLLATION", 64, DRIZZLE_TYPE_VARCHAR, 0, 1, "Collation", OPEN_FRM_ONLY},
4339
 
  {"CHECKSUM", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0,
 
4364
  {"CREATE_TIME", 0, MYSQL_TYPE_DATETIME, 0, 1, "Create_time", OPEN_FULL_TABLE},
 
4365
  {"UPDATE_TIME", 0, MYSQL_TYPE_DATETIME, 0, 1, "Update_time", OPEN_FULL_TABLE},
 
4366
  {"CHECK_TIME", 0, MYSQL_TYPE_DATETIME, 0, 1, "Check_time", OPEN_FULL_TABLE},
 
4367
  {"TABLE_COLLATION", 64, MYSQL_TYPE_STRING, 0, 1, "Collation", OPEN_FRM_ONLY},
 
4368
  {"CHECKSUM", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0,
4340
4369
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Checksum", OPEN_FULL_TABLE},
4341
 
  {"CREATE_OPTIONS", 255, DRIZZLE_TYPE_VARCHAR, 0, 1, "Create_options",
 
4370
  {"CREATE_OPTIONS", 255, MYSQL_TYPE_STRING, 0, 1, "Create_options",
4342
4371
   OPEN_FRM_ONLY},
4343
 
  {"TABLE_COMMENT", TABLE_COMMENT_MAXLEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Comment", OPEN_FRM_ONLY},
4344
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4372
  {"TABLE_COMMENT", TABLE_COMMENT_MAXLEN, MYSQL_TYPE_STRING, 0, 0, "Comment", OPEN_FRM_ONLY},
 
4373
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4345
4374
};
4346
4375
 
4347
4376
 
4348
4377
ST_FIELD_INFO columns_fields_info[]=
4349
4378
{
4350
 
  {"TABLE_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FRM_ONLY},
4351
 
  {"TABLE_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FRM_ONLY},
4352
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FRM_ONLY},
4353
 
  {"COLUMN_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Field",
 
4379
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FRM_ONLY},
 
4380
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FRM_ONLY},
 
4381
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FRM_ONLY},
 
4382
  {"COLUMN_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Field",
4354
4383
   OPEN_FRM_ONLY},
4355
 
  {"ORDINAL_POSITION", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0,
 
4384
  {"ORDINAL_POSITION", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0,
4356
4385
   MY_I_S_UNSIGNED, 0, OPEN_FRM_ONLY},
4357
 
  {"COLUMN_DEFAULT", MAX_FIELD_VARCHARLENGTH, DRIZZLE_TYPE_VARCHAR, 0,
 
4386
  {"COLUMN_DEFAULT", MAX_FIELD_VARCHARLENGTH, MYSQL_TYPE_STRING, 0,
4358
4387
   1, "Default", OPEN_FRM_ONLY},
4359
 
  {"IS_NULLABLE", 3, DRIZZLE_TYPE_VARCHAR, 0, 0, "Null", OPEN_FRM_ONLY},
4360
 
  {"DATA_TYPE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FRM_ONLY},
4361
 
  {"CHARACTER_MAXIMUM_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG,
4362
 
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
4363
 
  {"CHARACTER_OCTET_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS , DRIZZLE_TYPE_LONGLONG,
4364
 
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
4365
 
  {"NUMERIC_PRECISION", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG,
4366
 
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
4367
 
  {"NUMERIC_SCALE", MY_INT64_NUM_DECIMAL_DIGITS , DRIZZLE_TYPE_LONGLONG,
4368
 
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
4369
 
  {"CHARACTER_SET_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FRM_ONLY},
4370
 
  {"COLLATION_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 1, "Collation", OPEN_FRM_ONLY},
4371
 
  {"COLUMN_TYPE", 65535, DRIZZLE_TYPE_VARCHAR, 0, 0, "Type", OPEN_FRM_ONLY},
4372
 
  {"COLUMN_KEY", 3, DRIZZLE_TYPE_VARCHAR, 0, 0, "Key", OPEN_FRM_ONLY},
4373
 
  {"EXTRA", 27, DRIZZLE_TYPE_VARCHAR, 0, 0, "Extra", OPEN_FRM_ONLY},
4374
 
  {"PRIVILEGES", 80, DRIZZLE_TYPE_VARCHAR, 0, 0, "Privileges", OPEN_FRM_ONLY},
4375
 
  {"COLUMN_COMMENT", COLUMN_COMMENT_MAXLEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Comment", OPEN_FRM_ONLY},
4376
 
  {"STORAGE", 8, DRIZZLE_TYPE_VARCHAR, 0, 0, "Storage", OPEN_FRM_ONLY},
4377
 
  {"FORMAT", 8, DRIZZLE_TYPE_VARCHAR, 0, 0, "Format", OPEN_FRM_ONLY},
4378
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4388
  {"IS_NULLABLE", 3, MYSQL_TYPE_STRING, 0, 0, "Null", OPEN_FRM_ONLY},
 
4389
  {"DATA_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FRM_ONLY},
 
4390
  {"CHARACTER_MAXIMUM_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG,
 
4391
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
 
4392
  {"CHARACTER_OCTET_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS , MYSQL_TYPE_LONGLONG,
 
4393
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
 
4394
  {"NUMERIC_PRECISION", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG,
 
4395
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
 
4396
  {"NUMERIC_SCALE", MY_INT64_NUM_DECIMAL_DIGITS , MYSQL_TYPE_LONGLONG,
 
4397
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
 
4398
  {"CHARACTER_SET_NAME", 64, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FRM_ONLY},
 
4399
  {"COLLATION_NAME", 64, MYSQL_TYPE_STRING, 0, 1, "Collation", OPEN_FRM_ONLY},
 
4400
  {"COLUMN_TYPE", 65535, MYSQL_TYPE_STRING, 0, 0, "Type", OPEN_FRM_ONLY},
 
4401
  {"COLUMN_KEY", 3, MYSQL_TYPE_STRING, 0, 0, "Key", OPEN_FRM_ONLY},
 
4402
  {"EXTRA", 27, MYSQL_TYPE_STRING, 0, 0, "Extra", OPEN_FRM_ONLY},
 
4403
  {"PRIVILEGES", 80, MYSQL_TYPE_STRING, 0, 0, "Privileges", OPEN_FRM_ONLY},
 
4404
  {"COLUMN_COMMENT", COLUMN_COMMENT_MAXLEN, MYSQL_TYPE_STRING, 0, 0, "Comment", OPEN_FRM_ONLY},
 
4405
  {"STORAGE", 8, MYSQL_TYPE_STRING, 0, 0, "Storage", OPEN_FRM_ONLY},
 
4406
  {"FORMAT", 8, MYSQL_TYPE_STRING, 0, 0, "Format", OPEN_FRM_ONLY},
 
4407
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4379
4408
};
4380
4409
 
4381
4410
 
4382
4411
ST_FIELD_INFO charsets_fields_info[]=
4383
4412
{
4384
 
  {"CHARACTER_SET_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, "Charset",
4385
 
   SKIP_OPEN_TABLE},
4386
 
  {"DEFAULT_COLLATE_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, "Default collation",
4387
 
   SKIP_OPEN_TABLE},
4388
 
  {"DESCRIPTION", 60, DRIZZLE_TYPE_VARCHAR, 0, 0, "Description",
4389
 
   SKIP_OPEN_TABLE},
4390
 
  {"MAXLEN", 3, DRIZZLE_TYPE_LONGLONG, 0, 0, "Maxlen", SKIP_OPEN_TABLE},
4391
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4413
  {"CHARACTER_SET_NAME", 64, MYSQL_TYPE_STRING, 0, 0, "Charset",
 
4414
   SKIP_OPEN_TABLE},
 
4415
  {"DEFAULT_COLLATE_NAME", 64, MYSQL_TYPE_STRING, 0, 0, "Default collation",
 
4416
   SKIP_OPEN_TABLE},
 
4417
  {"DESCRIPTION", 60, MYSQL_TYPE_STRING, 0, 0, "Description",
 
4418
   SKIP_OPEN_TABLE},
 
4419
  {"MAXLEN", 3, MYSQL_TYPE_LONGLONG, 0, 0, "Maxlen", SKIP_OPEN_TABLE},
 
4420
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4392
4421
};
4393
4422
 
4394
4423
 
4395
4424
ST_FIELD_INFO collation_fields_info[]=
4396
4425
{
4397
 
  {"COLLATION_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, "Collation", SKIP_OPEN_TABLE},
4398
 
  {"CHARACTER_SET_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, "Charset",
4399
 
   SKIP_OPEN_TABLE},
4400
 
  {"ID", MY_INT32_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0, 0, "Id",
4401
 
   SKIP_OPEN_TABLE},
4402
 
  {"IS_DEFAULT", 3, DRIZZLE_TYPE_VARCHAR, 0, 0, "Default", SKIP_OPEN_TABLE},
4403
 
  {"IS_COMPILED", 3, DRIZZLE_TYPE_VARCHAR, 0, 0, "Compiled", SKIP_OPEN_TABLE},
4404
 
  {"SORTLEN", 3, DRIZZLE_TYPE_LONGLONG, 0, 0, "Sortlen", SKIP_OPEN_TABLE},
4405
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4426
  {"COLLATION_NAME", 64, MYSQL_TYPE_STRING, 0, 0, "Collation", SKIP_OPEN_TABLE},
 
4427
  {"CHARACTER_SET_NAME", 64, MYSQL_TYPE_STRING, 0, 0, "Charset",
 
4428
   SKIP_OPEN_TABLE},
 
4429
  {"ID", MY_INT32_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0, 0, "Id",
 
4430
   SKIP_OPEN_TABLE},
 
4431
  {"IS_DEFAULT", 3, MYSQL_TYPE_STRING, 0, 0, "Default", SKIP_OPEN_TABLE},
 
4432
  {"IS_COMPILED", 3, MYSQL_TYPE_STRING, 0, 0, "Compiled", SKIP_OPEN_TABLE},
 
4433
  {"SORTLEN", 3, MYSQL_TYPE_LONGLONG, 0, 0, "Sortlen", SKIP_OPEN_TABLE},
 
4434
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
 
4435
};
 
4436
 
 
4437
 
 
4438
ST_FIELD_INFO events_fields_info[]=
 
4439
{
 
4440
  {"EVENT_CATALOG", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4441
  {"EVENT_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Db",
 
4442
   SKIP_OPEN_TABLE},
 
4443
  {"EVENT_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Name",
 
4444
   SKIP_OPEN_TABLE},
 
4445
  {"DEFINER", 77, MYSQL_TYPE_STRING, 0, 0, "Definer", SKIP_OPEN_TABLE},
 
4446
  {"TIME_ZONE", 64, MYSQL_TYPE_STRING, 0, 0, "Time zone", SKIP_OPEN_TABLE},
 
4447
  {"EVENT_BODY", 8, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4448
  {"EVENT_DEFINITION", 65535, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4449
  {"EVENT_TYPE", 9, MYSQL_TYPE_STRING, 0, 0, "Type", SKIP_OPEN_TABLE},
 
4450
  {"EXECUTE_AT", 0, MYSQL_TYPE_DATETIME, 0, 1, "Execute at", SKIP_OPEN_TABLE},
 
4451
  {"INTERVAL_VALUE", 256, MYSQL_TYPE_STRING, 0, 1, "Interval value",
 
4452
   SKIP_OPEN_TABLE},
 
4453
  {"INTERVAL_FIELD", 18, MYSQL_TYPE_STRING, 0, 1, "Interval field",
 
4454
   SKIP_OPEN_TABLE},
 
4455
  {"SQL_MODE", 65535, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4456
  {"STARTS", 0, MYSQL_TYPE_DATETIME, 0, 1, "Starts", SKIP_OPEN_TABLE},
 
4457
  {"ENDS", 0, MYSQL_TYPE_DATETIME, 0, 1, "Ends", SKIP_OPEN_TABLE},
 
4458
  {"STATUS", 18, MYSQL_TYPE_STRING, 0, 0, "Status", SKIP_OPEN_TABLE},
 
4459
  {"ON_COMPLETION", 12, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4460
  {"CREATED", 0, MYSQL_TYPE_DATETIME, 0, 0, 0, SKIP_OPEN_TABLE},
 
4461
  {"LAST_ALTERED", 0, MYSQL_TYPE_DATETIME, 0, 0, 0, SKIP_OPEN_TABLE},
 
4462
  {"LAST_EXECUTED", 0, MYSQL_TYPE_DATETIME, 0, 1, 0, SKIP_OPEN_TABLE},
 
4463
  {"EVENT_COMMENT", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4464
  {"ORIGINATOR", 10, MYSQL_TYPE_LONGLONG, 0, 0, "Originator", SKIP_OPEN_TABLE},
 
4465
  {"CHARACTER_SET_CLIENT", MY_CS_NAME_SIZE, MYSQL_TYPE_STRING, 0, 0,
 
4466
   "character_set_client", SKIP_OPEN_TABLE},
 
4467
  {"COLLATION_CONNECTION", MY_CS_NAME_SIZE, MYSQL_TYPE_STRING, 0, 0,
 
4468
   "collation_connection", SKIP_OPEN_TABLE},
 
4469
  {"DATABASE_COLLATION", MY_CS_NAME_SIZE, MYSQL_TYPE_STRING, 0, 0,
 
4470
   "Database Collation", SKIP_OPEN_TABLE},
 
4471
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4406
4472
};
4407
4473
 
4408
4474
 
4409
4475
 
4410
4476
ST_FIELD_INFO coll_charset_app_fields_info[]=
4411
4477
{
4412
 
  {"COLLATION_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE},
4413
 
  {"CHARACTER_SET_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE},
4414
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4478
  {"COLLATION_NAME", 64, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4479
  {"CHARACTER_SET_NAME", 64, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4480
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4415
4481
};
4416
4482
 
4417
4483
 
4418
4484
ST_FIELD_INFO stat_fields_info[]=
4419
4485
{
4420
 
  {"TABLE_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FRM_ONLY},
4421
 
  {"TABLE_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FRM_ONLY},
4422
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Table", OPEN_FRM_ONLY},
4423
 
  {"NON_UNIQUE", 1, DRIZZLE_TYPE_LONGLONG, 0, 0, "Non_unique", OPEN_FRM_ONLY},
4424
 
  {"INDEX_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FRM_ONLY},
4425
 
  {"INDEX_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Key_name",
4426
 
   OPEN_FRM_ONLY},
4427
 
  {"SEQ_IN_INDEX", 2, DRIZZLE_TYPE_LONGLONG, 0, 0, "Seq_in_index", OPEN_FRM_ONLY},
4428
 
  {"COLUMN_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Column_name",
4429
 
   OPEN_FRM_ONLY},
4430
 
  {"COLLATION", 1, DRIZZLE_TYPE_VARCHAR, 0, 1, "Collation", OPEN_FRM_ONLY},
4431
 
  {"CARDINALITY", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0, 1,
 
4486
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FRM_ONLY},
 
4487
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FRM_ONLY},
 
4488
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Table", OPEN_FRM_ONLY},
 
4489
  {"NON_UNIQUE", 1, MYSQL_TYPE_LONGLONG, 0, 0, "Non_unique", OPEN_FRM_ONLY},
 
4490
  {"INDEX_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FRM_ONLY},
 
4491
  {"INDEX_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Key_name",
 
4492
   OPEN_FRM_ONLY},
 
4493
  {"SEQ_IN_INDEX", 2, MYSQL_TYPE_LONGLONG, 0, 0, "Seq_in_index", OPEN_FRM_ONLY},
 
4494
  {"COLUMN_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Column_name",
 
4495
   OPEN_FRM_ONLY},
 
4496
  {"COLLATION", 1, MYSQL_TYPE_STRING, 0, 1, "Collation", OPEN_FRM_ONLY},
 
4497
  {"CARDINALITY", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0, 1,
4432
4498
   "Cardinality", OPEN_FULL_TABLE},
4433
 
  {"SUB_PART", 3, DRIZZLE_TYPE_LONGLONG, 0, 1, "Sub_part", OPEN_FRM_ONLY},
4434
 
  {"PACKED", 10, DRIZZLE_TYPE_VARCHAR, 0, 1, "Packed", OPEN_FRM_ONLY},
4435
 
  {"NULLABLE", 3, DRIZZLE_TYPE_VARCHAR, 0, 0, "Null", OPEN_FRM_ONLY},
4436
 
  {"INDEX_TYPE", 16, DRIZZLE_TYPE_VARCHAR, 0, 0, "Index_type", OPEN_FULL_TABLE},
4437
 
  {"COMMENT", 16, DRIZZLE_TYPE_VARCHAR, 0, 1, "Comment", OPEN_FRM_ONLY},
4438
 
  {"INDEX_COMMENT", INDEX_COMMENT_MAXLEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Index_Comment", OPEN_FRM_ONLY},
4439
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4499
  {"SUB_PART", 3, MYSQL_TYPE_LONGLONG, 0, 1, "Sub_part", OPEN_FRM_ONLY},
 
4500
  {"PACKED", 10, MYSQL_TYPE_STRING, 0, 1, "Packed", OPEN_FRM_ONLY},
 
4501
  {"NULLABLE", 3, MYSQL_TYPE_STRING, 0, 0, "Null", OPEN_FRM_ONLY},
 
4502
  {"INDEX_TYPE", 16, MYSQL_TYPE_STRING, 0, 0, "Index_type", OPEN_FULL_TABLE},
 
4503
  {"COMMENT", 16, MYSQL_TYPE_STRING, 0, 1, "Comment", OPEN_FRM_ONLY},
 
4504
  {"INDEX_COMMENT", INDEX_COMMENT_MAXLEN, MYSQL_TYPE_STRING, 0, 0, "Index_Comment", OPEN_FRM_ONLY},
 
4505
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
 
4506
};
 
4507
 
 
4508
 
 
4509
ST_FIELD_INFO user_privileges_fields_info[]=
 
4510
{
 
4511
  {"GRANTEE", 81, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4512
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4513
  {"PRIVILEGE_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4514
  {"IS_GRANTABLE", 3, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4515
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
 
4516
};
 
4517
 
 
4518
 
 
4519
ST_FIELD_INFO schema_privileges_fields_info[]=
 
4520
{
 
4521
  {"GRANTEE", 81, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4522
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4523
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4524
  {"PRIVILEGE_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4525
  {"IS_GRANTABLE", 3, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4526
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
 
4527
};
 
4528
 
 
4529
 
 
4530
ST_FIELD_INFO table_privileges_fields_info[]=
 
4531
{
 
4532
  {"GRANTEE", 81, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4533
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4534
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4535
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4536
  {"PRIVILEGE_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4537
  {"IS_GRANTABLE", 3, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4538
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
 
4539
};
 
4540
 
 
4541
 
 
4542
ST_FIELD_INFO column_privileges_fields_info[]=
 
4543
{
 
4544
  {"GRANTEE", 81, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4545
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4546
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4547
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4548
  {"COLUMN_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4549
  {"PRIVILEGE_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4550
  {"IS_GRANTABLE", 3, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4551
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4440
4552
};
4441
4553
 
4442
4554
 
4443
4555
ST_FIELD_INFO table_constraints_fields_info[]=
4444
4556
{
4445
 
  {"CONSTRAINT_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FULL_TABLE},
4446
 
  {"CONSTRAINT_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4447
 
   OPEN_FULL_TABLE},
4448
 
  {"CONSTRAINT_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4449
 
   OPEN_FULL_TABLE},
4450
 
  {"TABLE_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4451
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4452
 
  {"CONSTRAINT_TYPE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4453
 
   OPEN_FULL_TABLE},
4454
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4557
  {"CONSTRAINT_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4558
  {"CONSTRAINT_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4559
   OPEN_FULL_TABLE},
 
4560
  {"CONSTRAINT_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4561
   OPEN_FULL_TABLE},
 
4562
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4563
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4564
  {"CONSTRAINT_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4565
   OPEN_FULL_TABLE},
 
4566
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4455
4567
};
4456
4568
 
4457
4569
 
4458
4570
ST_FIELD_INFO key_column_usage_fields_info[]=
4459
4571
{
4460
 
  {"CONSTRAINT_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FULL_TABLE},
4461
 
  {"CONSTRAINT_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4462
 
   OPEN_FULL_TABLE},
4463
 
  {"CONSTRAINT_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4464
 
   OPEN_FULL_TABLE},
4465
 
  {"TABLE_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FULL_TABLE},
4466
 
  {"TABLE_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4467
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4468
 
  {"COLUMN_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4469
 
  {"ORDINAL_POSITION", 10 ,DRIZZLE_TYPE_LONGLONG, 0, 0, 0, OPEN_FULL_TABLE},
4470
 
  {"POSITION_IN_UNIQUE_CONSTRAINT", 10 ,DRIZZLE_TYPE_LONGLONG, 0, 1, 0,
4471
 
   OPEN_FULL_TABLE},
4472
 
  {"REFERENCED_TABLE_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0,
4473
 
   OPEN_FULL_TABLE},
4474
 
  {"REFERENCED_TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0,
4475
 
   OPEN_FULL_TABLE},
4476
 
  {"REFERENCED_COLUMN_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0,
4477
 
   OPEN_FULL_TABLE},
4478
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4572
  {"CONSTRAINT_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4573
  {"CONSTRAINT_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4574
   OPEN_FULL_TABLE},
 
4575
  {"CONSTRAINT_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4576
   OPEN_FULL_TABLE},
 
4577
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4578
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4579
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4580
  {"COLUMN_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4581
  {"ORDINAL_POSITION", 10 ,MYSQL_TYPE_LONGLONG, 0, 0, 0, OPEN_FULL_TABLE},
 
4582
  {"POSITION_IN_UNIQUE_CONSTRAINT", 10 ,MYSQL_TYPE_LONGLONG, 0, 1, 0,
 
4583
   OPEN_FULL_TABLE},
 
4584
  {"REFERENCED_TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, 0,
 
4585
   OPEN_FULL_TABLE},
 
4586
  {"REFERENCED_TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, 0,
 
4587
   OPEN_FULL_TABLE},
 
4588
  {"REFERENCED_COLUMN_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, 0,
 
4589
   OPEN_FULL_TABLE},
 
4590
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4479
4591
};
4480
4592
 
4481
4593
 
4482
4594
ST_FIELD_INFO table_names_fields_info[]=
4483
4595
{
4484
 
  {"TABLE_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, SKIP_OPEN_TABLE},
4485
 
  {"TABLE_SCHEMA",NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE},
4486
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Tables_in_",
 
4596
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4597
  {"TABLE_SCHEMA",NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4598
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Tables_in_",
4487
4599
   SKIP_OPEN_TABLE},
4488
 
  {"TABLE_TYPE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Table_type",
 
4600
  {"TABLE_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Table_type",
4489
4601
   OPEN_FRM_ONLY},
4490
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4602
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4491
4603
};
4492
4604
 
4493
4605
 
4494
4606
ST_FIELD_INFO open_tables_fields_info[]=
4495
4607
{
4496
 
  {"Database", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Database",
 
4608
  {"Database", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Database",
4497
4609
   SKIP_OPEN_TABLE},
4498
 
  {"Table",NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Table", SKIP_OPEN_TABLE},
4499
 
  {"In_use", 1, DRIZZLE_TYPE_LONGLONG, 0, 0, "In_use", SKIP_OPEN_TABLE},
4500
 
  {"Name_locked", 4, DRIZZLE_TYPE_LONGLONG, 0, 0, "Name_locked", SKIP_OPEN_TABLE},
4501
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4610
  {"Table",NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Table", SKIP_OPEN_TABLE},
 
4611
  {"In_use", 1, MYSQL_TYPE_LONGLONG, 0, 0, "In_use", SKIP_OPEN_TABLE},
 
4612
  {"Name_locked", 4, MYSQL_TYPE_LONGLONG, 0, 0, "Name_locked", SKIP_OPEN_TABLE},
 
4613
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4502
4614
};
4503
4615
 
4504
4616
 
4505
4617
ST_FIELD_INFO variables_fields_info[]=
4506
4618
{
4507
 
  {"VARIABLE_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, "Variable_name",
 
4619
  {"VARIABLE_NAME", 64, MYSQL_TYPE_STRING, 0, 0, "Variable_name",
4508
4620
   SKIP_OPEN_TABLE},
4509
 
  {"VARIABLE_VALUE", 16300, DRIZZLE_TYPE_VARCHAR, 0, 1, "Value", SKIP_OPEN_TABLE},
4510
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4621
  {"VARIABLE_VALUE", 16300, MYSQL_TYPE_STRING, 0, 1, "Value", SKIP_OPEN_TABLE},
 
4622
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4511
4623
};
4512
4624
 
4513
4625
 
4514
4626
ST_FIELD_INFO processlist_fields_info[]=
4515
4627
{
4516
 
  {"ID", 4, DRIZZLE_TYPE_LONGLONG, 0, 0, "Id", SKIP_OPEN_TABLE},
4517
 
  {"USER", 16, DRIZZLE_TYPE_VARCHAR, 0, 0, "User", SKIP_OPEN_TABLE},
4518
 
  {"HOST", LIST_PROCESS_HOST_LEN,  DRIZZLE_TYPE_VARCHAR, 0, 0, "Host",
4519
 
   SKIP_OPEN_TABLE},
4520
 
  {"DB", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, "Db", SKIP_OPEN_TABLE},
4521
 
  {"COMMAND", 16, DRIZZLE_TYPE_VARCHAR, 0, 0, "Command", SKIP_OPEN_TABLE},
4522
 
  {"TIME", 7, DRIZZLE_TYPE_LONGLONG, 0, 0, "Time", SKIP_OPEN_TABLE},
4523
 
  {"STATE", 64, DRIZZLE_TYPE_VARCHAR, 0, 1, "State", SKIP_OPEN_TABLE},
4524
 
  {"INFO", PROCESS_LIST_INFO_WIDTH, DRIZZLE_TYPE_VARCHAR, 0, 1, "Info",
4525
 
   SKIP_OPEN_TABLE},
4526
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4628
  {"ID", 4, MYSQL_TYPE_LONGLONG, 0, 0, "Id", SKIP_OPEN_TABLE},
 
4629
  {"USER", 16, MYSQL_TYPE_STRING, 0, 0, "User", SKIP_OPEN_TABLE},
 
4630
  {"HOST", LIST_PROCESS_HOST_LEN,  MYSQL_TYPE_STRING, 0, 0, "Host",
 
4631
   SKIP_OPEN_TABLE},
 
4632
  {"DB", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, "Db", SKIP_OPEN_TABLE},
 
4633
  {"COMMAND", 16, MYSQL_TYPE_STRING, 0, 0, "Command", SKIP_OPEN_TABLE},
 
4634
  {"TIME", 7, MYSQL_TYPE_LONGLONG, 0, 0, "Time", SKIP_OPEN_TABLE},
 
4635
  {"STATE", 64, MYSQL_TYPE_STRING, 0, 1, "State", SKIP_OPEN_TABLE},
 
4636
  {"INFO", PROCESS_LIST_INFO_WIDTH, MYSQL_TYPE_STRING, 0, 1, "Info",
 
4637
   SKIP_OPEN_TABLE},
 
4638
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4527
4639
};
4528
4640
 
4529
4641
 
4530
4642
ST_FIELD_INFO plugin_fields_info[]=
4531
4643
{
4532
 
  {"PLUGIN_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Name", 
4533
 
   SKIP_OPEN_TABLE},
4534
 
  {"PLUGIN_VERSION", 20, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE},
4535
 
  {"PLUGIN_STATUS", 10, DRIZZLE_TYPE_VARCHAR, 0, 0, "Status", SKIP_OPEN_TABLE},
4536
 
  {"PLUGIN_TYPE", 80, DRIZZLE_TYPE_VARCHAR, 0, 0, "Type", SKIP_OPEN_TABLE},
4537
 
  {"PLUGIN_LIBRARY", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, "Library",
4538
 
   SKIP_OPEN_TABLE},
4539
 
  {"PLUGIN_AUTHOR", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, SKIP_OPEN_TABLE},
4540
 
  {"PLUGIN_DESCRIPTION", 65535, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, SKIP_OPEN_TABLE},
4541
 
  {"PLUGIN_LICENSE", 80, DRIZZLE_TYPE_VARCHAR, 0, 1, "License", SKIP_OPEN_TABLE},
4542
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4644
  {"PLUGIN_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Name",
 
4645
   SKIP_OPEN_TABLE},
 
4646
  {"PLUGIN_VERSION", 20, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4647
  {"PLUGIN_STATUS", 10, MYSQL_TYPE_STRING, 0, 0, "Status", SKIP_OPEN_TABLE},
 
4648
  {"PLUGIN_TYPE", 80, MYSQL_TYPE_STRING, 0, 0, "Type", SKIP_OPEN_TABLE},
 
4649
  {"PLUGIN_TYPE_VERSION", 20, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4650
  {"PLUGIN_LIBRARY", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, "Library",
 
4651
   SKIP_OPEN_TABLE},
 
4652
  {"PLUGIN_LIBRARY_VERSION", 20, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4653
  {"PLUGIN_AUTHOR", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4654
  {"PLUGIN_DESCRIPTION", 65535, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4655
  {"PLUGIN_LICENSE", 80, MYSQL_TYPE_STRING, 0, 1, "License", SKIP_OPEN_TABLE},
 
4656
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4543
4657
};
4544
4658
 
4545
4659
ST_FIELD_INFO referential_constraints_fields_info[]=
4546
4660
{
4547
 
  {"CONSTRAINT_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0, OPEN_FULL_TABLE},
4548
 
  {"CONSTRAINT_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4549
 
   OPEN_FULL_TABLE},
4550
 
  {"CONSTRAINT_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4551
 
   OPEN_FULL_TABLE},
4552
 
  {"UNIQUE_CONSTRAINT_CATALOG", FN_REFLEN, DRIZZLE_TYPE_VARCHAR, 0, 1, 0,
4553
 
   OPEN_FULL_TABLE},
4554
 
  {"UNIQUE_CONSTRAINT_SCHEMA", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
4555
 
   OPEN_FULL_TABLE},
4556
 
  {"UNIQUE_CONSTRAINT_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0,
 
4661
  {"CONSTRAINT_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4662
  {"CONSTRAINT_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4663
   OPEN_FULL_TABLE},
 
4664
  {"CONSTRAINT_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4665
   OPEN_FULL_TABLE},
 
4666
  {"UNIQUE_CONSTRAINT_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0,
 
4667
   OPEN_FULL_TABLE},
 
4668
  {"UNIQUE_CONSTRAINT_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4669
   OPEN_FULL_TABLE},
 
4670
  {"UNIQUE_CONSTRAINT_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0,
4557
4671
   MY_I_S_MAYBE_NULL, 0, OPEN_FULL_TABLE},
4558
 
  {"MATCH_OPTION", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4559
 
  {"UPDATE_RULE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4560
 
  {"DELETE_RULE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4561
 
  {"TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, OPEN_FULL_TABLE},
4562
 
  {"REFERENCED_TABLE_NAME", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, 0,
 
4672
  {"MATCH_OPTION", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4673
  {"UPDATE_RULE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4674
  {"DELETE_RULE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4675
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4676
  {"REFERENCED_TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
4563
4677
   OPEN_FULL_TABLE},
4564
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4678
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
 
4679
};
 
4680
 
 
4681
 
 
4682
ST_FIELD_INFO parameters_fields_info[]=
 
4683
{
 
4684
  {"SPECIFIC_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4685
  {"SPECIFIC_SCHEMA", NAME_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4686
  {"SPECIFIC_NAME", NAME_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4687
  {"ORDINAL_POSITION", 21 , MYSQL_TYPE_LONG, 0, 0, 0, OPEN_FULL_TABLE},
 
4688
  {"PARAMETER_MODE", 5, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4689
  {"PARAMETER_NAME", NAME_LEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4690
  {"DATA_TYPE", NAME_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4691
  {"CHARACTER_MAXIMUM_LENGTH", 21 , MYSQL_TYPE_LONG, 0, 1, 0, OPEN_FULL_TABLE},
 
4692
  {"CHARACTER_OCTET_LENGTH", 21 , MYSQL_TYPE_LONG, 0, 1, 0, OPEN_FULL_TABLE},
 
4693
  {"NUMERIC_PRECISION", 21 , MYSQL_TYPE_LONG, 0, 1, 0, OPEN_FULL_TABLE},
 
4694
  {"NUMERIC_SCALE", 21 , MYSQL_TYPE_LONG, 0, 1, 0, OPEN_FULL_TABLE},
 
4695
  {"CHARACTER_SET_NAME", 64, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4696
  {"COLLATION_NAME", 64, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4697
  {"DTD_IDENTIFIER", 65535, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4698
  {"ROUTINE_TYPE", 9, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4699
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE}
4565
4700
};
4566
4701
 
4567
4702
 
4582
4717
   create_schema_table, fill_schema_coll_charset_app, 0, 0, -1, -1, 0, 0},
4583
4718
  {"COLUMNS", columns_fields_info, create_schema_table, 
4584
4719
   get_all_tables, make_columns_old_format, get_schema_column_record, 1, 2, 0,
4585
 
   OPTIMIZE_I_S_TABLE},
 
4720
   OPTIMIZE_I_S_TABLE|OPEN_VIEW_FULL},
4586
4721
  {"GLOBAL_STATUS", variables_fields_info, create_schema_table,
4587
4722
   fill_status, make_old_format, 0, -1, -1, 0, 0},
4588
4723
  {"GLOBAL_VARIABLES", variables_fields_info, create_schema_table,
4649
4784
 
4650
4785
    if (plugin->plugin->init(schema_table))
4651
4786
    {
4652
 
      sql_print_error(_("Plugin '%s' init function returned error."),
 
4787
      sql_print_error("Plugin '%s' init function returned error.",
4653
4788
                      plugin->name.str);
4654
4789
      goto err;
4655
4790
    }
4660
4795
 
4661
4796
  return(0);
4662
4797
err:
4663
 
  free(schema_table);
 
4798
  my_free(schema_table, MYF(0));
4664
4799
  return(1);
4665
4800
}
4666
4801
 
4669
4804
  ST_SCHEMA_TABLE *schema_table= (ST_SCHEMA_TABLE *)plugin->data;
4670
4805
 
4671
4806
  if (schema_table && plugin->plugin->deinit)
4672
 
    free(schema_table);
 
4807
    my_free(schema_table, MYF(0));
4673
4808
 
4674
4809
  return(0);
4675
4810
}