← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/sql_show.cc

  • Committer: Mark Atwood
  • Date: 2008-07-12 07:25:25 UTC
  • mto: This revision was merged to the branch mainline in revision 139.
  • Revision ID: me@mark.atwood.name-20080712072525-s1dq9mtwo5td7af7
more hackery to get plugin UDFs working

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
 
89
 
static bool show_plugins(THD *thd, plugin_ref plugin,
 
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
 
 
90
static my_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
884
893
    {
885
894
      char *end;
886
895
      packet->append(STRING_WITH_LEN(" AUTO_INCREMENT="));
887
 
      end= int64_t10_to_str(create_info.auto_increment_value, buff,10);
 
896
      end= longlong10_to_str(create_info.auto_increment_value, buff,10);
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;
894
923
      packet->append(STRING_WITH_LEN(" MIN_ROWS="));
895
 
      end= int64_t10_to_str(share->min_rows, buff, 10);
 
924
      end= longlong10_to_str(share->min_rows, buff, 10);
896
925
      packet->append(buff, (uint) (end- buff));
897
926
    }
898
927
 
900
929
    {
901
930
      char *end;
902
931
      packet->append(STRING_WITH_LEN(" MAX_ROWS="));
903
 
      end= int64_t10_to_str(share->max_rows, buff, 10);
 
932
      end= longlong10_to_str(share->max_rows, buff, 10);
904
933
      packet->append(buff, (uint) (end - buff));
905
934
    }
906
935
 
908
937
    {
909
938
      char *end;
910
939
      packet->append(STRING_WITH_LEN(" AVG_ROW_LENGTH="));
911
 
      end= int64_t10_to_str(share->avg_row_length, buff,10);
 
940
      end= longlong10_to_str(share->avg_row_length, buff,10);
912
941
      packet->append(buff, (uint) (end - buff));
913
942
    }
914
943
 
940
969
    {
941
970
      char *end;
942
971
      packet->append(STRING_WITH_LEN(" KEY_BLOCK_SIZE="));
943
 
      end= int64_t10_to_str(table->s->key_block_size, buff, 10);
944
 
      packet->append(buff, (uint) (end - buff));
945
 
    }
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);
 
972
      end= longlong10_to_str(table->s->key_block_size, buff, 10);
951
973
      packet->append(buff, (uint) (end - buff));
952
974
    }
953
975
    table->file->append_create_info(packet);
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];
1052
1074
      table->s->key_block_size != key_info->block_size)
1053
1075
  {
1054
1076
    packet->append(STRING_WITH_LEN(" KEY_BLOCK_SIZE="));
1055
 
    end= int64_t10_to_str(key_info->block_size, buff, 10);
 
1077
    end= longlong10_to_str(key_info->block_size, buff, 10);
1056
1078
    packet->append(buff, (uint) (end - buff));
1057
1079
  }
1058
1080
 
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);
1176
1200
  while ((thd_info=thread_infos.get()))
1177
1201
  {
1178
1202
    protocol->prepare_for_resend();
1179
 
    protocol->store((uint64_t) thd_info->thread_id);
 
1203
    protocol->store((ulonglong) thd_info->thread_id);
1180
1204
    protocol->store(thd_info->user, system_charset_info);
1181
1205
    protocol->store(thd_info->host, system_charset_info);
1182
1206
    protocol->store(thd_info->db, system_charset_info);
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((longlong) 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);
1551
1576
          end= int10_to_str(*(long*) value, buff, 10);
1552
1577
          break;
1553
1578
        case SHOW_LONGLONG_STATUS:
1554
 
          value= ((char *) status_var + (uint64_t) value);
 
1579
          value= ((char *) status_var + (ulonglong) value);
1555
1580
          /* fall through */
1556
1581
        case SHOW_LONGLONG:
1557
 
          end= int64_t10_to_str(*(int64_t*) value, buff, 10);
 
1582
          end= longlong10_to_str(*(longlong*) value, buff, 10);
1558
1583
          break;
1559
1584
        case SHOW_HA_ROWS:
1560
 
          end= int64_t10_to_str((int64_t) *(ha_rows*) value, buff, 10);
 
1585
          end= longlong10_to_str((longlong) *(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, *(my_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:
1595
1620
          break;
1596
1621
        case SHOW_KEY_CACHE_LONGLONG:
1597
1622
          value= (char*) dflt_key_cache + (ulong)value;
1598
 
          end= int64_t10_to_str(*(int64_t*) value, buff, 10);
 
1623
          end= longlong10_to_str(*(longlong*) value, buff, 10);
1599
1624
          break;
1600
1625
        case SHOW_UNDEF:
1601
1626
          break;                                        // Return empty string
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
 
2074
2099
};
2075
2100
 
2076
2101
 
2077
 
static bool add_schema_table(THD *thd, plugin_ref plugin,
 
2102
static my_bool add_schema_table(THD *thd, plugin_ref plugin,
2078
2103
                                void* p_data)
2079
2104
{
2080
2105
  LEX_STRING *file_name= 0;
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);
2532
2558
      if lookup value is empty string then
2533
2559
      it's impossible table name or db name
2534
2560
    */
2535
 
    if ((lookup_field_vals.db_value.str && !lookup_field_vals.db_value.str[0]) ||
2536
 
        (lookup_field_vals.table_value.str && !lookup_field_vals.table_value.str[0]))
 
2561
    if (lookup_field_vals.db_value.str &&
 
2562
        !lookup_field_vals.db_value.str[0] ||
 
2563
        lookup_field_vals.table_value.str &&
 
2564
        !lookup_field_vals.table_value.str[0])
2537
2565
    {
2538
2566
      error= 0;
2539
2567
      goto err;
2542
2570
 
2543
2571
  if (lookup_field_vals.db_value.length &&
2544
2572
      !lookup_field_vals.wild_db_value)
2545
 
    tables->has_db_lookup_value= true;
 
2573
    tables->has_db_lookup_value= TRUE;
2546
2574
  if (lookup_field_vals.table_value.length &&
2547
2575
      !lookup_field_vals.wild_table_value) 
2548
 
    tables->has_table_lookup_value= true;
 
2576
    tables->has_table_lookup_value= TRUE;
2549
2577
 
2550
2578
  if (tables->has_db_lookup_value && tables->has_table_lookup_value)
2551
2579
    partial_cond= 0;
2601
2629
            continue;
2602
2630
          }
2603
2631
 
2604
 
          /* SHOW Table NAMES command */
 
2632
          /* SHOW TABLE NAMES command */
2605
2633
          if (schema_table_idx == SCH_TABLE_NAMES)
2606
2634
          {
2607
2635
            if (fill_schema_table_names(thd, tables->table, db_name,
2628
2656
            sel.parent_lex= lex;
2629
2657
            /* db_name can be changed in make_table_list() func */
2630
2658
            if (!thd->make_lex_string(&orig_db_name, db_name->str,
2631
 
                                      db_name->length, false))
 
2659
                                      db_name->length, FALSE))
2632
2660
              goto err;
2633
2661
            if (make_table_list(thd, &sel, db_name, table_name))
2634
2662
              goto err;
2635
 
            TableList *show_table_list= (TableList*) sel.table_list.first;
 
2663
            TABLE_LIST *show_table_list= (TABLE_LIST*) sel.table_list.first;
2636
2664
            lex->all_selects_list= &sel;
2637
2665
            lex->derived_tables= 0;
2638
2666
            lex->sql_command= SQLCOM_SHOW_FIELDS;
2639
2667
            show_table_list->i_s_requested_object=
2640
2668
              schema_table->i_s_requested_object;
2641
2669
            res= open_normal_and_derived_tables(thd, show_table_list,
2642
 
                                                DRIZZLE_LOCK_IGNORE_FLUSH);
 
2670
                                                MYSQL_LOCK_IGNORE_FLUSH);
2643
2671
            lex->sql_command= save_sql_command;
2644
2672
            /*
2645
2673
              XXX:  show_table_list has a flag i_is_requested,
2671
2699
                in this case.
2672
2700
              */
2673
2701
              thd->make_lex_string(&tmp_lex_string, show_table_list->alias,
2674
 
                                   strlen(show_table_list->alias), false);
 
2702
                                   strlen(show_table_list->alias), FALSE);
2675
2703
              res= schema_table->process_table(thd, show_table_list, table,
2676
2704
                                               res, &orig_db_name,
2677
2705
                                               &tmp_lex_string);
2703
2731
}
2704
2732
 
2705
2733
 
2706
 
bool store_schema_shemata(THD* thd, Table *table, LEX_STRING *db_name,
2707
 
                          const CHARSET_INFO * const cs)
 
2734
bool store_schema_shemata(THD* thd, TABLE *table, LEX_STRING *db_name,
 
2735
                          CHARSET_INFO *cs)
2708
2736
{
2709
2737
  restore_record(table, s->default_values);
2710
2738
  table->field[1]->store(db_name->str, db_name->length, system_charset_info);
2714
2742
}
2715
2743
 
2716
2744
 
2717
 
int fill_schema_schemata(THD *thd, TableList *tables, COND *cond)
 
2745
int fill_schema_schemata(THD *thd, TABLE_LIST *tables, COND *cond)
2718
2746
{
2719
2747
  /*
2720
2748
    TODO: fill_schema_shemata() is called when new client is connected.
2726
2754
  LEX_STRING *db_name;
2727
2755
  bool with_i_schema;
2728
2756
  HA_CREATE_INFO create;
2729
 
  Table *table= tables->table;
 
2757
  TABLE *table= tables->table;
2730
2758
 
2731
2759
  if (get_lookup_field_values(thd, cond, tables, &lookup_field_vals))
2732
2760
    return(0);
2741
2769
     !with_i_schema)
2742
2770
  {
2743
2771
    char path[FN_REFLEN+16];
2744
 
    uint32_t path_len;
 
2772
    uint path_len;
2745
2773
    struct stat stat_info;
2746
2774
    if (!lookup_field_vals.db_value.str[0])
2747
2775
      return(0);
2774
2802
}
2775
2803
 
2776
2804
 
2777
 
static int get_schema_tables_record(THD *thd, TableList *tables,
2778
 
                                    Table *table, bool res,
 
2805
static int get_schema_tables_record(THD *thd, TABLE_LIST *tables,
 
2806
                                    TABLE *table, bool res,
2779
2807
                                    LEX_STRING *db_name,
2780
2808
                                    LEX_STRING *table_name)
2781
2809
{
2782
2810
  const char *tmp_buff;
2783
 
  DRIZZLE_TIME time;
2784
 
  const CHARSET_INFO * const cs= system_charset_info;
 
2811
  MYSQL_TIME time;
 
2812
  CHARSET_INFO *cs= system_charset_info;
2785
2813
 
2786
2814
  restore_record(table, s->default_values);
2787
2815
  table->field[1]->store(db_name->str, db_name->length, cs);
2795
2823
    if (tables->schema_table)
2796
2824
      table->field[3]->store(STRING_WITH_LEN("SYSTEM VIEW"), cs);
2797
2825
    else
2798
 
      table->field[3]->store(STRING_WITH_LEN("BASE Table"), cs);
 
2826
      table->field[3]->store(STRING_WITH_LEN("BASE TABLE"), cs);
2799
2827
    table->field[20]->store(error, strlen(error), cs);
2800
2828
    thd->clear_error();
2801
2829
  }
2802
2830
  else
2803
2831
  {
2804
 
    char option_buff[400],*ptr;
2805
 
    Table *show_table= tables->table;
 
2832
    char option_buff[350],*ptr;
 
2833
    TABLE *show_table= tables->table;
2806
2834
    TABLE_SHARE *share= show_table->s;
2807
2835
    handler *file= show_table->file;
2808
2836
    handlerton *tmp_db_type= share->db_type();
2811
2839
    else if (share->tmp_table)
2812
2840
      table->field[3]->store(STRING_WITH_LEN("LOCAL TEMPORARY"), cs);
2813
2841
    else
2814
 
      table->field[3]->store(STRING_WITH_LEN("BASE Table"), cs);
 
2842
      table->field[3]->store(STRING_WITH_LEN("BASE TABLE"), cs);
2815
2843
 
2816
2844
    for (int i= 4; i < 20; i++)
2817
2845
    {
2821
2849
    }
2822
2850
    tmp_buff= (char *) ha_resolve_storage_engine_name(tmp_db_type);
2823
2851
    table->field[4]->store(tmp_buff, strlen(tmp_buff), cs);
2824
 
    table->field[5]->store((int64_t) share->frm_version, true);
 
2852
    table->field[5]->store((longlong) share->frm_version, TRUE);
2825
2853
 
2826
2854
    ptr=option_buff;
2827
2855
    if (share->min_rows)
2828
2856
    {
2829
 
      ptr=my_stpcpy(ptr," min_rows=");
2830
 
      ptr=int64_t10_to_str(share->min_rows,ptr,10);
 
2857
      ptr=strmov(ptr," min_rows=");
 
2858
      ptr=longlong10_to_str(share->min_rows,ptr,10);
2831
2859
    }
2832
2860
    if (share->max_rows)
2833
2861
    {
2834
 
      ptr=my_stpcpy(ptr," max_rows=");
2835
 
      ptr=int64_t10_to_str(share->max_rows,ptr,10);
 
2862
      ptr=strmov(ptr," max_rows=");
 
2863
      ptr=longlong10_to_str(share->max_rows,ptr,10);
2836
2864
    }
2837
2865
    if (share->avg_row_length)
2838
2866
    {
2839
 
      ptr=my_stpcpy(ptr," avg_row_length=");
2840
 
      ptr=int64_t10_to_str(share->avg_row_length,ptr,10);
 
2867
      ptr=strmov(ptr," avg_row_length=");
 
2868
      ptr=longlong10_to_str(share->avg_row_length,ptr,10);
2841
2869
    }
2842
2870
    if (share->db_create_options & HA_OPTION_PACK_KEYS)
2843
 
      ptr=my_stpcpy(ptr," pack_keys=1");
 
2871
      ptr=strmov(ptr," pack_keys=1");
2844
2872
    if (share->db_create_options & HA_OPTION_NO_PACK_KEYS)
2845
 
      ptr=my_stpcpy(ptr," pack_keys=0");
 
2873
      ptr=strmov(ptr," pack_keys=0");
2846
2874
    /* We use CHECKSUM, instead of TABLE_CHECKSUM, for backward compability */
2847
2875
    if (share->db_create_options & HA_OPTION_CHECKSUM)
2848
 
      ptr=my_stpcpy(ptr," checksum=1");
 
2876
      ptr=strmov(ptr," checksum=1");
2849
2877
    if (share->page_checksum != HA_CHOICE_UNDEF)
2850
2878
      ptr= strxmov(ptr, " page_checksum=",
2851
 
                   ha_choice_values[(uint) share->page_checksum], NULL);
 
2879
                   ha_choice_values[(uint) share->page_checksum], NullS);
2852
2880
    if (share->db_create_options & HA_OPTION_DELAY_KEY_WRITE)
2853
 
      ptr=my_stpcpy(ptr," delay_key_write=1");
 
2881
      ptr=strmov(ptr," delay_key_write=1");
2854
2882
    if (share->row_type != ROW_TYPE_DEFAULT)
2855
2883
      ptr=strxmov(ptr, " row_format=", 
2856
2884
                  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
 
    
 
2885
                  NullS);
2864
2886
    if (share->transactional != HA_CHOICE_UNDEF)
2865
2887
    {
2866
2888
      ptr= strxmov(ptr, " TRANSACTIONAL=",
2867
2889
                   (share->transactional == HA_CHOICE_YES ? "1" : "0"),
2868
 
                   NULL);
 
2890
                   NullS);
2869
2891
    }
2870
2892
    if (share->transactional != HA_CHOICE_UNDEF)
2871
2893
      ptr= strxmov(ptr, " transactional=",
2872
 
                   ha_choice_values[(uint) share->transactional], NULL);
 
2894
                   ha_choice_values[(uint) share->transactional], NullS);
