← 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-04-09 01:50:49 UTC
  • mfrom: (971.3.21 eday-dev)
  • Revision ID: brian@gaz-20090409015049-ohyn58r972hkccj2
Merge Eric

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/show.cc
359
359
                                               cmax(buffer.length(),(uint32_t)1024)));
360
360
  }
361
361
 
362
 
  if (protocol->send_fields(&field_list,
363
 
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
 
362
  if (protocol->sendFields(&field_list,
 
363
                           Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
364
364
  {
365
365
    return(true);
366
366
  }
367
 
  protocol->prepare_for_resend();
 
367
  protocol->prepareForResend();
368
368
  {
369
369
    if (table_list->schema_table)
370
370
      protocol->store(table_list->schema_table->table_name,
403
403
  field_list.push_back(new Item_empty_string("Database",NAME_CHAR_LEN));
404
404
  field_list.push_back(new Item_empty_string("Create Database",1024));
405
405
 
406
 
  if (protocol->send_fields(&field_list,
407
 
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
 
406
  if (protocol->sendFields(&field_list,
 
407
                           Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
408
408
    return(true);
409
409
 
410
 
  protocol->prepare_for_resend();
 
410
  protocol->prepareForResend();
411
411
  protocol->store(dbname, strlen(dbname), system_charset_info);
412
412
  protocol->store(buffer.ptr(), buffer.length(), buffer.charset());
413
413
 
446
446
  }
447
447
  restore_record(table, s->default_values);              // Get empty record
448
448
  table->use_all_columns();
449
 
  if (session->protocol->send_fields(&field_list, Protocol::SEND_DEFAULTS))
 
449
  if (session->protocol->sendFields(&field_list, Protocol::SEND_DEFAULTS))
450
450
    return;
451
451
  session->my_eof();
452
452
  return;
1028
1028
  field->maybe_null= true;
1029
1029
  field_list.push_back(field=new Item_empty_string("Info", PROCESS_LIST_WIDTH));
1030
1030
  field->maybe_null= true;
1031
 
  if (protocol->send_fields(&field_list,
1032
 
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
 
1031
  if (protocol->sendFields(&field_list,
 
1032
                           Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
1033
1033
    return;
1034
1034
 
1035
1035
  pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
1041
1041
    {
1042
1042
      Security_context *tmp_sctx= &tmp->security_ctx;
1043
1043
      struct st_my_thread_var *mysys_var;
1044
 
      if (tmp->protocol->io_ok() && (!user || (tmp_sctx->user.c_str() && !strcmp(tmp_sctx->user.c_str(), user))))
 
1044
      if (tmp->protocol->isConnected() && (!user || (tmp_sctx->user.c_str() && !strcmp(tmp_sctx->user.c_str(), user))))
1045
1045
      {
1046
1046
        thread_info *session_info= new thread_info;
1047
1047
 
1053
1053
        session_info->command=(int) tmp->command;
1054
1054
        if ((mysys_var= tmp->mysys_var))
1055
1055
          pthread_mutex_lock(&mysys_var->mutex);
1056
 
        session_info->proc_info= (char*) (tmp->killed == Session::KILL_CONNECTION? "Killed" : 0);
1057
 
        session_info->state_info= (char*) (tmp->protocol->is_writing() ?
 
1056
 
 
1057
        if (tmp->killed == Session::KILL_CONNECTION)
 
1058
          session_info->proc_info= (char*) "Killed";
 
1059
        else
 
1060
          session_info->proc_info= command_name[session_info->command].str;
 
1061
 
 
1062
        session_info->state_info= (char*) (tmp->protocol->isWriting() ?
1058
1063
                                           "Writing to net" :
1059
 
                                           tmp->protocol->is_reading() ?
 
1064
                                           tmp->protocol->isReading() ?
1060
1065
                                           (session_info->command == COM_SLEEP ?
1061
1066
                                            NULL : "Reading from net") :
1062
1067
                                       tmp->get_proc_info() ? tmp->get_proc_info() :
1088
1093
  time_t now= time(NULL);
1089
1094
  while ((session_info=thread_infos.get()))
1090
1095
  {
1091
 
    protocol->prepare_for_resend();
 
1096
    protocol->prepareForResend();
1092
1097
    protocol->store((uint64_t) session_info->thread_id);
1093
1098
    protocol->store(session_info->user, system_charset_info);
1094
1099
    protocol->store(session_info->host, system_charset_info);
1095
1100
    protocol->store(session_info->db, system_charset_info);
1096
 
    if (session_info->proc_info)
1097
 
      protocol->store(session_info->proc_info, system_charset_info);
1098
 
    else
1099
 
      protocol->store(command_name[session_info->command].str, system_charset_info);
 
1101
    protocol->store(session_info->proc_info, system_charset_info);
 
1102
 
1100
1103
    if (session_info->start_time)
1101
1104
      protocol->store((uint32_t) (now - session_info->start_time));
1102
1105
    else
1103
 
      protocol->store_null();
 
1106
      protocol->store();
 
1107
 
1104
1108
    protocol->store(session_info->state_info, system_charset_info);
1105
1109
    protocol->store(session_info->query, system_charset_info);
 
1110
 
1106
1111
    if (protocol->write())
1107
1112
      break; /* purecov: inspected */
1108
1113
  }
1135
1140
      struct st_my_thread_var *mysys_var;
1136
1141
      const char *val;
1137
1142
 
1138
 
      if (! tmp->protocol->io_ok())
 
1143
      if (! tmp->protocol->isConnected())
1139
1144
        continue;
1140
1145
 
1141
1146
      restore_record(table, s->default_values);
1165
1170
      table->field[5]->store((uint32_t)(tmp->start_time ?
1166
1171
                                      now - tmp->start_time : 0), true);
1167
1172
      /* STATE */
1168
 
      val= (char*) (tmp->protocol->is_writing() ?
 
1173
      val= (char*) (tmp->protocol->isWriting() ?
1169
1174
                    "Writing to net" :
1170
 
                    tmp->protocol->is_reading() ?
 
1175
                    tmp->protocol->isReading() ?
1171
1176
                    (tmp->command == COM_SLEEP ?
1172
1177
                     NULL : "Reading from net") :
1173
1178
                    tmp->get_proc_info() ? tmp->get_proc_info() :