← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/show.cc

  • Committer: Brian Aker
  • Date: 2009-07-23 00:02:03 UTC
  • mfrom: (1093.1.25 captain)
  • Revision ID: brian@gaz-20090723000203-kkrx4udjiiwy869o
Mege Jay

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/show.cc
1009
1009
  }
1010
1010
};
1011
1011
 
 
1012
SHOW_VAR *getFrontOfStatusVars()
 
1013
{
 
1014
  return all_status_vars.front();
 
1015
}
 
1016
 
1012
1017
/*
1013
1018
  Adds an array of SHOW_VAR entries to the output of SHOW STATUS
1014
1019
 
1147
1152
  }
1148
1153
}
1149
1154
 
1150
 
inline void make_upper(char *buf)
1151
 
{
1152
 
  for (; *buf; buf++)
1153
 
    *buf= my_toupper(system_charset_info, *buf);
1154
 
}
1155
 
 
1156
 
static bool show_status_array(Session *session, const char *wild,
1157
 
                              SHOW_VAR *variables,
1158
 
                              enum enum_var_type value_type,
1159
 
                              struct system_status_var *status_var,
1160
 
                              const char *prefix, Table *table,
1161
 
                              bool ucase_names)
1162
 
{
1163
 
  MY_ALIGNED_BYTE_ARRAY(buff_data, SHOW_VAR_FUNC_BUFF_SIZE, int64_t);
1164
 
  char * const buff= (char *) &buff_data;
1165
 
  char *prefix_end;
1166
 
  /* the variable name should not be longer than 64 characters */
1167
 
  char name_buffer[64];
1168
 
  int len;
1169
 
  SHOW_VAR tmp, *var;
1170
 
 
1171
 
  prefix_end= strncpy(name_buffer, prefix, sizeof(name_buffer)-1);
1172
 
  prefix_end+= strlen(prefix);
1173
 
 
1174
 
  if (*prefix)
1175
 
    *prefix_end++= '_';
1176
 
  len=name_buffer + sizeof(name_buffer) - prefix_end;
1177
 
 
1178
 
  for (; variables->name; variables++)