2873
2895
    table->field[19]->store(option_buff+1,
2874
2896
                            (ptr == option_buff ? 0 : 
2875
2897
                             (uint) (ptr-option_buff)-1), cs);
2916
2938
      table->field[6]->store(tmp_buff, strlen(tmp_buff), cs);
2917
2939
      if (!tables->schema_table)
2918
2940
      {
2919
 
        table->field[7]->store((int64_t) file->stats.records, true);
 
2941
        table->field[7]->store((longlong) file->stats.records, TRUE);
2920
2942
        table->field[7]->set_notnull();
2921
2943
      }
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);
 
2944
      table->field[8]->store((longlong) file->stats.mean_rec_length, TRUE);
 
2945
      table->field[9]->store((longlong) file->stats.data_file_length, TRUE);
2924
2946
      if (file->stats.max_data_file_length)
2925
2947
      {
2926
 
        table->field[10]->store((int64_t) file->stats.max_data_file_length,
2927
 
                                true);
 
2948
        table->field[10]->store((longlong) file->stats.max_data_file_length,
 
2949
                                TRUE);
2928
2950
      }
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);
 
2951
      table->field[11]->store((longlong) file->stats.index_file_length, TRUE);
 
2952
      table->field[12]->store((longlong) file->stats.delete_length, TRUE);
2931
2953
      if (show_table->found_next_number_field)
2932
2954
      {
2933
 
        table->field[13]->store((int64_t) file->stats.auto_increment_value,
2934
 
                                true);
 
2955
        table->field[13]->store((longlong) file->stats.auto_increment_value,
 
2956
                                TRUE);
2935
2957
        table->field[13]->set_notnull();
2936
2958
      }
2937
2959
      if (file->stats.create_time)
2938
2960
      {
2939
2961
        thd->variables.time_zone->gmt_sec_to_TIME(&time,
2940
2962
                                                  (my_time_t) file->stats.create_time);
2941
 
        table->field[14]->store_time(&time, DRIZZLE_TIMESTAMP_DATETIME);
 
2963
        table->field[14]->store_time(&time, MYSQL_TIMESTAMP_DATETIME);
2942
2964
        table->field[14]->set_notnull();
2943
2965
      }
2944
2966
      if (file->stats.update_time)
2945
2967
      {
2946
2968
        thd->variables.time_zone->gmt_sec_to_TIME(&time,
2947
2969
                                                  (my_time_t) file->stats.update_time);
2948
 
        table->field[15]->store_time(&time, DRIZZLE_TIMESTAMP_DATETIME);
 
2970
        table->field[15]->store_time(&time, MYSQL_TIMESTAMP_DATETIME);
2949
2971
        table->field[15]->set_notnull();
2950
2972
      }
2951
2973
      if (file->stats.check_time)
2952
2974
      {
2953
2975
        thd->variables.time_zone->gmt_sec_to_TIME(&time,
2954
2976
                                                  (my_time_t) file->stats.check_time);
2955
 
        table->field[16]->store_time(&time, DRIZZLE_TIMESTAMP_DATETIME);
 
2977
        table->field[16]->store_time(&time, MYSQL_TIMESTAMP_DATETIME);
2956
2978
        table->field[16]->set_notnull();
2957
2979
      }
2958
2980
      if (file->ha_table_flags() & (ulong) HA_HAS_CHECKSUM)
2959
2981
      {
2960
 
        table->field[18]->store((int64_t) file->checksum(), true);
 
2982
        table->field[18]->store((longlong) file->checksum(), TRUE);
2961
2983
        table->field[18]->set_notnull();
2962
2984
      }
2963
2985
    }
2978
3000
  @return         void
2979
3001
*/
2980
3002
 
2981
 
void store_column_type(Table *table, Field *field, const CHARSET_INFO * const cs,
2982
 
                       uint32_t offset)
 
3003
void store_column_type(TABLE *table, Field *field, CHARSET_INFO *cs,
 
3004
                       uint offset)
2983
3005
{
2984
3006
  bool is_blob;
2985
3007
  int decimals, field_length;
2996
3018
  table->field[offset]->store(column_type.ptr(),
2997
3019
                         (tmp_buff ? tmp_buff - column_type.ptr() :
2998
3020
                          column_type.length()), cs);
2999
 
  is_blob= (field->type() == DRIZZLE_TYPE_BLOB);
 
3021
  is_blob= (field->type() == MYSQL_TYPE_BLOB);
3000
3022
  if (field->has_charset() || is_blob ||
3001
 
      field->real_type() == DRIZZLE_TYPE_VARCHAR)  // For varbinary type
 
3023
      field->real_type() == MYSQL_TYPE_VARCHAR ||  // For varbinary type
 
3024
      field->real_type() == MYSQL_TYPE_STRING)     // For binary type
3002
3025
  {
3003
 
    uint32_t octet_max_length= field->max_display_length();
3004
 
    if (is_blob && octet_max_length != (uint32_t) 4294967295U)
 
3026
    uint32 octet_max_length= field->max_display_length();
 
3027
    if (is_blob && octet_max_length != (uint32) 4294967295U)
3005
3028
      octet_max_length /= field->charset()->mbmaxlen;
3006
 
    int64_t char_max_len= is_blob ? 
3007
 
      (int64_t) octet_max_length / field->charset()->mbminlen :
3008
 
      (int64_t) octet_max_length / field->charset()->mbmaxlen;
 
3029
    longlong char_max_len= is_blob ? 
 
3030
      (longlong) octet_max_length / field->charset()->mbminlen :
 
3031
      (longlong) octet_max_length / field->charset()->mbmaxlen;
3009
3032
    /* CHARACTER_MAXIMUM_LENGTH column*/
3010
 
    table->field[offset + 1]->store(char_max_len, true);
 
3033
    table->field[offset + 1]->store(char_max_len, TRUE);
3011
3034
    table->field[offset + 1]->set_notnull();
3012
3035
    /* CHARACTER_OCTET_LENGTH column */
3013
 
    table->field[offset + 2]->store((int64_t) octet_max_length, true);
 
3036
    table->field[offset + 2]->store((longlong) octet_max_length, TRUE);
3014
3037
    table->field[offset + 2]->set_notnull();
3015
3038
  }
