← 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-12-30 19:10:09 UTC
  • mfrom: (1245.2.7 remove-ilist)
  • Revision ID: brian@gaz-20091230191009-ulqzmoln5q530e6a
Merge Monty.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/show.cc
701
701
  returns for each thread: thread id, user, host, db, command, info
702
702
****************************************************************************/
703
703
 
704
 
class thread_info :public ilink {
 
704
class thread_info
 
705
{
 
706
  thread_info();
705
707
public:
706
 
  static void *operator new(size_t size)
707
 
  {
708
 
    return (void*) memory::sql_alloc((uint32_t) size);
709
 
  }
710
 
  static void operator delete(void *, size_t)
711
 
  { }
712
 
 
713
708
  uint64_t thread_id;
714
709
  time_t start_time;
715
710
  uint32_t   command;
716
 
  const char *user,*host,*db,*proc_info,*state_info;
717
 
  char *query;
 
711
  string user, host, db, proc_info, state_info, query;
 
712
  thread_info(uint64_t thread_id_arg,
 
713
              time_t start_time_arg,
 
714
              uint32_t command_arg,
 
715
              const string &user_arg,
 
716
              const string &host_arg,
 
717
              const string &db_arg,
 
718
              const string &proc_info_arg,
 
719
              const string &state_info_arg,
 
720
              const string &query_arg)
 
721
    : thread_id(thread_id_arg), start_time(start_time_arg), command(command_arg),
 
722
      user(user_arg), host(host_arg), db(db_arg), proc_info(proc_info_arg),
 
723
      state_info(state_info_arg), query(query_arg)
 
724
  {}
718
725
};
719
726
 
720
 
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
721
 
template class I_List<thread_info>;
722
 
#endif
723
 
 
724
727
void mysqld_list_processes(Session *session,const char *user, bool)
725
728
{
726
729
  Item *field;
727
730
  List<Item> field_list;
728
 
  I_List<thread_info> thread_infos;
 
731
  vector<thread_info> thread_infos;
729
732
 
730
733
  field_list.push_back(new Item_int("Id", 0, MY_INT32_NUM_DECIMAL_DIGITS));
731
734
  field_list.push_back(new Item_empty_string("User",16));
752
755
      struct st_my_thread_var *mysys_var;
753
756
      if (tmp->client->isConnected() && (!user || (tmp_sctx->user.c_str() && !strcmp(tmp_sctx->user.c_str(), user))))
754
757
      {
755
 
        thread_info *session_info= new thread_info;
756
758
 
757
 
        session_info->thread_id=tmp->thread_id;
758
 
        session_info->user= session->strdup(tmp_sctx->user.c_str() ? tmp_sctx->user.c_str() : "unauthenticated user");
759
 
        session_info->host= session->strdup(tmp_sctx->ip.c_str());
760
 
        if ((session_info->db= tmp->db.c_str()))             // Safe test
761
 
          session_info->db=session->strdup(session_info->db);
762
 
        session_info->command=(int) tmp->command;
763
759
        if ((mysys_var= tmp->mysys_var))
764
760
          pthread_mutex_lock(&mysys_var->mutex);
765
761
 
766
 
        if (tmp->killed == Session::KILL_CONNECTION)
767
 
          session_info->proc_info= (char*) "Killed";
768
 
        else
769
 
          session_info->proc_info= command_name[session_info->command].str;
 
762
        const string tmp_proc_info((tmp->killed == Session::KILL_CONNECTION) ? "Killed" : command_name[tmp->command].str);
770
763
 
771
 
        session_info->state_info= (char*) (tmp->client->isWriting() ?
772
 
                                           "Writing to net" :
773
 
                                           tmp->client->isReading() ?
774
 
                                           (session_info->command == COM_SLEEP ?
775
 
                                            NULL : "Reading from net") :
776
 
                                       tmp->get_proc_info() ? tmp->get_proc_info() :
777
 
                                       tmp->mysys_var &&
778
 
                                       tmp->mysys_var->current_cond ?
779
 
                                       "Waiting on cond" : NULL);
 
764
        const string tmp_state_info(tmp->client->isWriting()
 
765
                                     ? "Writing to net"
 
766
                                     : tmp->client->isReading()
 
767
                                       ? (tmp->command == COM_SLEEP
 
768
                                            ? ""
 
769
                                            : "Reading from net")
 
770
                                       : tmp->get_proc_info()
 
771
                                         ? tmp->get_proc_info()
 
772
                                         : (tmp->mysys_var && tmp->mysys_var->current_cond)
 
773
                                           ? "Waiting on cond"
 
774
                                           : "");
780
775
        if (mysys_var)
781
776
          pthread_mutex_unlock(&mysys_var->mutex);
782
777
 
783
 
        session_info->start_time= tmp->start_time;
784
 
        session_info->query= NULL;
785
 
        if (tmp->process_list_info[0])
786
 
          session_info->query= session->strdup(tmp->process_list_info);
787
 
        thread_infos.append(session_info);
 
778
        const string tmp_query((tmp->process_list_info[0]) ? tmp->process_list_info : "");
 
779
        thread_infos.push_back(thread_info(tmp->thread_id,
 
780
                                           tmp->start_time,
 
781
                                           tmp->command,
 
782
                                           tmp_sctx->user.empty()
 
783
                                             ? string("unauthenticated user")
 
784
                                             : tmp_sctx->user,
 
785
                                           tmp_sctx->ip,
 
786
                                           tmp->db,
 
787
                                           tmp_proc_info,
 
788
                                           tmp_state_info,
 
789
                                           tmp_query));
788
790
      }
789
791
    }
790
792
  }
791
793
  pthread_mutex_unlock(&LOCK_thread_count);
792
 
 
793
 
  thread_info *session_info;
794
794
  time_t now= time(NULL);
795
 
  while ((session_info=thread_infos.get()))
 
795
  for(vector<thread_info>::iterator iter= thread_infos.begin();
 
796
      iter != thread_infos.end();
 
797
      ++iter)
796
798
  {
797
 
    session->client->store((uint64_t) session_info->thread_id);
798
 
    session->client->store(session_info->user);
799
 
    session->client->store(session_info->host);
800
 
    session->client->store(session_info->db);
801
 
    session->client->store(session_info->proc_info);
 
799
    session->client->store((uint64_t) (*iter).thread_id);
 
800
    session->client->store((*iter).user);
 
801
    session->client->store((*iter).host);
 
802
    session->client->store((*iter).db);
 
803
    session->client->store((*iter).proc_info);
802
804
 
803
 
    if (session_info->start_time)
804
 
      session->client->store((uint32_t) (now - session_info->start_time));
 
805
    if ((*iter).start_time)
 
806
      session->client->store((uint32_t) (now - (*iter).start_time));
805
807
    else
806
808
      session->client->store();
807
809
 
808
 
    session->client->store(session_info->state_info);
809
 
    session->client->store(session_info->query);
 
810
    session->client->store((*iter).state_info);
 
811
    session->client->store((*iter).query);
810
812
 
811
813
    if (session->client->flush())
812
814
      break;
813
815
  }
814
816
  session->my_eof();
 
817
 
815
818
  return;
816
819
}
817
820