1179
 
  {
1180
 
    strncpy(prefix_end, variables->name, len);
1181
 
    name_buffer[sizeof(name_buffer)-1]=0;       /* Safety */
1182
 
    if (ucase_names)
1183
 
      make_upper(name_buffer);
1184
 
 
1185
 
    /*
1186
 
      if var->type is SHOW_FUNC, call the function.
1187
 
      Repeat as necessary, if new var is again SHOW_FUNC
1188
 
    */
1189
 
    for (var=variables; var->type == SHOW_FUNC; var= &tmp)
1190
 
      ((mysql_show_var_func)((st_show_var_func_container *)var->value)->func)(&tmp, buff);
1191
 
 
1192
 
    SHOW_TYPE show_type=var->type;
1193
 
    if (show_type == SHOW_ARRAY)
1194
 
    {
1195
 
      show_status_array(session, wild, (SHOW_VAR *) var->value, value_type,
1196
 
                        status_var, name_buffer, table, ucase_names);
1197
 
    }
1198
 
    else
1199
 
    {
1200
 
      if (!(wild && wild[0] && wild_case_compare(system_charset_info,
1201
 
                                                 name_buffer, wild)))
1202
 
      {
1203
 
        char *value=var->value;
1204
 
        const char *pos, *end;                  // We assign a lot of const's
1205
 
        pthread_mutex_lock(&LOCK_global_system_variables);
1206
 
 
1207
 
        if (show_type == SHOW_SYS)
1208
 
        {
1209
 
          show_type= ((sys_var*) value)->show_type();
1210
 
          value= (char*) ((sys_var*) value)->value_ptr(session, value_type,
1211
 
                                                       &null_lex_str);
1212
 
        }
1213
 
 
1214
 
        pos= end= buff;
1215
 
        /*
1216
 
          note that value may be == buff. All SHOW_xxx code below
1217
 
          should still work in this case
1218
 
        */
1219
 
        switch (show_type) {
1220
 
        case SHOW_DOUBLE_STATUS:
1221
 
          value= ((char *) status_var + (ulong) value);
1222
 
          /* fall through */
1223
 
        case SHOW_DOUBLE:
1224
 
          /* 6 is the default precision for '%f' in sprintf() */
1225
 
          end= buff + my_fcvt(*(double *) value, 6, buff, NULL);
1226
 
          break;
1227
 
        case SHOW_LONG_STATUS:
1228
 
          value= ((char *) status_var + (ulong) value);
1229
 
          /* fall through */
1230
 
        case SHOW_LONG:
1231
 
          end= int10_to_str(*(long*) value, buff, 10);
1232
 
          break;
1233
 
        case SHOW_LONGLONG_STATUS:
1234
 
          value= ((char *) status_var + (uint64_t) value);
1235
 
          /* fall through */
1236
 
        case SHOW_LONGLONG:
1237
 
          end= int64_t10_to_str(*(int64_t*) value, buff, 10);
1238
 
          break;
1239
 
        case SHOW_SIZE:
1240
 
          {
1241
 
            stringstream ss (stringstream::in);
1242
 
            ss << *(size_t*) value;
1243
 
 
1244
 
            string str= ss.str();
1245
 
            strncpy(buff, str.c_str(), str.length());
1246
 
            end= buff+ str.length();
1247
 
          }
1248
 
          break;
1249
 
        case SHOW_HA_ROWS:
1250
 
          end= int64_t10_to_str((int64_t) *(ha_rows*) value, buff, 10);
1251
 
          break;
1252
 
        case SHOW_BOOL:
1253
 
          end+= sprintf(buff,"%s", *(bool*) value ? "ON" : "OFF");
1254
 
          break;
1255
 
        case SHOW_MY_BOOL:
1256
 
          end+= sprintf(buff,"%s", *(bool*) value ? "ON" : "OFF");
1257
 
          break;
1258
 
        case SHOW_INT:
1259
 
        case SHOW_INT_NOFLUSH: // the difference lies in refresh_status()
1260
 
          end= int10_to_str((long) *(uint32_t*) value, buff, 10);
1261
 
          break;
1262
 
        case SHOW_HAVE:
1263
 
        {
1264
 
          SHOW_COMP_OPTION tmp_option= *(SHOW_COMP_OPTION *)value;
1265
 
          pos= show_comp_option_name[(int) tmp_option];
1266
 
          end= strchr(pos, '\0');
1267
 
          break;
1268
 
        }
1269
 
        case SHOW_CHAR:
1270
 
        {
1271
 
          if (!(pos= value))
1272
 
            pos= "";
1273
 
          end= strchr(pos, '\0');
1274
 
          break;
1275
 
        }
1276
 
       case SHOW_CHAR_PTR:
1277
 
        {
1278
 
          if (!(pos= *(char**) value))
1279
 
            pos= "";
1280
 
          end= strchr(pos, '\0');
1281
 
          break;
1282
 
        }
1283
 
        case SHOW_KEY_CACHE_LONG:
1284
 
          value= (char*) dflt_key_cache + (ulong)value;
1285
 
          end= int10_to_str(*(long*) value, buff, 10);
1286
 
          break;
1287
 
        case SHOW_KEY_CACHE_LONGLONG:
1288
 
          value= (char*) dflt_key_cache + (ulong)value;
1289
 
          end= int64_t10_to_str(*(int64_t*) value, buff, 10);
1290
 
          break;
1291
 
        case SHOW_UNDEF:
1292
 
          break;                                        // Return empty string
1293
 
        case SHOW_SYS:                                  // Cannot happen
1294
 
        default:
1295
 
          assert(0);
1296
 
          break;
1297
 
        }
1298
 
        table->restoreRecordAsDefault();
1299
 
        table->field[0]->store(name_buffer, strlen(name_buffer),
1300
 
                               system_charset_info);
1301
 
        table->field[1]->store(pos, (uint32_t) (end - pos), system_charset_info);
1302
 
        table->field[1]->set_notnull();
1303
 
 
1304
 
        pthread_mutex_unlock(&LOCK_global_system_variables);
1305
 
 
1306
 
        if (schema_table_store_record(session, table))
1307
 
          return true;
1308
 
      }
1309
 
    }
1310
 
  }
1311
 
 
1312
 
  return false;
1313
 
}
1314
 
 
1315
 
 
1316
1155
/* collect status for all running threads */
1317
1156
 
1318
1157
void calc_sum_of_all_status(STATUS_VAR *to)
1333
1172
  return;
1334
1173
}
1335
1174
 
1336
 
 
1337
 
/* This is only used internally, but we need it here as a forward reference */
1338
 