3016
3039
 
3021
3044
 
3022
3045
  decimals= field->decimals();
3023
3046
  switch (field->type()) {
3024
 
  case DRIZZLE_TYPE_NEWDECIMAL:
 
3047
  case MYSQL_TYPE_NEWDECIMAL:
3025
3048
    field_length= ((Field_new_decimal*) field)->precision;
3026
3049
    break;
3027
 
  case DRIZZLE_TYPE_TINY:
3028
 
  case DRIZZLE_TYPE_LONG:
3029
 
  case DRIZZLE_TYPE_LONGLONG:
 
3050
  case MYSQL_TYPE_TINY:
 
3051
  case MYSQL_TYPE_SHORT:
 
3052
  case MYSQL_TYPE_LONG:
 
3053
  case MYSQL_TYPE_LONGLONG:
3030
3054
    field_length= field->max_display_length() - 1;
3031
3055
    break;
3032
 
  case DRIZZLE_TYPE_DOUBLE:
 
3056
  case MYSQL_TYPE_FLOAT:  
 
3057
  case MYSQL_TYPE_DOUBLE:
3033
3058
    field_length= field->field_length;
3034
3059
    if (decimals == NOT_FIXED_DEC)
3035
3060
      decimals= -1;                           // return NULL
3042
3067
  /* NUMERIC_PRECISION column */
3043
3068
  if (field_length >= 0)
3044
3069
  {
3045
 
    table->field[offset + 3]->store((int64_t) field_length, true);
 
3070
    table->field[offset + 3]->store((longlong) field_length, TRUE);
3046
3071
    table->field[offset + 3]->set_notnull();
3047
3072
  }
3048
3073
  /* NUMERIC_SCALE column */
3049
3074
  if (decimals >= 0)
3050
3075
  {
3051
 
    table->field[offset + 4]->store((int64_t) decimals, true);
 
3076
    table->field[offset + 4]->store((longlong) decimals, TRUE);
3052
3077
    table->field[offset + 4]->set_notnull();
3053
3078
  }
3054
3079
  if (field->has_charset())
3065
3090
}
3066
3091
 
3067
3092
 
3068
 
static int get_schema_column_record(THD *thd, TableList *tables,
3069
 
                                    Table *table, bool res,
 
3093
static int get_schema_column_record(THD *thd, TABLE_LIST *tables,
 
3094
                                    TABLE *table, bool res,
3070
3095
                                    LEX_STRING *db_name,
3071
3096
                                    LEX_STRING *table_name)
3072
3097
{
3073
3098
  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;
 
3099
  const char *wild= lex->wild ? lex->wild->ptr() : NullS;
 
3100
  CHARSET_INFO *cs= system_charset_info;
 
3101
  TABLE *show_table;
3077
3102
  TABLE_SHARE *show_table_share;
3078
3103
  Field **ptr, *field, *timestamp_field;
3079
3104
  int count;
3087
3112
        rather than in SHOW COLUMNS
3088
3113
      */ 
3089
3114
      if (thd->is_error())
3090
 
        push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
3115
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
3091
3116
                     thd->main_da.sql_errno(), thd->main_da.message());
3092
3117
      thd->clear_error();
3093
3118
      res= 0;
3116
3141
    if (!show_table->read_set)
3117
3142
    {
3118
3143
      /* 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)))
 
3144
      uchar *bitmaps;
 
3145
      uint bitmap_size= show_table_share->column_bitmap_size;
 
3146
      if (!(bitmaps= (uchar*) alloc_root(thd->mem_root, bitmap_size)))
3122
3147
        return(0);
3123
3148
      bitmap_init(&show_table->def_read_set,
3124
 
                  (my_bitmap_map*) bitmaps, show_table_share->fields, false);
 
3149
                  (my_bitmap_map*) bitmaps, show_table_share->fields, FALSE);
3125
3150
      bitmap_set_all(&show_table->def_read_set);
3126
3151
      show_table->read_set= &show_table->def_read_set;
3127
3152
    }
3130
3155
 
3131
3156
  for (; (field= *ptr) ; ptr++)
3132
3157
  {
3133
 
    unsigned char *pos;
 
3158
    uchar *pos;
3134
3159
    char tmp[MAX_FIELD_WIDTH];
3135
3160
    String type(tmp,sizeof(tmp), system_charset_info);
3136
3161
    char *end;
3151
3176
    table->field[2]->store(table_name->str, table_name->length, cs);
3152
3177
    table->field[3]->store(field->field_name, strlen(field->field_name),
3153
3178
                           cs);
3154
 
    table->field[4]->store((int64_t) count, true);
 
3179
    table->field[4]->store((longlong) count, TRUE);
3155
3180
 
3156
3181
    if (get_field_default_value(thd, timestamp_field, field, &type, 0))
3157
3182
    {
3158
3183
      table->field[5]->store(type.ptr(), type.length(), cs);
3159
3184
      table->field[5]->set_notnull();
3160
3185
    }
3161
 
    pos=(unsigned char*) ((field->flags & NOT_NULL_FLAG) ?  "NO" : "YES");
 
3186
    pos=(uchar*) ((field->flags & NOT_NULL_FLAG) ?  "NO" : "YES");
3162
3187
    table->field[6]->store((const char*) pos,
3163
3188
                           strlen((const char*) pos), cs);
3164
3189
    store_column_type(table, field, cs, 7);
3165
3190
 
3166
 
    pos=(unsigned char*) ((field->flags & PRI_KEY_FLAG) ? "PRI" :
 
3191
    pos=(uchar*) ((field->flags & PRI_KEY_FLAG) ? "PRI" :
3167
3192
                 (field->flags & UNIQUE_KEY_FLAG) ? "UNI" :
3168
3193
                 (field->flags & MULTIPLE_KEY_FLAG) ? "MUL":"");
3169
3194
    table->field[15]->store((const char*) pos,
3181
3206
    {
3182
3207
      enum column_format_type column_format= (enum column_format_type)
3183
3208
        ((field->flags >> COLUMN_FORMAT_FLAGS) & COLUMN_FORMAT_MASK);
3184
 
      pos=(unsigned char*)"Default";
 
3209
      pos=(uchar*)"Default";
3185
3210
      table->field[19]->store((const char*) pos,
3186
3211
                              strlen((const char*) pos), cs);
3187
 
      pos=(unsigned char*)(column_format == COLUMN_FORMAT_TYPE_DEFAULT ? "Default" :
 
3212
      pos=(uchar*)(column_format == COLUMN_FORMAT_TYPE_DEFAULT ? "Default" :
3188
3213
                   column_format == COLUMN_FORMAT_TYPE_FIXED ? "Fixed" :
3189
3214
                                                             "Dynamic");
3190
3215
      table->field[20]->store((const char*) pos,
3198
3223
 
3199
3224
 
3200
3225
 
3201
 
int fill_schema_charsets(THD *thd, TableList *tables, COND *cond __attribute__((unused)))
 
3226
int fill_schema_charsets(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((__unused__)))
3202
3227
{
3203
3228
  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;
 
3229
  const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS;
 
3230
  TABLE *table= tables->table;
 
3231
  CHARSET_INFO *scs= system_charset_info;
3207
3232
 
3208
3233
  for (cs= all_charsets ; cs < all_charsets+255 ; cs++)
3209
3234
  {
3210
 
    const CHARSET_INFO * const tmp_cs= cs[0];
 
3235
    CHARSET_INFO *tmp_cs= cs[0];
3211
3236
    if (tmp_cs && (tmp_cs->state & MY_CS_PRIMARY) && 
3212
3237
        (tmp_cs->state & MY_CS_AVAILABLE) &&
3213
3238
        !(tmp_cs->state & MY_CS_HIDDEN) &&
3214
3239
        !(wild && wild[0] &&
3215
 
          wild_case_compare(scs, tmp_cs->csname,wild)))
 
3240
          wild_case_compare(scs, tmp_cs->csname,wild)))
3216
3241
    {
3217
3242
      const char *comment;
3218
3243
      restore_record(table, s->default_values);
3220
3245
      table->field[1]->store(tmp_cs->name, strlen(tmp_cs->name), scs);
3221
3246
      comment= tmp_cs->comment ? tmp_cs->comment : "";
3222
3247
      table->field[2]->store(comment, strlen(comment), scs);
3223
 
      table->field[3]->store((int64_t) tmp_cs->mbmaxlen, true);
 
3248
      table->field[3]->store((longlong) tmp_cs->mbmaxlen, TRUE);
3224
3249
      if (schema_table_store_record(thd, table))
3225
3250
        return 1;
3226
3251
    }
3229
3254
}
3230
3255
 
3231
3256
 
3232
 
int fill_schema_collation(THD *thd, TableList *tables, COND *cond __attribute__((unused)))
 
3257
int fill_schema_collation(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((__unused__)))
3233
3258
{
3234
3259
  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;
 
3260
  const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS;
 
3261
  TABLE *table= tables->table;
 
3262
  CHARSET_INFO *scs= system_charset_info;
3238
3263
  for (cs= all_charsets ; cs < all_charsets+255 ; cs++ )
3239
3264
  {
3240
3265
    CHARSET_INFO **cl;
3241
 
    const CHARSET_INFO *tmp_cs= cs[0];
 
3266
    CHARSET_INFO *tmp_cs= cs[0];
3242
3267
    if (!tmp_cs || !(tmp_cs->state & MY_CS_AVAILABLE) ||
3243
3268
         (tmp_cs->state & MY_CS_HIDDEN) ||
3244
3269
        !(tmp_cs->state & MY_CS_PRIMARY))
3245
3270
      continue;
3246
3271
    for (cl= all_charsets; cl < all_charsets+255 ;cl ++)
3247
3272
    {
3248
 
      const CHARSET_INFO *tmp_cl= cl[0];
 
3273
      CHARSET_INFO *tmp_cl= cl[0];
3249
3274
      if (!tmp_cl || !(tmp_cl->state & MY_CS_AVAILABLE) || 
3250
3275
          !my_charset_same(tmp_cs, tmp_cl))
3251
 
        continue;
 
3276
        continue;
3252
3277
      if (!(wild && wild[0] &&
3253
 
          wild_case_compare(scs, tmp_cl->name,wild)))
 
3278
          wild_case_compare(scs, tmp_cl->name,wild)))
3254
3279
      {
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);
 
3280
        const char *tmp_buff;
 
3281
        restore_record(table, s->default_values);
 
3282
        table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs);
3258
3283
        table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs);
3259
 
        table->field[2]->store((int64_t) tmp_cl->number, true);
 
3284
        table->field[2]->store((longlong) tmp_cl->number, TRUE);
3260
3285
        tmp_buff= (tmp_cl->state & MY_CS_PRIMARY) ? "Yes" : "";
3261
 
        table->field[3]->store(tmp_buff, strlen(tmp_buff), scs);
 
3286
        table->field[3]->store(tmp_buff, strlen(tmp_buff), scs);
3262
3287
        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);
 
3288
        table->field[4]->store(tmp_buff, strlen(tmp_buff), scs);
 
3289
        table->field[5]->store((longlong) tmp_cl->strxfrm_multiply, TRUE);
3265
3290
        if (schema_table_store_record(thd, table))
3266
3291
          return 1;
3267
3292
      }
3271
3296
}
3272
3297
 
3273
3298
 
3274
 
int fill_schema_coll_charset_app(THD *thd, TableList *tables, COND *cond __attribute__((unused)))
 
3299
int fill_schema_coll_charset_app(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((__unused__)))
3275
3300
{
3276
3301
  CHARSET_INFO **cs;
3277
 
  Table *table= tables->table;
3278
 
  const CHARSET_INFO * const scs= system_charset_info;
 
3302
  TABLE *table= tables->table;
 
3303
  CHARSET_INFO *scs= system_charset_info;
3279
3304
  for (cs= all_charsets ; cs < all_charsets+255 ; cs++ )
3280
3305
  {
3281
3306
    CHARSET_INFO **cl;
3282
 
    const CHARSET_INFO *tmp_cs= cs[0];
 
3307
    CHARSET_INFO *tmp_cs= cs[0];
3283
3308
    if (!tmp_cs || !(tmp_cs->state & MY_CS_AVAILABLE) || 
3284
3309
        !(tmp_cs->state & MY_CS_PRIMARY))
3285
3310
      continue;
3286
3311
    for (cl= all_charsets; cl < all_charsets+255 ;cl ++)
3287
3312
    {
3288
 
      const CHARSET_INFO *tmp_cl= cl[0];
 
3313
      CHARSET_INFO *tmp_cl= cl[0];
3289
3314
      if (!tmp_cl || !(tmp_cl->state & MY_CS_AVAILABLE) || 
3290
3315
          !my_charset_same(tmp_cs,tmp_cl))
3291
3316
        continue;
3300
3325
}
3301
3326
 
3302
3327
 
3303
 
static int get_schema_stat_record(THD *thd, TableList *tables,
3304
 
                                  Table *table, bool res,
 
3328
static int get_schema_stat_record(THD *thd, TABLE_LIST *tables,
 
3329
                                  TABLE *table, bool res,
3305
3330
                                  LEX_STRING *db_name,
3306
3331
                                  LEX_STRING *table_name)
3307
3332
{
3308
 
  const CHARSET_INFO * const cs= system_charset_info;
 
3333
  CHARSET_INFO *cs= system_charset_info;
3309
3334
  if (res)
3310
3335
  {
3311
3336
    if (thd->lex->sql_command != SQLCOM_SHOW_KEYS)
3315
3340
        rather than in SHOW KEYS
3316
3341
      */
3317
3342
      if (thd->is_error())
3318
 
        push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
3343
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
3319
3344
                     thd->main_da.sql_errno(), thd->main_da.message());
3320
3345
      thd->clear_error();
3321
3346
      res= 0;
3324
3349
  }
