← 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-09 05:35:58 UTC
  • mfrom: (984 merge)
  • mto: (992.1.1 mordred)
  • mto: This revision was merged to the branch mainline in revision 986.
  • Revision ID: mordred@inaugust.com-20090409053558-qi1x0zzsgf1d8f1p
Merged trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/show.cc
374
374
                                               cmax(buffer.length(),(uint32_t)1024)));
375
375
  }
376
376
 
377
 
  if (protocol->send_fields(&field_list,
378
 
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
 
377
  if (protocol->sendFields(&field_list,
 
378
                           Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
379
379
  {
380
380
    return(true);
381
381
  }
382
 
  protocol->prepare_for_resend();
 
382
  protocol->prepareForResend();
383
383
  {
384
384
    if (table_list->schema_table)
385
385
      protocol->store(table_list->schema_table->table_name,
418
418
  field_list.push_back(new Item_empty_string("Database",NAME_CHAR_LEN));
419
419
  field_list.push_back(new Item_empty_string("Create Database",1024));
420
420
 
421
 
  if (protocol->send_fields(&field_list,
422
 
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
 
421
  if (protocol->sendFields(&field_list,
 
422
                           Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
423
423
    return(true);
424
424
 
425
 
  protocol->prepare_for_resend();
 
425
  protocol->prepareForResend();
426
426
  protocol->store(dbname, strlen(dbname), system_charset_info);
427
427
  protocol->store(buffer.ptr(), buffer.length(), buffer.charset());
428
428
 
461
461
  }
462
462
  restore_record(table, s->default_values);              // Get empty record
463
463
  table->use_all_columns();
464
 
  if (session->protocol->send_fields(&field_list, Protocol::SEND_DEFAULTS))
 
464
  if (session->protocol->sendFields(&field_list, Protocol::SEND_DEFAULTS))
465
465
    return;
466
466
  session->my_eof();
467
467
  return;
1043
1043
  field->maybe_null= true;
1044
1044
  field_list.push_back(field=new Item_empty_string("Info", PROCESS_LIST_WIDTH));
1045
1045
  field->maybe_null= true;
1046
 
  if (protocol->send_fields(&field_list,
1047
 
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
 
1046
  if (protocol->sendFields(&field_list,
 
1047
                           Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
1048
1048
    return;
1049
1049
 
1050
1050
  pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
1056
1056
    {
1057
1057
      Security_context *tmp_sctx= &tmp->security_ctx;
1058
1058
      struct st_my_thread_var *mysys_var;
1059
 
      if (tmp->protocol->io_ok() && (!user || (tmp_sctx->user.c_str() && !strcmp(tmp_sctx->user.c_str(), user))))
 
1059
      if (tmp->protocol->isConnected() && (!user || (tmp_sctx->user.c_str() && !strcmp(tmp_sctx->user.c_str(), user))))
1060
1060
      {
1061
1061
        thread_info *session_info= new thread_info;
1062
1062
 
1068
1068
        session_info->command=(int) tmp->command;
1069
1069
        if ((mysys_var= tmp->mysys_var))
1070
1070
          pthread_mutex_lock(&mysys_var->mutex);
1071
 
        session_info->proc_info= (char*) (tmp->killed == Session::KILL_CONNECTION? "Killed" : 0);
1072
 
        session_info->state_info= (char*) (tmp->protocol->is_writing() ?
 
1071
 
 
1072
        if (tmp->killed == Session::KILL_CONNECTION)
 
1073
          session_info->proc_info= (char*) "Killed";
 
1074
        else
 
1075
          session_info->proc_info= command_name[session_info->command].str;
 
1076
 
 
1077
        session_info->state_info= (char*) (tmp->protocol->isWriting() ?
1073
1078
                                           "Writing to net" :
1074
 
                                           tmp->protocol->is_reading() ?
 
1079
                                           tmp->protocol->isReading() ?
1075
1080
                                           (session_info->command == COM_SLEEP ?
1076
1081
                                            NULL : "Reading from net") :
1077
1082
                                       tmp->get_proc_info() ? tmp->get_proc_info() :
1103
1108
  time_t now= time(NULL);
1104
1109
  while ((session_info=thread_infos.get()))
1105
1110
  {
1106
 
    protocol->prepare_for_resend();
 
1111
    protocol->prepareForResend();
1107
1112
    protocol->store((uint64_t) session_info->thread_id);
1108
1113
    protocol->store(session_info->user, system_charset_info);
1109
1114
    protocol->store(session_info->host, system_charset_info);
1110
1115
    protocol->store(session_info->db, system_charset_info);
1111
 
    if (session_info->proc_info)
1112
 
      protocol->store(session_info->proc_info, system_charset_info);
1113
 
    else
1114
 
      protocol->store(command_name[session_info->command].str, system_charset_info);
 
1116
    protocol->store(session_info->proc_info, system_charset_info);
 
1117
 
1115
1118
    if (session_info->start_time)
1116
1119
      protocol->store((uint32_t) (now - session_info->start_time));
1117
1120
    else
1118
 
      protocol->store_null();
 
1121
      protocol->store();
 
1122
 
1119
1123
    protocol->store(session_info->state_info, system_charset_info);
1120
1124
    protocol->store(session_info->query, system_charset_info);
 
1125
 
1121
1126
    if (protocol->write())
1122
1127
      break; /* purecov: inspected */
1123
1128
  }
1150
1155
      struct st_my_thread_var *mysys_var;
1151
1156
      const char *val;
1152
1157
 
1153
 
      if (! tmp->protocol->io_ok())
 
1158
      if (! tmp->protocol->isConnected())
1154
1159
        continue;
1155
1160
 
1156
1161
      restore_record(table, s->default_values);
1180
1185
      table->field[5]->store((uint32_t)(tmp->start_time ?
1181
1186
                                      now - tmp->start_time : 0), true);
1182
1187
      /* STATE */
1183
 
      val= (char*) (tmp->protocol->is_writing() ?
 
1188
      val= (char*) (tmp->protocol->isWriting() ?
1184
1189
                    "Writing to net" :
1185
 
                    tmp->protocol->is_reading() ?
 
1190
                    tmp->protocol->isReading() ?
1186
1191
                    (tmp->command == COM_SLEEP ?
1187
1192
                     NULL : "Reading from net") :
1188
1193
                    tmp->get_proc_info() ? tmp->get_proc_info() :