extern InfoSchemaTable schema_tables[];
1339
 
 
1340
1175
/*
1341
1176
  Store record to I_S table, convert HEAP table
1342
1177
  to MyISAM if necessary
1777
1612
 
1778
1613
static int schema_tables_add(Session *session, vector<LEX_STRING*> &files, const char *wild)
1779
1614
{
1780
 
  InfoSchemaTable *tmp_schema_table= schema_tables;
1781
 
 
1782
 
  for (; tmp_schema_table->getTableName().length() != 0; tmp_schema_table++)
1783
 
  {
1784
 
    if (tmp_schema_table->isHidden())
1785
 
    {
1786
 
      continue;
1787
 
    }
1788
 
 
1789
 
    const string &schema_table_name= tmp_schema_table->getTableName();
1790
 
 
1791
 
    if (wild && wild_case_compare(files_charset_info, schema_table_name.c_str(), wild))
1792
 
    {
1793
 
      continue;
1794
 
    }
1795
 
 
1796
 
    LEX_STRING *file_name= 0;
1797
 
    file_name= session->make_lex_string(file_name, schema_table_name.c_str(),
1798
 
                                        schema_table_name.length(), true);
1799
 
    if (file_name == NULL)
1800
 
    {
1801
 
      return 1;
1802
 
    }
1803
 
 
1804
 
    files.push_back(file_name);
1805
 
  }
1806
 
 
1807
1615
  vector<InfoSchemaTable *>::iterator iter= find_if(all_schema_tables.begin(),
1808
1616
                                                    all_schema_tables.end(),
1809
1617
                                                    AddSchemaTable(session, files, wild));
1810
1618
 
1811
1619
  if (iter != all_schema_tables.end())
 
1620
  {
1812
1621
    return 1;
 
1622
  }
1813
1623
 
1814
1624
  return 0;
1815
1625
}
2575
2385
}
2576
2386
 
2577
2387
 
2578
 
int VariablesISMethods::fillTable(Session *session, TableList *tables, COND *)
2579
 
{
2580
 
  int res= 0;
2581
 
  LEX *lex= session->lex;
2582
 
  const char *wild= lex->wild ? lex->wild->ptr() : NULL;
2583
 
  const string schema_table_name= tables->schema_table->getTableName();
2584
 
  enum enum_var_type option_type= OPT_SESSION;
2585
 
  bool upper_case_names= (schema_table_name.compare("VARIABLES") != 0);
2586
 
  bool sorted_vars= (schema_table_name.compare("VARIABLES") == 0);
2587
 
 
2588
 
  if (lex->option_type == OPT_GLOBAL ||
2589
 
      schema_table_name.compare("GLOBAL_VARIABLES") == 0)
2590
 
  {
2591
 
    option_type= OPT_GLOBAL;
2592
 
  }
2593
 
 
2594
 
  pthread_rwlock_rdlock(&LOCK_system_variables_hash);
2595
 
  res= show_status_array(session, wild, enumerate_sys_vars(session, sorted_vars),
2596
 
                         option_type, NULL, "", tables->table, upper_case_names);
2597
 
  pthread_rwlock_unlock(&LOCK_system_variables_hash);
2598
 
  return(res);
2599
 
}
2600
 
 
2601
 
 
2602
 
int StatusISMethods::fillTable(Session *session, TableList *tables, COND *)
2603
 
{
2604
 
  LEX *lex= session->lex;
2605
 
  const char *wild= lex->wild ? lex->wild->ptr() : NULL;
2606
 
  int res= 0;
2607
 
  STATUS_VAR *tmp1, tmp;
2608
 
  const string schema_table_name= tables->schema_table->getTableName();
2609
 
  enum enum_var_type option_type;
2610
 
  bool upper_case_names= (schema_table_name.compare("STATUS") != 0);
2611
 
 
2612
 
  if (schema_table_name.compare("STATUS") == 0)
2613
 
  {
2614
 
    option_type= lex->option_type;
2615
 
    if (option_type == OPT_GLOBAL)
2616
 
      tmp1= &tmp;
2617
 
    else
2618
 
      tmp1= session->initial_status_var;
2619
 
  }
2620
 
  else if (schema_table_name.compare("GLOBAL_STATUS") == 0)
2621
 
  {
2622
 
    option_type= OPT_GLOBAL;
2623
 
    tmp1= &tmp;
2624
 
  }
2625
 
  else
2626
 
  {
2627
 
    option_type= OPT_SESSION;
2628
 
    tmp1= &session->status_var;
2629
 
  }
2630
 
 
2631
 
  pthread_mutex_lock(&LOCK_status);
2632
 
  if (option_type == OPT_GLOBAL)
2633
 
    calc_sum_of_all_status(&tmp);
2634
 
  res= show_status_array(session, wild,
2635
 
                         (SHOW_VAR *) all_status_vars.front(),
2636
 
                         option_type, tmp1, "", tables->table,
2637
 
                         upper_case_names);
2638
 
  pthread_mutex_unlock(&LOCK_status);
2639
 
  return(res);
2640
 
}
2641
 
 
2642
 
 
2643
2388
class FindSchemaTableByName : public unary_function<InfoSchemaTable *, bool>
2644
2389
{
2645
2390
  const char *table_name;
2669
2414
 
2670
2415
InfoSchemaTable *find_schema_table(const char* table_name)
2671
2416
{
2672
 
  InfoSchemaTable *schema_table= schema_tables;
2673
 
 
2674
 
  for (; schema_table->getTableName().length() != 0; schema_table++)
2675
 
  {
2676
 
    if (! my_strcasecmp(system_charset_info,
2677
 
                        schema_table->getTableName().c_str(),
2678
 
                        table_name))
2679
 
      return(schema_table);
2680
 
  }
2681
 
 
2682
2417
  vector<InfoSchemaTable *>::iterator iter= 
2683
2418
    find_if(all_schema_tables.begin(), all_schema_tables.end(),
2684
2419
            FindSchemaTableByName(table_name));
2685
2420
  if (iter != all_schema_tables.end())
 
2421
  {
2686
2422
    return *iter;
 
2423
  }
 
2424
 
2687
2425
  return NULL;
2688
2426
}
2689
2427
 
2996
2734
  session->no_warnings_for_error= 0;
2997
2735
  return(result);
2998
2736
}
2999
 
 
3000
 
ColumnInfo variables_fields_info[]=
3001
 
{
3002
 
  ColumnInfo("VARIABLE_NAME", 64, DRIZZLE_TYPE_VARCHAR, 0, 0, "Variable_name",
3003
 
   SKIP_OPEN_TABLE),
3004
 
  ColumnInfo("VARIABLE_VALUE", 16300, DRIZZLE_TYPE_VARCHAR, 0, 1, "Value", SKIP_OPEN_TABLE),
3005
 
  ColumnInfo()
3006
 
};
3007
 
 
3008
 
 
3009
 
static StatusISMethods status_methods;
3010
 
static VariablesISMethods variables_methods;
3011
 
 
3012
 
static InfoSchemaTable global_stat_table("GLOBAL_STATUS",
3013
 
                                         variables_fields_info,
3014
 
                                         -1, -1, false, false, 0,
3015
 
                                         &status_methods);
3016
 
static InfoSchemaTable global_var_table("GLOBAL_VARIABLES",
3017
 
                                        variables_fields_info,
3018
 
                                        -1, -1, false, false, 0,
3019
 
                                        &variables_methods);
3020
 
static InfoSchemaTable sess_stat_table("SESSION_STATUS",
3021
 
                                       variables_fields_info,
3022
 
                                       -1, -1, false, false, 0,
3023
 
                                       &status_methods);
3024
 
static InfoSchemaTable sess_var_table("SESSION_VARIABLES",
3025
 
                                      variables_fields_info,
3026
 
                                      -1, -1, false, false, 0,
3027
 
                                      &variables_methods);
3028
 
static InfoSchemaTable status_table("STATUS",
3029
 
                                    variables_fields_info,
3030
 
                                    -1, -1, true, false, 0,
3031
 
                                    &status_methods);
3032
 
static InfoSchemaTable var_table("VARIABLES",
3033
 
                                 variables_fields_info,
3034
 
                                 -1, -1, true, false, 0,
3035
 
                                 &variables_methods);
3036
 
 
3037
 
InfoSchemaTable schema_tables[]=
3038
 
{
3039
 
  global_stat_table,
3040
 
  global_var_table,
3041
 
  sess_stat_table,
3042
 
  sess_var_table,
3043
 
  status_table,
3044
 
  var_table,
3045
 
  InfoSchemaTable()
3046
 
};