3325
3350
  else
3326
3351
  {
3327
 
    Table *show_table= tables->table;
 
3352
    TABLE *show_table= tables->table;
3328
3353
    KEY *key_info=show_table->s->key_info;
3329
3354
    if (show_table->file)
3330
3355
      show_table->file->info(HA_STATUS_VARIABLE |
3331
3356
                             HA_STATUS_NO_LOCK |
3332
3357
                             HA_STATUS_TIME);
3333
 
    for (uint32_t i=0 ; i < show_table->s->keys ; i++,key_info++)
 
3358
    for (uint i=0 ; i < show_table->s->keys ; i++,key_info++)
3334
3359
    {
3335
3360
      KEY_PART_INFO *key_part= key_info->key_part;
3336
3361
      const char *str;
3337
 
      for (uint32_t j=0 ; j < key_info->key_parts ; j++,key_part++)
 
3362
      for (uint j=0 ; j < key_info->key_parts ; j++,key_part++)
3338
3363
      {
3339
3364
        restore_record(table, s->default_values);
3340
3365
        table->field[1]->store(db_name->str, db_name->length, cs);
3341
3366
        table->field[2]->store(table_name->str, table_name->length, cs);
3342
 
        table->field[3]->store((int64_t) ((key_info->flags &
3343
 
                                            HA_NOSAME) ? 0 : 1), true);
 
3367
        table->field[3]->store((longlong) ((key_info->flags &
 
3368
                                            HA_NOSAME) ? 0 : 1), TRUE);
3344
3369
        table->field[4]->store(db_name->str, db_name->length, cs);
3345
3370
        table->field[5]->store(key_info->name, strlen(key_info->name), cs);
3346
 
        table->field[6]->store((int64_t) (j+1), true);
 
3371
        table->field[6]->store((longlong) (j+1), TRUE);
3347
3372
        str=(key_part->field ? key_part->field->field_name :
3348
3373
             "?unknown field?");
3349
3374
        table->field[7]->store(str, strlen(str), cs);
3361
3386
          {
3362
3387
            ha_rows records=(show_table->file->stats.records /
3363
3388
                             key->rec_per_key[j]);
3364
 
            table->field[9]->store((int64_t) records, true);
 
3389
            table->field[9]->store((longlong) records, TRUE);
3365
3390
            table->field[9]->set_notnull();
3366
3391
          }
3367
3392
          str= show_table->file->index_type(i);
3371
3396
             key_part->length !=
3372
3397
             show_table->s->field[key_part->fieldnr-1]->key_length()))
3373
3398
        {
3374
 
          table->field[10]->store((int64_t) key_part->length /
3375
 
                                  key_part->field->charset()->mbmaxlen, true);
 
3399
          table->field[10]->store((longlong) key_part->length /
 
3400
                                  key_part->field->charset()->mbmaxlen, TRUE);
3376
3401
          table->field[10]->set_notnull();
3377
3402
        }
3378
 
        uint32_t flags= key_part->field ? key_part->field->flags : 0;
 
3403
        uint flags= key_part->field ? key_part->field->flags : 0;
3379
3404
        const char *pos=(char*) ((flags & NOT_NULL_FLAG) ? "" : "YES");
3380
3405
        table->field[12]->store(pos, strlen(pos), cs);
3381
3406
        if (!show_table->s->keys_in_use.is_set(i))
3397
3422
}
3398
3423
 
3399
3424
 
3400
 
bool store_constraints(THD *thd, Table *table, LEX_STRING *db_name,
 
3425
bool store_constraints(THD *thd, TABLE *table, LEX_STRING *db_name,
3401
3426
                       LEX_STRING *table_name, const char *key_name,
3402
 
                       uint32_t key_len, const char *con_type, uint32_t con_len)
 
3427
                       uint key_len, const char *con_type, uint con_len)
3403
3428
{
3404
 
  const CHARSET_INFO * const cs= system_charset_info;
 
3429
  CHARSET_INFO *cs= system_charset_info;
3405
3430
  restore_record(table, s->default_values);
3406
3431
  table->field[1]->store(db_name->str, db_name->length, cs);
3407
3432
  table->field[2]->store(key_name, key_len, cs);
3412
3437
}
3413
3438
 
3414
3439
 
3415
 
