← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/show.cc

  • Committer: Monty Taylor
  • Date: 2009-04-12 09:10:36 UTC
  • mto: (992.1.1 mordred)
  • mto: This revision was merged to the branch mainline in revision 990.
  • Revision ID: mordred@inaugust.com-20090412091036-e1k40nhgt5okphih
Renamed ST_SCHEMA_TABLE to InfoSchemaTable. One step down towards making the darned thing a class. (/me shudders)

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/show.cc
66
66
static void store_key_options(Session *session, String *packet, Table *table,
67
67
                              KEY *key_info);
68
68
 
69
 
static vector<ST_SCHEMA_TABLE *> all_schema_tables;
 
69
static vector<InfoSchemaTable *> all_schema_tables;
70
70
 
71
71
Table *create_schema_table(Session *session, TableList *table_list);
72
 
int make_old_format(Session *session, ST_SCHEMA_TABLE *schema_table);
 
72
int make_old_format(Session *session, InfoSchemaTable *schema_table);
73
73
 
74
 
void add_infoschema_table(ST_SCHEMA_TABLE *schema_table)
 
74
void add_infoschema_table(InfoSchemaTable *schema_table)
75
75
{
76
76
  if (schema_table->create_table == NULL)
77
77
    schema_table->create_table= create_schema_table;
85
85
  all_schema_tables.push_back(schema_table);
86
86
}
87
87
 
88
 
void remove_infoschema_table(ST_SCHEMA_TABLE *table)
 