static int get_schema_constraints_record(THD *thd, TableList *tables,
3416
 
                                         Table *table, bool res,
 
3440
static int get_schema_constraints_record(THD *thd, TABLE_LIST *tables,
 
3441
                                         TABLE *table, bool res,
3417
3442
                                         LEX_STRING *db_name,
3418
3443
                                         LEX_STRING *table_name)
3419
3444
{
3420
3445
  if (res)
3421
3446
  {
3422
3447
    if (thd->is_error())
3423
 
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
3448
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
3424
3449
                   thd->main_da.sql_errno(), thd->main_da.message());
3425
3450
    thd->clear_error();
3426
3451
    return(0);
3428
3453
  else
3429
3454
  {
3430
3455
    List<FOREIGN_KEY_INFO> f_key_list;
3431
 
    Table *show_table= tables->table;
 
3456
    TABLE *show_table= tables->table;
3432
3457
    KEY *key_info=show_table->key_info;
3433
 
    uint32_t primary_key= show_table->s->primary_key;
 
3458
    uint primary_key= show_table->s->primary_key;
3434
3459
    show_table->file->info(HA_STATUS_VARIABLE | 
3435
3460
                           HA_STATUS_NO_LOCK |
3436
3461
                           HA_STATUS_TIME);
3437
 
    for (uint32_t i=0 ; i < show_table->s->keys ; i++, key_info++)
 
3462
    for (uint i=0 ; i < show_table->s->keys ; i++, key_info++)
3438
3463
    {
3439
3464
      if (i != primary_key && !(key_info->flags & HA_NOSAME))
3440
3465
        continue;
3471
3496
}
3472
3497
 
3473
3498
 
3474
 
void store_key_column_usage(Table *table, LEX_STRING *db_name,
 
3499
void store_key_column_usage(TABLE *table, LEX_STRING *db_name,
3475
3500
                            LEX_STRING *table_name, const char *key_name,
3476
 
                            uint32_t key_len, const char *con_type, uint32_t con_len,
3477
 
                            int64_t idx)
 
3501
                            uint key_len, const char *con_type, uint con_len,
 
3502
                            longlong idx)
3478
3503
{
3479
 
  const CHARSET_INFO * const cs= system_charset_info;
 
3504
  CHARSET_INFO *cs= system_charset_info;
3480
3505
  table->field[1]->store(db_name->str, db_name->length, cs);
3481
3506
  table->field[2]->store(key_name, key_len, cs);
3482
3507
  table->field[4]->store(db_name->str, db_name->length, cs);
3483
3508
  table->field[5]->store(table_name->str, table_name->length, cs);
3484
3509
  table->field[6]->store(con_type, con_len, cs);
3485
 
  table->field[7]->store((int64_t) idx, true);
 
3510
  table->field[7]->store((longlong) idx, TRUE);
3486
3511
}
3487
3512
 
3488
3513
 
3489
3514
static int get_schema_key_column_usage_record(THD *thd,
3490
 
                                              TableList *tables,
3491
 
                                              Table *table, bool res,
 
3515
                                              TABLE_LIST *tables,
 
3516
                                              TABLE *table, bool res,
3492
3517
                                              LEX_STRING *db_name,
3493
3518
                                              LEX_STRING *table_name)
3494
3519
{
3495
3520
  if (res)
3496
3521
  {
3497
3522
    if (thd->is_error())
3498
 
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
3523
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
3499
3524
                   thd->main_da.sql_errno(), thd->main_da.message());
3500
3525
    thd->clear_error();
3501
3526
    return(0);
3503
3528
  else
3504
3529
  {
3505
3530
    List<FOREIGN_KEY_INFO> f_key_list;
3506
 
    Table *show_table= tables->table;
 
3531
    TABLE *show_table= tables->table;
3507
3532
    KEY *key_info=show_table->key_info;
3508
 
    uint32_t primary_key= show_table->s->primary_key;
 
3533
    uint primary_key= show_table->s->primary_key;
3509
3534
    show_table->file->info(HA_STATUS_VARIABLE | 
3510
3535
                           HA_STATUS_NO_LOCK |
3511
3536
                           HA_STATUS_TIME);
3512
 
    for (uint32_t i=0 ; i < show_table->s->keys ; i++, key_info++)
 
3537
    for (uint i=0 ; i < show_table->s->keys ; i++, key_info++)
3513
3538
    {
3514
3539
      if (i != primary_key && !(key_info->flags & HA_NOSAME))
3515
3540
        continue;
3516
 
      uint32_t f_idx= 0;
 
3541
      uint f_idx= 0;
3517
3542
      KEY_PART_INFO *key_part= key_info->key_part;
3518
 
      for (uint32_t j=0 ; j < key_info->key_parts ; j++,key_part++)
 
3543
      for (uint j=0 ; j < key_info->key_parts ; j++,key_part++)
3519
3544
      {
3520
3545
        if (key_part->field)
3521
3546
        {
3526
3551
                                 strlen(key_info->name), 
3527
3552
                                 key_part->field->field_name, 
3528
3553
                                 strlen(key_part->field->field_name),
3529
 
                                 (int64_t) f_idx);
 
3554
                                 (longlong) f_idx);
3530
3555
          if (schema_table_store_record(thd, table))
3531
3556
            return(1);
3532
3557
        }
3542
3567
      LEX_STRING *r_info;
3543
3568
      List_iterator_fast<LEX_STRING> it(f_key_info->foreign_fields),
3544
3569
        it1(f_key_info->referenced_fields);
3545
 
      uint32_t f_idx= 0;
 
3570
      uint f_idx= 0;
3546
3571
      while ((f_info= it++))
3547
3572
      {
3548
3573
        r_info= it1++;
3552
3577
                               f_key_info->forein_id->str,
3553
3578
                               f_key_info->forein_id->length,
3554
3579
                               f_info->str, f_info->length,
3555
 
                               (int64_t) f_idx);
3556
 
        table->field[8]->store((int64_t) f_idx, true);
 
3580
                               (longlong) f_idx);
 
3581
        table->field[8]->store((longlong) f_idx, TRUE);
3557
3582
        table->field[8]->set_notnull();
3558
3583
        table->field[9]->store(f_key_info->referenced_db->str,
3559
3584
                               f_key_info->referenced_db->length,
3575
3600
}
3576
3601
 
3577
3602
 
3578
 
int fill_open_tables(THD *thd, TableList *tables, COND *cond __attribute__((unused)))
 
3603
int fill_open_tables(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((__unused__)))
3579
3604
{
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;
 
3605
  const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS;
 
3606
  TABLE *table= tables->table;
 
3607
  CHARSET_INFO *cs= system_charset_info;
 
3608
  OPEN_TABLE_LIST *open_list;
3584
3609
  if (!(open_list=list_open_tables(thd,thd->lex->select_lex.db, wild))
3585
3610
            && thd->is_fatal_error)
3586
3611
    return(1);
3590
3615
    restore_record(table, s->default_values);
3591
3616
    table->field[0]->store(open_list->db, strlen(open_list->db), cs);
3592
3617
    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);
 
3618
    table->field[2]->store((longlong) open_list->in_use, TRUE);
 
3619
    table->field[3]->store((longlong) open_list->locked, TRUE);
3595
3620
    if (schema_table_store_record(thd, table))
3596
3621
      return(1);
3597
3622
  }
3599
3624
}
3600
3625
 
3601
3626
 
3602
 
int fill_variables(THD *thd, TableList *tables, COND *cond __attribute__((unused)))
 
3627
int fill_variables(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((__unused__)))
3603
3628
{
3604
3629
  int res= 0;
3605
3630
  LEX *lex= thd->lex;
3606
 
  const char *wild= lex->wild ? lex->wild->ptr() : NULL;
 
3631
  const char *wild= lex->wild ? lex->wild->ptr() : NullS;
3607
3632
  enum enum_schema_tables schema_table_idx=
3608
3633
    get_schema_table_idx(tables->schema_table);
3609
3634
  enum enum_var_type option_type= OPT_SESSION;
3622
3647
}
3623
3648
 
3624
3649
 
3625
 
int fill_status(THD *thd, TableList *tables, COND *cond __attribute__((unused)))
 
3650
int fill_status(THD *thd, TABLE_LIST *tables, COND *cond __attribute__((__unused__)))
3626
3651
{
3627
3652
  LEX *lex= thd->lex;
3628
 
  const char *wild= lex->wild ? lex->wild->ptr() : NULL;
 
3653
  const char *wild= lex->wild ? lex->wild->ptr() : NullS;
3629
3654
  int res= 0;
3630
3655
  STATUS_VAR *tmp1, tmp;
3631
3656
  enum enum_schema_tables schema_table_idx=
3683
3708
*/
3684
3709
 
3685
3710
static int
3686
 
get_referential_constraints_record(THD *thd, TableList *tables,
3687
 
                                   Table *table, bool res,
 
3711
get_referential_constraints_record(THD *thd, TABLE_LIST *tables,
 
3712
                                   TABLE *table, bool res,
3688
3713
                                   LEX_STRING *db_name, LEX_STRING *table_name)
3689
3714
{
3690
 
  const CHARSET_INFO * const cs= system_charset_info;
 
3715
  CHARSET_INFO *cs= system_charset_info;
3691
3716
 
3692
3717
  if (res)
3693
3718
  {
3694
3719
    if (thd->is_error())
3695
 
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
3720
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
3696
3721
                   thd->main_da.sql_errno(), thd->main_da.message());
3697
3722
    thd->clear_error();
3698
3723
    return(0);
3700
3725
 
3701
3726
  {
3702
3727
    List<FOREIGN_KEY_INFO> f_key_list;
3703
 
    Table *show_table= tables->table;
 
3728
    TABLE *show_table= tables->table;
3704
3729
    show_table->file->info(HA_STATUS_VARIABLE | 
3705
3730
                           HA_STATUS_NO_LOCK |
3706
3731
                           HA_STATUS_TIME);
3760
3785
    0   table not found
3761
3786
    1   found the schema table
3762
3787
*/
3763
 
static bool find_schema_table_in_plugin(THD *thd __attribute__((unused)),
 
3788
static my_bool find_schema_table_in_plugin(THD *thd __attribute__((__unused__)),
3764
3789
                                           plugin_ref plugin,
3765
3790
                                           void* p_table)
3766
3791
{
3807
3832
 
3808
3833
  schema_table_a.table_name= table_name;
3809
3834
  if (plugin_foreach(thd, find_schema_table_in_plugin, 
3810
 
                     DRIZZLE_INFORMATION_SCHEMA_PLUGIN, &schema_table_a))
 
3835
                     MYSQL_INFORMATION_SCHEMA_PLUGIN, &schema_table_a))
3811
3836
    return(schema_table_a.schema_table);
3812
3837
 
3813
3838
  return(NULL);
3835
3860
  @retval  NULL           Can't create table
3836
3861
*/
3837
3862
 
3838
 
Table *create_schema_table(THD *thd, TableList *table_list)
 
3863
TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
3839
3864
{
3840
3865
  int field_count= 0;
3841
3866
  Item *item;
3842
 
  Table *table;
 
3867
  TABLE *table;
3843
3868
  List<Item> field_list;
3844
3869
  ST_SCHEMA_TABLE *schema_table= table_list->schema_table;
3845
3870
  ST_FIELD_INFO *fields_info= schema_table->fields_info;
3846
 
  const CHARSET_INFO * const cs= system_charset_info;
 
3871
  CHARSET_INFO *cs= system_charset_info;
3847
3872
 
3848
3873
  for (; fields_info->field_name; fields_info++)
3849
3874
  {
3850
3875
    switch (fields_info->field_type) {
3851
 
    case DRIZZLE_TYPE_TINY:
3852
 
    case DRIZZLE_TYPE_LONG:
3853
 
    case DRIZZLE_TYPE_LONGLONG:
 
3876
    case MYSQL_TYPE_TINY:
 
3877
    case MYSQL_TYPE_LONG:
 
3878
    case MYSQL_TYPE_SHORT:
 
3879
    case MYSQL_TYPE_LONGLONG:
3854
3880
      if (!(item= new Item_return_int(fields_info->field_name,
3855
3881
                                      fields_info->field_length,
3856
3882
                                      fields_info->field_type,
3860
3886
      }
3861
3887
      item->unsigned_flag= (fields_info->field_flags & MY_I_S_UNSIGNED);
3862
3888
      break;
3863
 
    case DRIZZLE_TYPE_NEWDATE:
3864
 
    case DRIZZLE_TYPE_TIME:
3865
 
    case DRIZZLE_TYPE_TIMESTAMP:
3866
 
    case DRIZZLE_TYPE_DATETIME:
 
3889
    case MYSQL_TYPE_NEWDATE:
 
3890
    case MYSQL_TYPE_TIME:
 
3891
    case MYSQL_TYPE_TIMESTAMP:
 
3892
    case MYSQL_TYPE_DATETIME:
3867
3893
      if (!(item=new Item_return_date_time(fields_info->field_name,
3868
3894
                                           fields_info->field_type)))
3869
3895
      {
3870
3896
        return(0);
3871
3897
      }
3872
3898
      break;
3873
 
    case DRIZZLE_TYPE_DOUBLE:
 
3899
    case MYSQL_TYPE_FLOAT:
 
3900
    case MYSQL_TYPE_DOUBLE:
3874
3901
      if ((item= new Item_float(fields_info->field_name, 0.0, NOT_FIXED_DEC, 
3875
3902
                           fields_info->field_length)) == NULL)
3876
3903
        return(NULL);
3877
3904
      break;
3878
 
    case DRIZZLE_TYPE_NEWDECIMAL:
3879
 
      if (!(item= new Item_decimal((int64_t) fields_info->value, false)))
 
3905
    case MYSQL_TYPE_NEWDECIMAL:
 
3906
      if (!(item= new Item_decimal((longlong) fields_info->value, false)))
3880
3907
      {
3881
3908
        return(0);
3882
3909
      }
3890
3917
      item->set_name(fields_info->field_name,
3891
3918
                     strlen(fields_info->field_name), cs);
3892
3919
      break;
3893
 
    case DRIZZLE_TYPE_BLOB:
 
3920
    case MYSQL_TYPE_BLOB:
3894
3921
      if (!(item= new Item_blob(fields_info->field_name,
3895
3922
                                fields_info->field_length)))
3896
3923
      {
3898
3925
      }
3899
3926
      break;
3900
3927
    default:
 
3928
      /* Don't let unimplemented types pass through. Could be a grave error. */
 
3929
      assert(fields_info->field_type == MYSQL_TYPE_STRING);
 
3930
 
3901
3931
      if (!(item= new Item_empty_string("", fields_info->field_length, cs)))
3902
3932
      {
3903
3933
        return(0);
3918
3948
  tmp_table_param->schema_table= 1;
3919
3949
  SELECT_LEX *select_lex= thd->lex->current_select;
3920
3950
  if (!(table= create_tmp_table(thd, tmp_table_param,
3921
 
                                field_list, (order_st*) 0, 0, 0, 
 
3951
                                field_list, (ORDER*) 0, 0, 0, 
3922
3952
                                (select_lex->options | thd->options |
3923
3953
                                 TMP_TABLE_ALL_COLUMNS),
3924
3954
                                HA_POS_ERROR, table_list->alias)))
3926
3956
  my_bitmap_map* bitmaps=
3927
3957
    (my_bitmap_map*) thd->alloc(bitmap_buffer_size(field_count));
3928
3958
  bitmap_init(&table->def_read_set, (my_bitmap_map*) bitmaps, field_count,
3929
 
              false);
 
3959
              FALSE);
3930
3960
  table->read_set= &table->def_read_set;
3931
3961
  bitmap_clear_all(table->read_set);
3932
3962
  table_list->schema_table_param= tmp_table_param;
3958
3988
    if (field_info->old_name)
3959
3989
    {
3960
3990
      Item_field *field= new Item_field(context,
3961
 
                                        NULL, NULL, field_info->field_name);
 
3991
                                        NullS, NullS, field_info->field_name);
3962
3992
      if (field)
3963
3993
      {
3964
3994
        field->set_name(field_info->old_name,
3985
4015
    ST_FIELD_INFO *field_info= &schema_table->fields_info[1];
3986
4016
    String buffer(tmp,sizeof(tmp), system_charset_info);
3987
4017
    Item_field *field= new Item_field(context,
3988
 
                                      NULL, NULL, field_info->field_name);
 
4018
                                      NullS, NullS, field_info->field_name);
3989
4019
    if (!field || add_item_to_list(thd, field))
3990
4020
      return 1;
3991
4021
    buffer.length(0);
4020
4050
    buffer.append(')');
4021
4051
  }
4022
4052
  Item_field *field= new Item_field(context,
4023
 
                                    NULL, NULL, field_info->field_name);
 
4053
                                    NullS, NullS, field_info->field_name);
4024
4054
  if (add_item_to_list(thd, field))
4025
4055
    return 1;
4026
4056
  field->set_name(buffer.ptr(), buffer.length(), system_charset_info);
4028
4058
  {
4029
4059
    field->set_name(buffer.ptr(), buffer.length(), system_charset_info);
4030
4060
    field_info= &schema_table->fields_info[3];
4031
 
    field= new Item_field(context, NULL, NULL, field_info->field_name);
 
4061
    field= new Item_field(context, NullS, NullS, field_info->field_name);
4032
4062
    if (add_item_to_list(thd, field))
4033
4063
      return 1;
4034
4064
    field->set_name(field_info->old_name, strlen(field_info->old_name),
4053
4083
                               *field_num == 18))
4054
4084
      continue;
4055
4085
    Item_field *field= new Item_field(context,
4056
 
                                      NULL, NULL, field_info->field_name);
 
4086
                                      NullS, NullS, field_info->field_name);
4057
4087
    if (field)
4058
4088
    {
4059
4089
      field->set_name(field_info->old_name,
4078
4108
  {
4079
4109
    field_info= &schema_table->fields_info[*field_num];
4080
4110
    Item_field *field= new Item_field(context,
4081
 
                                      NULL, NULL, field_info->field_name);
 
4111
                                      NullS, NullS, field_info->field_name);
4082
4112
    if (field)
4083
4113
    {
4084
4114
      field->set_name(field_info->old_name,
4106
4136
    1   error
4107
4137
*/
4108
4138
 
4109
 
int mysql_schema_table(THD *thd, LEX *lex, TableList *table_list)
 
4139
int mysql_schema_table(THD *thd, LEX *lex, TABLE_LIST *table_list)
4110
4140
{
4111
 
  Table *table;
 
4141
  TABLE *table;
4112
4142
  if (!(table= table_list->schema_table->create_table(thd, table_list)))
4113
4143
    return(1);
4114
4144
  table->s->tmp_table= SYSTEM_TMP_TABLE;
4149
4179
    }
4150
4180
    List_iterator_fast<Item> it(sel->item_list);
4151
4181
    if (!(transl=
4152
 
          (Field_translator*)(thd->alloc(sel->item_list.elements *
 
4182
          (Field_translator*)(thd->stmt_arena->
 
4183
                              alloc(sel->item_list.elements *
4153
4184
                                    sizeof(Field_translator)))))
4154
4185
    {
4155
4186
      return(1);
4217
4248
    executed_place place where I_S table processed
4218
4249
 
4219
4250
  RETURN
4220
 
    false success
4221
 
    true  error
 
4251
    FALSE success
 
4252
    TRUE  error
4222
4253
*/
4223
4254
 
4224
4255
bool get_schema_tables_result(JOIN *join,
4235
4266
    if (!tab->table || !tab->table->pos_in_table_list)
4236
4267
      break;
4237
4268
 
4238
 
    TableList *table_list= tab->table->pos_in_table_list;
 
4269
    TABLE_LIST *table_list= tab->table->pos_in_table_list;
4239
4270
    if (table_list->schema_table)
4240
4271
    {
4241
4272
      bool is_subselect= (&lex->unit != lex->current_select->master_unit() &&
4296
4327
 
4297
4328
ST_FIELD_INFO schema_fields_info[]=
4298
4329
{
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}
 
4330
  {"CATALOG_NAME", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4331
  {"SCHEMA_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Database",
 
4332
   SKIP_OPEN_TABLE},
 
4333
  {"DEFAULT_CHARACTER_SET_NAME", 64, MYSQL_TYPE_STRING, 0, 0, 0,
 
4334
   SKIP_OPEN_TABLE},
 
4335
  {"DEFAULT_COLLATION_NAME", 64, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4336
  {"SQL_PATH", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4337
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4307
4338
};
4308
4339
 
4309
4340
 
4310
4341
ST_FIELD_INFO tables_fields_info[]=
4311
4342
{
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",
 
4343
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4344
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4345
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Name",
4315
4346
   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,
 
4347
  {"TABLE_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FRM_ONLY},
 
4348
  {"ENGINE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, "Engine", OPEN_FRM_ONLY},
 
4349
  {"VERSION", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0,
4319
4350
   (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,
 
4351
  {"ROW_FORMAT", 10, MYSQL_TYPE_STRING, 0, 1, "Row_format", OPEN_FULL_TABLE},
 
4352
  {"TABLE_ROWS", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0,
4322
4353
   (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, 
 
4354
  {"AVG_ROW_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0, 
4324
4355
   (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, 
 
4356
  {"DATA_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0, 
4326
4357
   (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,
 
4358
  {"MAX_DATA_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0,
4328
4359
   (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, 
 
4360
  {"INDEX_LENGTH", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0, 
4330
4361
   (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,
 
4362
  {"DATA_FREE", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0,
4332
4363
   (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, 
 
4364
  {"AUTO_INCREMENT", MY_INT64_NUM_DECIMAL_DIGITS , MYSQL_TYPE_LONGLONG, 0, 
4334
4365
   (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,
 
4366
  {"CREATE_TIME", 0, MYSQL_TYPE_DATETIME, 0, 1, "Create_time", OPEN_FULL_TABLE},
 
4367
  {"UPDATE_TIME", 0, MYSQL_TYPE_DATETIME, 0, 1, "Update_time", OPEN_FULL_TABLE},
 
4368
  {"CHECK_TIME", 0, MYSQL_TYPE_DATETIME, 0, 1, "Check_time", OPEN_FULL_TABLE},
 
4369
  {"TABLE_COLLATION", 64, MYSQL_TYPE_STRING, 0, 1, "Collation", OPEN_FRM_ONLY},
 
4370
  {"CHECKSUM", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0,
4340
4371
   (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), "Checksum", OPEN_FULL_TABLE},
4341
 
  {"CREATE_OPTIONS", 255, DRIZZLE_TYPE_VARCHAR, 0, 1, "Create_options",
 
4372
  {"CREATE_OPTIONS", 255, MYSQL_TYPE_STRING, 0, 1, "Create_options",
4342
4373
   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}
 
4374
  {"TABLE_COMMENT", TABLE_COMMENT_MAXLEN, MYSQL_TYPE_STRING, 0, 0, "Comment", OPEN_FRM_ONLY},
 
4375
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4345
4376
};
4346
4377
 
4347
4378
 
4348
4379
ST_FIELD_INFO columns_fields_info[]=
4349
4380
{
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",
 
4381
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FRM_ONLY},
 
4382
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FRM_ONLY},
 
4383
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FRM_ONLY},
 
4384
  {"COLUMN_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Field",
4354
4385
   OPEN_FRM_ONLY},
4355
 
  {"ORDINAL_POSITION", MY_INT64_NUM_DECIMAL_DIGITS, DRIZZLE_TYPE_LONGLONG, 0,
 
4386
  {"ORDINAL_POSITION", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0,
4356
4387
   MY_I_S_UNSIGNED, 0, OPEN_FRM_ONLY},
4357
 
  {"COLUMN_DEFAULT", MAX_FIELD_VARCHARLENGTH, DRIZZLE_TYPE_VARCHAR, 0,
 
4388
  {"COLUMN_DEFAULT", MAX_FIELD_VARCHARLENGTH, MYSQL_TYPE_STRING, 0,
4358
4389
   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}
 
4390
  {"IS_NULLABLE", 3, MYSQL_TYPE_STRING, 0, 0, "Null", OPEN_FRM_ONLY},
 
4391
  {"DATA_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FRM_ONLY},
 
4392
  {"CHARACTER_MAXIMUM_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
  {"CHARACTER_OCTET_LENGTH", 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_PRECISION", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG,
 
4397
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
 
4398
  {"NUMERIC_SCALE", MY_INT64_NUM_DECIMAL_DIGITS , MYSQL_TYPE_LONGLONG,
 
4399
   0, (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FRM_ONLY},
 
4400
  {"CHARACTER_SET_NAME", 64, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FRM_ONLY},
 
4401
  {"COLLATION_NAME", 64, MYSQL_TYPE_STRING, 0, 1, "Collation", OPEN_FRM_ONLY},
 
4402
  {"COLUMN_TYPE", 65535, MYSQL_TYPE_STRING, 0, 0, "Type", OPEN_FRM_ONLY},
 
4403
  {"COLUMN_KEY", 3, MYSQL_TYPE_STRING, 0, 0, "Key", OPEN_FRM_ONLY},
 
4404
  {"EXTRA", 27, MYSQL_TYPE_STRING, 0, 0, "Extra", OPEN_FRM_ONLY},
 
4405
  {"PRIVILEGES", 80, MYSQL_TYPE_STRING, 0, 0, "Privileges", OPEN_FRM_ONLY},
 
4406
  {"COLUMN_COMMENT", COLUMN_COMMENT_MAXLEN, MYSQL_TYPE_STRING, 0, 0, "Comment", OPEN_FRM_ONLY},
 
4407
  {"STORAGE", 8, MYSQL_TYPE_STRING, 0, 0, "Storage", OPEN_FRM_ONLY},
 
4408
  {"FORMAT", 8, MYSQL_TYPE_STRING, 0, 0, "Format", OPEN_FRM_ONLY},
 
4409
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4379
4410
};
4380
4411
 
4381
4412
 
4382
4413
ST_FIELD_INFO charsets_fields_info[]=
4383
4414
{
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}
 
4415
  {"CHARACTER_SET_NAME", 64, MYSQL_TYPE_STRING, 0, 0, "Charset",
 
4416
   SKIP_OPEN_TABLE},
 
4417
  {"DEFAULT_COLLATE_NAME", 64, MYSQL_TYPE_STRING, 0, 0, "Default collation",
 
4418
   SKIP_OPEN_TABLE},
 
4419
  {"DESCRIPTION", 60, MYSQL_TYPE_STRING, 0, 0, "Description",
 
4420
   SKIP_OPEN_TABLE},
 
4421
  {"MAXLEN", 3, MYSQL_TYPE_LONGLONG, 0, 0, "Maxlen", SKIP_OPEN_TABLE},
 
4422
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4392
4423
};
4393
4424
 
4394
4425
 
4395
4426
ST_FIELD_INFO collation_fields_info[]=
4396
4427
{
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}
 
4428
  {"COLLATION_NAME", 64, MYSQL_TYPE_STRING, 0, 0, "Collation", SKIP_OPEN_TABLE},
 
4429
  {"CHARACTER_SET_NAME", 64, MYSQL_TYPE_STRING, 0, 0, "Charset",
 
4430
   SKIP_OPEN_TABLE},
 
4431
  {"ID", MY_INT32_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0, 0, "Id",
 
4432
   SKIP_OPEN_TABLE},
 
4433
  {"IS_DEFAULT", 3, MYSQL_TYPE_STRING, 0, 0, "Default", SKIP_OPEN_TABLE},
 
4434
  {"IS_COMPILED", 3, MYSQL_TYPE_STRING, 0, 0, "Compiled", SKIP_OPEN_TABLE},
 
4435
  {"SORTLEN", 3, MYSQL_TYPE_LONGLONG, 0, 0, "Sortlen", SKIP_OPEN_TABLE},
 
4436
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
 
4437
};
 
4438
 
 
4439
 
 
4440
ST_FIELD_INFO events_fields_info[]=
 
4441
{
 
4442
  {"EVENT_CATALOG", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4443
  {"EVENT_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Db",
 
4444
   SKIP_OPEN_TABLE},
 
4445
  {"EVENT_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Name",
 
4446
   SKIP_OPEN_TABLE},
 
4447
  {"DEFINER", 77, MYSQL_TYPE_STRING, 0, 0, "Definer", SKIP_OPEN_TABLE},
 
4448
  {"TIME_ZONE", 64, MYSQL_TYPE_STRING, 0, 0, "Time zone", SKIP_OPEN_TABLE},
 
4449
  {"EVENT_BODY", 8, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4450
  {"EVENT_DEFINITION", 65535, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4451
  {"EVENT_TYPE", 9, MYSQL_TYPE_STRING, 0, 0, "Type", SKIP_OPEN_TABLE},
 
4452
  {"EXECUTE_AT", 0, MYSQL_TYPE_DATETIME, 0, 1, "Execute at", SKIP_OPEN_TABLE},
 
4453
  {"INTERVAL_VALUE", 256, MYSQL_TYPE_STRING, 0, 1, "Interval value",
 
4454
   SKIP_OPEN_TABLE},
 
4455
  {"INTERVAL_FIELD", 18, MYSQL_TYPE_STRING, 0, 1, "Interval field",
 
4456
   SKIP_OPEN_TABLE},
 
4457
  {"SQL_MODE", 65535, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4458
  {"STARTS", 0, MYSQL_TYPE_DATETIME, 0, 1, "Starts", SKIP_OPEN_TABLE},
 
4459
  {"ENDS", 0, MYSQL_TYPE_DATETIME, 0, 1, "Ends", SKIP_OPEN_TABLE},
 
4460
  {"STATUS", 18, MYSQL_TYPE_STRING, 0, 0, "Status", SKIP_OPEN_TABLE},
 
4461
  {"ON_COMPLETION", 12, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4462
  {"CREATED", 0, MYSQL_TYPE_DATETIME, 0, 0, 0, SKIP_OPEN_TABLE},
 
4463
  {"LAST_ALTERED", 0, MYSQL_TYPE_DATETIME, 0, 0, 0, SKIP_OPEN_TABLE},
 
4464
  {"LAST_EXECUTED", 0, MYSQL_TYPE_DATETIME, 0, 1, 0, SKIP_OPEN_TABLE},
 
4465
  {"EVENT_COMMENT", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4466
  {"ORIGINATOR", 10, MYSQL_TYPE_LONGLONG, 0, 0, "Originator", SKIP_OPEN_TABLE},
 
4467
  {"CHARACTER_SET_CLIENT", MY_CS_NAME_SIZE, MYSQL_TYPE_STRING, 0, 0,
 
4468
   "character_set_client", SKIP_OPEN_TABLE},
 
4469
  {"COLLATION_CONNECTION", MY_CS_NAME_SIZE, MYSQL_TYPE_STRING, 0, 0,
 
4470
   "collation_connection", SKIP_OPEN_TABLE},
 
4471
  {"DATABASE_COLLATION", MY_CS_NAME_SIZE, MYSQL_TYPE_STRING, 0, 0,
 
4472
   "Database Collation", SKIP_OPEN_TABLE},
 
4473
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4406
4474
};
4407
4475
 
4408
4476
 
4409
4477
 
4410
4478
ST_FIELD_INFO coll_charset_app_fields_info[]=
4411
4479
{
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}
 
4480
  {"COLLATION_NAME", 64, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4481
  {"CHARACTER_SET_NAME", 64, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4482
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4415
4483
};
4416
4484
 
4417
4485
 
4418
4486
ST_FIELD_INFO stat_fields_info[]=
4419
4487
{
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,
 
4488
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FRM_ONLY},
 
4489
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FRM_ONLY},
 
4490
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Table", OPEN_FRM_ONLY},
 
4491
  {"NON_UNIQUE", 1, MYSQL_TYPE_LONGLONG, 0, 0, "Non_unique", OPEN_FRM_ONLY},
 
4492
  {"INDEX_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FRM_ONLY},
 
4493
  {"INDEX_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Key_name",
 
4494
   OPEN_FRM_ONLY},
 
4495
  {"SEQ_IN_INDEX", 2, MYSQL_TYPE_LONGLONG, 0, 0, "Seq_in_index", OPEN_FRM_ONLY},
 
4496
  {"COLUMN_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Column_name",
 
4497
   OPEN_FRM_ONLY},
 
4498
  {"COLLATION", 1, MYSQL_TYPE_STRING, 0, 1, "Collation", OPEN_FRM_ONLY},
 
4499
  {"CARDINALITY", MY_INT64_NUM_DECIMAL_DIGITS, MYSQL_TYPE_LONGLONG, 0, 1,
4432
4500
   "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}
 
4501
  {"SUB_PART", 3, MYSQL_TYPE_LONGLONG, 0, 1, "Sub_part", OPEN_FRM_ONLY},
 
4502
  {"PACKED", 10, MYSQL_TYPE_STRING, 0, 1, "Packed", OPEN_FRM_ONLY},
 
4503
  {"NULLABLE", 3, MYSQL_TYPE_STRING, 0, 0, "Null", OPEN_FRM_ONLY},
 
4504
  {"INDEX_TYPE", 16, MYSQL_TYPE_STRING, 0, 0, "Index_type", OPEN_FULL_TABLE},
 
4505
  {"COMMENT", 16, MYSQL_TYPE_STRING, 0, 1, "Comment", OPEN_FRM_ONLY},
 
4506
  {"INDEX_COMMENT", INDEX_COMMENT_MAXLEN, MYSQL_TYPE_STRING, 0, 0, "Index_Comment", OPEN_FRM_ONLY},
 
4507
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
 
4508
};
 
4509
 
 
4510
 
 
4511
ST_FIELD_INFO user_privileges_fields_info[]=
 
4512
{
 
4513
  {"GRANTEE", 81, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4514
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4515
  {"PRIVILEGE_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4516
  {"IS_GRANTABLE", 3, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4517
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
 
4518
};
 
4519
 
 
4520
 
 
4521
ST_FIELD_INFO schema_privileges_fields_info[]=
 
4522
{
 
4523
  {"GRANTEE", 81, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4524
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4525
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4526
  {"PRIVILEGE_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4527
  {"IS_GRANTABLE", 3, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4528
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
 
4529
};
 
4530
 
 
4531
 
 
4532
ST_FIELD_INFO table_privileges_fields_info[]=
 
4533
{
 
4534
  {"GRANTEE", 81, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4535
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4536
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4537
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4538
  {"PRIVILEGE_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4539
  {"IS_GRANTABLE", 3, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4540
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
 
4541
};
 
4542
 
 
4543
 
 
4544
ST_FIELD_INFO column_privileges_fields_info[]=
 
4545
{
 
4546
  {"GRANTEE", 81, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4547
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4548
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4549
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4550
  {"COLUMN_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4551
  {"PRIVILEGE_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4552
  {"IS_GRANTABLE", 3, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4553
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4440
4554
};
4441
4555
 
4442
4556
 
4443
4557
ST_FIELD_INFO table_constraints_fields_info[]=
4444
4558
{
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}
 
4559
  {"CONSTRAINT_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4560
  {"CONSTRAINT_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4561
   OPEN_FULL_TABLE},
 
4562
  {"CONSTRAINT_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4563
   OPEN_FULL_TABLE},
 
4564
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4565
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4566
  {"CONSTRAINT_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4567
   OPEN_FULL_TABLE},
 
4568
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4455
4569
};
4456
4570
 
4457
4571
 
4458
4572
ST_FIELD_INFO key_column_usage_fields_info[]=
4459
4573
{
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}
 
4574
  {"CONSTRAINT_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4575
  {"CONSTRAINT_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4576
   OPEN_FULL_TABLE},
 
4577
  {"CONSTRAINT_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4578
   OPEN_FULL_TABLE},
 
4579
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4580
  {"TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4581
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4582
  {"COLUMN_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4583
  {"ORDINAL_POSITION", 10 ,MYSQL_TYPE_LONGLONG, 0, 0, 0, OPEN_FULL_TABLE},
 
4584
  {"POSITION_IN_UNIQUE_CONSTRAINT", 10 ,MYSQL_TYPE_LONGLONG, 0, 1, 0,
 
4585
   OPEN_FULL_TABLE},
 
4586
  {"REFERENCED_TABLE_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, 0,
 
4587
   OPEN_FULL_TABLE},
 
4588
  {"REFERENCED_TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, 0,
 
4589
   OPEN_FULL_TABLE},
 
4590
  {"REFERENCED_COLUMN_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, 0,
 
4591
   OPEN_FULL_TABLE},
 
4592
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4479
4593
};
4480
4594
 
4481
4595
 
4482
4596
ST_FIELD_INFO table_names_fields_info[]=
4483
4597
{
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_",
 
4598
  {"TABLE_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4599
  {"TABLE_SCHEMA",NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4600
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Tables_in_",
4487
4601
   SKIP_OPEN_TABLE},
4488
 
  {"TABLE_TYPE", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Table_type",
 
4602
  {"TABLE_TYPE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Table_type",
4489
4603
   OPEN_FRM_ONLY},
4490
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4604
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4491
4605
};
4492
4606
 
4493
4607
 
4494
4608
ST_FIELD_INFO open_tables_fields_info[]=
4495
4609
{
4496
 
  {"Database", NAME_CHAR_LEN, DRIZZLE_TYPE_VARCHAR, 0, 0, "Database",
 
4610
  {"Database", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Database",
4497
4611
   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}
 
4612
  {"Table",NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Table", SKIP_OPEN_TABLE},
 
4613
  {"In_use", 1, MYSQL_TYPE_LONGLONG, 0, 0, "In_use", SKIP_OPEN_TABLE},
 
4614
  {"Name_locked", 4, MYSQL_TYPE_LONGLONG, 0, 0, "Name_locked", SKIP_OPEN_TABLE},
 
4615
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4502
4616
};
4503
4617
 
4504
4618
 
4505
4619
ST_FIELD_INFO variables_fields_info[]=
4506
4620
{
4507
 
  {"VARIABLE_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, "Variable_name",
 
4621
  {"VARIABLE_NAME", 64, MYSQL_TYPE_STRING, 0, 0, "Variable_name",
4508
4622
   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}
 
4623
  {"VARIABLE_VALUE", 16300, MYSQL_TYPE_STRING, 0, 1, "Value", SKIP_OPEN_TABLE},
 
4624
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4511
4625
};
4512
4626
 
4513
4627
 
4514
4628
ST_FIELD_INFO processlist_fields_info[]=
4515
4629
{
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}
 
4630
  {"ID", 4, MYSQL_TYPE_LONGLONG, 0, 0, "Id", SKIP_OPEN_TABLE},
 
4631
  {"USER", 16, MYSQL_TYPE_STRING, 0, 0, "User", SKIP_OPEN_TABLE},
 
4632
  {"HOST", LIST_PROCESS_HOST_LEN,  MYSQL_TYPE_STRING, 0, 0, "Host",
 
4633
   SKIP_OPEN_TABLE},
 
4634
  {"DB", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, "Db", SKIP_OPEN_TABLE},
 
4635
  {"COMMAND", 16, MYSQL_TYPE_STRING, 0, 0, "Command", SKIP_OPEN_TABLE},
 
4636
  {"TIME", 7, MYSQL_TYPE_LONGLONG, 0, 0, "Time", SKIP_OPEN_TABLE},
 
4637
  {"STATE", 64, MYSQL_TYPE_STRING, 0, 1, "State", SKIP_OPEN_TABLE},
 
4638
  {"INFO", PROCESS_LIST_INFO_WIDTH, MYSQL_TYPE_STRING, 0, 1, "Info",
 
4639
   SKIP_OPEN_TABLE},
 
4640
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4527
4641
};
4528
4642
 
4529
4643
 
4530
4644
ST_FIELD_INFO plugin_fields_info[]=
4531
4645
{
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}
 
4646
  {"PLUGIN_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Name",
 
4647
   SKIP_OPEN_TABLE},
 
4648
  {"PLUGIN_VERSION", 20, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4649
  {"PLUGIN_STATUS", 10, MYSQL_TYPE_STRING, 0, 0, "Status", SKIP_OPEN_TABLE},
 
4650
  {"PLUGIN_TYPE", 80, MYSQL_TYPE_STRING, 0, 0, "Type", SKIP_OPEN_TABLE},
 
4651
  {"PLUGIN_TYPE_VERSION", 20, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
 
4652
  {"PLUGIN_LIBRARY", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, "Library",
 
4653
   SKIP_OPEN_TABLE},
 
4654
  {"PLUGIN_LIBRARY_VERSION", 20, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4655
  {"PLUGIN_AUTHOR", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4656
  {"PLUGIN_DESCRIPTION", 65535, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
 
4657
  {"PLUGIN_LICENSE", 80, MYSQL_TYPE_STRING, 0, 1, "License", SKIP_OPEN_TABLE},
 
4658
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
4543
4659
};
4544
4660
 
4545
4661
ST_FIELD_INFO referential_constraints_fields_info[]=
4546
4662
{
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,
 
4663
  {"CONSTRAINT_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4664
  {"CONSTRAINT_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4665
   OPEN_FULL_TABLE},
 
4666
  {"CONSTRAINT_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4667
   OPEN_FULL_TABLE},
 
4668
  {"UNIQUE_CONSTRAINT_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0,
 
4669
   OPEN_FULL_TABLE},
 
4670
  {"UNIQUE_CONSTRAINT_SCHEMA", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
 
4671
   OPEN_FULL_TABLE},
 
4672
  {"UNIQUE_CONSTRAINT_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0,
4557
4673
   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,
 
4674
  {"MATCH_OPTION", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4675
  {"UPDATE_RULE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4676
  {"DELETE_RULE", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4677
  {"TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4678
  {"REFERENCED_TABLE_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, 0,
4563
4679
   OPEN_FULL_TABLE},
4564
 
  {0, 0, DRIZZLE_TYPE_VARCHAR, 0, 0, 0, SKIP_OPEN_TABLE}
 
4680
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
 
4681
};
 
4682
 
 
4683
 
 
4684
ST_FIELD_INFO parameters_fields_info[]=
 
4685
{
 
4686
  {"SPECIFIC_CATALOG", FN_REFLEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4687
  {"SPECIFIC_SCHEMA", NAME_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4688
  {"SPECIFIC_NAME", NAME_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4689
  {"ORDINAL_POSITION", 21 , MYSQL_TYPE_LONG, 0, 0, 0, OPEN_FULL_TABLE},
 
4690
  {"PARAMETER_MODE", 5, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4691
  {"PARAMETER_NAME", NAME_LEN, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4692
  {"DATA_TYPE", NAME_LEN, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4693
  {"CHARACTER_MAXIMUM_LENGTH", 21 , MYSQL_TYPE_LONG, 0, 1, 0, OPEN_FULL_TABLE},
 
4694
  {"CHARACTER_OCTET_LENGTH", 21 , MYSQL_TYPE_LONG, 0, 1, 0, OPEN_FULL_TABLE},
 
4695
  {"NUMERIC_PRECISION", 21 , MYSQL_TYPE_LONG, 0, 1, 0, OPEN_FULL_TABLE},
 
4696
  {"NUMERIC_SCALE", 21 , MYSQL_TYPE_LONG, 0, 1, 0, OPEN_FULL_TABLE},
 
4697
  {"CHARACTER_SET_NAME", 64, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4698
  {"COLLATION_NAME", 64, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
 
4699
  {"DTD_IDENTIFIER", 65535, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4700
  {"ROUTINE_TYPE", 9, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE},
 
4701
  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, OPEN_FULL_TABLE}
4565
4702
};
4566
4703
 
4567
4704
 
4582
4719
   create_schema_table, fill_schema_coll_charset_app, 0, 0, -1, -1, 0, 0},
4583
4720
  {"COLUMNS", columns_fields_info, create_schema_table, 
4584
4721
   get_all_tables, make_columns_old_format, get_schema_column_record, 1, 2, 0,
4585
 
   OPTIMIZE_I_S_TABLE},
 
4722
   OPTIMIZE_I_S_TABLE|OPEN_VIEW_FULL},
4586
4723
  {"GLOBAL_STATUS", variables_fields_info, create_schema_table,
4587
4724
   fill_status, make_old_format, 0, -1, -1, 0, 0},
4588
4725
  {"GLOBAL_VARIABLES", variables_fields_info, create_schema_table,
4649
4786
 
4650
4787
    if (plugin->plugin->init(schema_table))
4651
4788
    {
4652
 
      sql_print_error(_("Plugin '%s' init function returned error."),
 
4789
      sql_print_error("Plugin '%s' init function returned error.",
4653
4790
                      plugin->name.str);
4654
4791
      goto err;
4655
4792
    }
4660
4797
 
4661
4798
  return(0);
4662
4799
err:
4663
 
  free(schema_table);
 
4800
  my_free(schema_table, MYF(0));
4664
4801
  return(1);
4665
4802
}
4666
4803
 
4669
4806
  ST_SCHEMA_TABLE *schema_table= (ST_SCHEMA_TABLE *)plugin->data;
4670
4807
 
4671
4808
  if (schema_table && plugin->plugin->deinit)
4672
 
    free(schema_table);
 
4809
    my_free(schema_table, MYF(0));
4673
4810
 
4674
4811
  return(0);
4675
4812
}