88
void remove_infoschema_table(InfoSchemaTable *table)
89
89
{
90
90
  all_schema_tables.erase(remove_if(all_schema_tables.begin(),
91
91
                                    all_schema_tables.end(),
92
 
                                    bind2nd(equal_to<ST_SCHEMA_TABLE *>(),
 
92
                                    bind2nd(equal_to<InfoSchemaTable *>(),
93
93
                                            table)),
94
94
                          all_schema_tables.end());
95
95
}
1593
1593
 
1594
1594
 
1595
1595
/* This is only used internally, but we need it here as a forward reference */
1596
 
extern ST_SCHEMA_TABLE schema_tables[];
 
1596
extern InfoSchemaTable schema_tables[];
1597
1597
 
1598
1598
typedef struct st_lookup_field_values
1599
1599
{
1665
1665
                      TableList *table,
1666
1666
                      LOOKUP_FIELD_VALUES *lookup_field_vals)
1667
1667
{
1668
 
  ST_SCHEMA_TABLE *schema_table= table->schema_table;
 
1668
  InfoSchemaTable *schema_table= table->schema_table;
1669
1669
  ST_FIELD_INFO *field_info= schema_table->fields_info;
1670
1670
  const char *field_name1= schema_table->idx_field1 >= 0 ?
1671
1671
    field_info[schema_table->idx_field1].field_name : "";
1794
1794
  {
1795
1795
    Item_field *item_field= (Item_field*)item;
1796
1796
    const CHARSET_INFO * const cs= system_charset_info;
1797
 
    ST_SCHEMA_TABLE *schema_table= table->schema_table;
 
1797
    InfoSchemaTable *schema_table= table->schema_table;
1798
1798
    ST_FIELD_INFO *field_info= schema_table->fields_info;
1799
1799
    const char *field_name1= schema_table->idx_field1 >= 0 ?
1800
1800
      field_info[schema_table->idx_field1].field_name : "";
1929
1929
}
1930
1930
 
1931
1931
 
1932
 
enum enum_schema_tables get_schema_table_idx(ST_SCHEMA_TABLE *schema_table)
 
1932
enum enum_schema_tables get_schema_table_idx(InfoSchemaTable *schema_table)
1933
1933
{
1934
1934
  return (enum enum_schema_tables) (schema_table - &schema_tables[0]);
1935
1935
}
2021
2021
};
2022
2022
 
2023
2023
 
2024
 
class AddSchemaTable : public unary_function<ST_SCHEMA_TABLE *, bool>
 
2024
class AddSchemaTable : public unary_function<InfoSchemaTable *, bool>
2025
2025
{
2026
2026
  Session *session;
2027
2027
  st_add_schema_table *data;
2062
2062
int schema_tables_add(Session *session, List<LEX_STRING> *files, const char *wild)
2063
2063
{
2064
2064
  LEX_STRING *file_name= 0;
2065
 
  ST_SCHEMA_TABLE *tmp_schema_table= schema_tables;
 
2065
  InfoSchemaTable *tmp_schema_table= schema_tables;
2066
2066
  st_add_schema_table add_data;
2067
2067
 
2068
2068
  for (; tmp_schema_table->table_name; tmp_schema_table++)
2091
2091
 
2092
2092
  add_data.files= files;
2093
2093
  add_data.wild= wild;
2094
 
  vector<ST_SCHEMA_TABLE *>::iterator iter=
 
2094
  vector<InfoSchemaTable *>::iterator iter=
2095
2095
    find_if(all_schema_tables.begin(), all_schema_tables.end(),
2096
2096
           AddSchemaTable(session, &add_data));
2097
2097
  if (iter != all_schema_tables.end())
2194
2194
 
2195
2195
static int
2196
2196
fill_schema_show_cols_or_idxs(Session *session, TableList *tables,
2197
 
                              ST_SCHEMA_TABLE *schema_table,
 
2197
                              InfoSchemaTable *schema_table,
2198
2198
                              Open_tables_state *open_tables_state_backup)
2199
2199
{
2200
2200
  LEX *lex= session->lex;
2311
2311
*/
2312
2312
 
2313
2313
static uint32_t get_table_open_method(TableList *tables,
2314
 
                                      ST_SCHEMA_TABLE *schema_table,
 
2314
                                      InfoSchemaTable *schema_table,
2315
2315
                                      enum enum_schema_tables)
2316
2316
{
2317
2317
  /*
2352
2352
*/
2353
2353
 
2354
2354
static int fill_schema_table_from_frm(Session *session,TableList *tables,
2355
 
                                      ST_SCHEMA_TABLE *schema_table,
 
2355
                                      InfoSchemaTable *schema_table,
2356
2356
                                      LEX_STRING *db_name,
2357
2357
                                      LEX_STRING *table_name,
2358
2358
                                      enum enum_schema_tables)
2425
2425
  Select_Lex *old_all_select_lex= lex->all_selects_list;
2426
2426
  enum_sql_command save_sql_command= lex->sql_command;
2427
2427
  Select_Lex *lsel= tables->schema_select_lex;
2428
 
  ST_SCHEMA_TABLE *schema_table= tables->schema_table;
 
2428
  InfoSchemaTable *schema_table= tables->schema_table;
2429
2429
  Select_Lex sel;
2430
2430
  LOOKUP_FIELD_VALUES lookup_field_vals;
2431
2431
  LEX_STRING *db_name, *table_name;
3665
3665
}
3666
3666
 
3667
3667
 
3668
 
class FindSchemaTableByName : public unary_function<ST_SCHEMA_TABLE *, bool>
 
3668
class FindSchemaTableByName : public unary_function<InfoSchemaTable *, bool>
3669
3669
{
3670
3670
  const char *table_name;
3671
3671
public:
3693
3693
    #   pointer to 'schema_tables' element
3694
3694
*/
3695
3695
 
3696
 
ST_SCHEMA_TABLE *find_schema_table(Session *, const char* table_name)
 
3696
InfoSchemaTable *find_schema_table(Session *, const char* table_name)
3697
3697
{
3698
 
  ST_SCHEMA_TABLE *schema_table= schema_tables;
 
3698
  InfoSchemaTable *schema_table= schema_tables;
3699
3699
 
3700
3700
  for (; schema_table->table_name; schema_table++)
3701
3701
  {
3705
3705
      return(schema_table);
3706
3706
  }
3707
3707
 
3708
 
  vector<ST_SCHEMA_TABLE *>::iterator iter= 
 
3708
  vector<InfoSchemaTable *>::iterator iter= 
3709
3709
    find_if(all_schema_tables.begin(), all_schema_tables.end(),
3710
3710
            FindSchemaTableByName(table_name));
3711
3711
  if (iter != all_schema_tables.end())
3714
3714
}
3715
3715
 
3716
3716
 
3717
 
ST_SCHEMA_TABLE *get_schema_table(enum enum_schema_tables schema_table_idx)
 
3717
InfoSchemaTable *get_schema_table(enum enum_schema_tables schema_table_idx)
3718
3718
{
3719
3719
  return &schema_tables[schema_table_idx];
3720
3720
}
3741
3741
  Item *item;
3742
3742
  Table *table;
3743
3743
  List<Item> field_list;
3744
 
  ST_SCHEMA_TABLE *schema_table= table_list->schema_table;
 
3744
  InfoSchemaTable *schema_table= table_list->schema_table;
3745
3745
  ST_FIELD_INFO *fields_info= schema_table->fields_info;
3746
3746
  const CHARSET_INFO * const cs= system_charset_info;
3747
3747
 
3844
3844
   0    success
3845
3845
*/
3846
3846
 
3847
 
int make_old_format(Session *session, ST_SCHEMA_TABLE *schema_table)
 
3847
int make_old_format(Session *session, InfoSchemaTable *schema_table)
3848
3848
{
3849
3849
  ST_FIELD_INFO *field_info= schema_table->fields_info;
3850
3850
  Name_resolution_context *context= &session->lex->select_lex.context;
3868
3868
}
3869
3869
 
3870
3870
 
3871
 
int make_schemata_old_format(Session *session, ST_SCHEMA_TABLE *schema_table)
 
3871
int make_schemata_old_format(Session *session, InfoSchemaTable *schema_table)
3872
3872
{
3873
3873
  char tmp[128];
3874
3874
  LEX *lex= session->lex;
3897
3897
}
3898
3898
 
3899
3899
 
3900
 
int make_table_names_old_format(Session *session, ST_SCHEMA_TABLE *schema_table)
 
3900
int make_table_names_old_format(Session *session, InfoSchemaTable *schema_table)
3901
3901
{
3902
3902
  char tmp[128];
3903
3903
  String buffer(tmp,sizeof(tmp), session->charset());
3933
3933
}
3934
3934
 
3935
3935
 
3936
 
int make_columns_old_format(Session *session, ST_SCHEMA_TABLE *schema_table)
 
3936
int make_columns_old_format(Session *session, InfoSchemaTable *schema_table)
3937
3937
{
3938
3938
  int fields_arr[]= {3, 14, 13, 6, 15, 5, 16, 17, 18, -1};
3939
3939
  int *field_num= fields_arr;
3962
3962
}
3963
3963
 
3964
3964
 
3965
 
int make_character_sets_old_format(Session *session, ST_SCHEMA_TABLE *schema_table)
 
3965
int make_character_sets_old_format(Session *session, InfoSchemaTable *schema_table)
3966
3966
{
3967
3967
  int fields_arr[]= {0, 2, 1, 3, -1};
3968
3968
  int *field_num= fields_arr;
4046
4046
int make_schema_select(Session *session, Select_Lex *sel,
4047
4047
                       enum enum_schema_tables schema_table_idx)
4048
4048
{
4049
 
  ST_SCHEMA_TABLE *schema_table= get_schema_table(schema_table_idx);
 
4049
  InfoSchemaTable *schema_table= get_schema_table(schema_table_idx);
4050
4050
  LEX_STRING db, table;
4051
4051
  /*
4052
4052
     We have to make non const db_name & table_name
4427
4427
 
4428
4428
*/
4429
4429
 
4430
 
ST_SCHEMA_TABLE schema_tables[]=
 
4430
InfoSchemaTable schema_tables[]=
4431
4431
{
4432
4432
  {"CHARACTER_SETS", charsets_fields_info, create_schema_table,
4433
4433
   fill_schema_charsets, make_character_sets_old_format, 0, -1, -1, 0, 0},