home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / sql / sql_test.cpp < prev    next >
C/C++ Source or Header  |  2000-08-31  |  7KB  |  247 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  16.  
  17.  
  18. /* Write some debug info */
  19.  
  20.  
  21. #include "mysql_priv.h"
  22. #include "sql_select.h"
  23. #include <hash.h>
  24.  
  25. /* Intern key cache variables */
  26. extern "C" pthread_mutex_t THR_LOCK_keycache;
  27.  
  28. #ifndef DBUG_OFF
  29.  
  30. void
  31. print_where(COND *cond,const char *info)
  32. {
  33.   if (cond)
  34.   {
  35.     char buff[256];
  36.     String str(buff,(uint32) sizeof(buff));
  37.     str.length(0);
  38.     cond->print(&str);
  39.     str.append('\0');
  40.     DBUG_LOCK_FILE;
  41.     (void) fprintf(DBUG_FILE,"\nWHERE:(%s) ",info);
  42.     (void) fputs(str.ptr(),DBUG_FILE);
  43.     (void) fputc('\n',DBUG_FILE);
  44.     DBUG_UNLOCK_FILE;
  45.   }
  46. }
  47.  
  48.     /* This is for debugging purposes */
  49.  
  50. extern HASH open_cache;
  51. extern TABLE *unused_tables;
  52.  
  53. void print_cached_tables(void)
  54. {
  55.   uint idx,count,unused;
  56.   TABLE *start_link,*lnk;
  57.  
  58.   VOID(pthread_mutex_lock(&LOCK_open));
  59.   puts("DB             Table                            Version  Thread  L.thread  Open");
  60.  
  61.   for (idx=unused=0 ; idx < open_cache.records ; idx++)
  62.   {
  63.     TABLE *entry=(TABLE*) hash_element(&open_cache,idx);
  64.     printf("%-14.14s %-32s%6ld%8ld%10ld%6d\n",
  65.        entry->table_cache_key,entry->real_name,entry->version,
  66.        entry->in_use ? entry->in_use->thread_id : 0L,
  67.        entry->in_use ? entry->in_use->dbug_thread_id : 0L,
  68.        entry->db_stat ? 1 : 0);
  69.     if (!entry->in_use)
  70.       unused++;
  71.   }
  72.   count=0;
  73.   if ((start_link=lnk=unused_tables))
  74.   {
  75.     do
  76.     {
  77.       if (lnk != lnk->next->prev || lnk != lnk->prev->next)
  78.       {
  79.     printf("unused_links isn't linked properly\n");
  80.     return;
  81.       }
  82.     } while (count++ < open_cache.records && (lnk=lnk->next) != start_link);
  83.     if (lnk != start_link)
  84.     {
  85.       printf("Unused_links aren't connected\n");
  86.     }
  87.   }
  88.   if (count != unused)
  89.     printf("Unused_links (%d) doesn't match open_cache: %d\n", count,unused);
  90.   printf("\nCurrent refresh version: %ld\n",refresh_version);
  91.   if (hash_check(&open_cache))
  92.     printf("Error: File hash table is corrupted\n");
  93.   fflush(stdout);
  94.   VOID(pthread_mutex_unlock(&LOCK_open));
  95.   return;
  96. }
  97.  
  98.  
  99. void TEST_filesort(TABLE **table,SORT_FIELD *sortorder,uint s_length,
  100.            ha_rows special)
  101. {
  102.   char buff[256],buff2[256];
  103.   String str(buff,sizeof(buff)),out(buff2,sizeof(buff2));
  104.   const char *sep;
  105.   DBUG_ENTER("TEST_filesort");
  106.  
  107.   out.length(0);
  108.   for (sep=""; s_length-- ; sortorder++, sep=" ")
  109.   {
  110.     out.append(sep);
  111.     if (sortorder->reverse)
  112.       out.append('-');
  113.     if (sortorder->field)
  114.     {
  115.       if (sortorder->field->table_name)
  116.       {
  117.     out.append(sortorder->field->table_name);
  118.     out.append('.');
  119.       }
  120.       out.append(sortorder->field->field_name ? sortorder->field->field_name:
  121.          "tmp_table_column");
  122.     }
  123.     else
  124.     {
  125.       str.length(0);
  126.       sortorder->item->print(&str);
  127.       out.append(str);
  128.     }
  129.   }
  130.   out.append('\0');                // Purify doesn't like c_ptr()
  131.   DBUG_LOCK_FILE;
  132.   VOID(fputs("\nInfo about FILESORT\n",DBUG_FILE));
  133.   if (special)
  134.     fprintf(DBUG_FILE,"Records to sort: %ld\n",special);
  135.   fprintf(DBUG_FILE,"Sortorder: %s\n",out.ptr());
  136.   DBUG_UNLOCK_FILE;
  137.   DBUG_VOID_RETURN;
  138. }
  139.  
  140.  
  141. void
  142. TEST_join(JOIN *join)
  143. {
  144.   uint i,ref;
  145.   DBUG_ENTER("TEST_join");
  146.  
  147.   DBUG_LOCK_FILE;
  148.   VOID(fputs("\nInfo about JOIN\n",DBUG_FILE));
  149.   for (i=0 ; i < join->tables ; i++)
  150.   {
  151.     JOIN_TAB *tab=join->join_tab+i;
  152.     TABLE *form=tab->table;
  153.     fprintf(DBUG_FILE,"%-16.16s  type: %-7s  q_keys: %4d  refs: %d  key: %d  len: %d\n",
  154.         form->table_name,
  155.         join_type_str[tab->type],
  156.         tab->keys,
  157.         tab->ref.key_parts,
  158.         tab->ref.key,
  159.         tab->ref.key_length);
  160.     if (tab->select)
  161.     {
  162.       if (tab->use_quick == 2)
  163.     fprintf(DBUG_FILE,
  164.         "                  quick select checked for each record (keys: %d)\n",
  165.         (int) tab->select->quick_keys);
  166.       else if (tab->select->quick)
  167.     fprintf(DBUG_FILE,"                  quick select used on key %s, length: %d\n",
  168.         form->key_info[tab->select->quick->index].name,
  169.         tab->select->quick->max_used_key_length);
  170.       else
  171.     VOID(fputs("                  select used\n",DBUG_FILE));
  172.     }
  173.     if (tab->ref.key_parts)
  174.     {
  175.       VOID(fputs("                  refs: ",DBUG_FILE));
  176.       for (ref=0 ; ref < tab->ref.key_parts ; ref++)
  177.       {
  178.     Item *item=tab->ref.items[ref];
  179.     fprintf(DBUG_FILE,"%s  ", item->full_name());
  180.       }
  181.       VOID(fputc('\n',DBUG_FILE));
  182.     }
  183.   }
  184.   DBUG_UNLOCK_FILE;
  185.   DBUG_VOID_RETURN;
  186. }
  187.  
  188. #endif
  189.  
  190. void mysql_print_status(THD *thd)
  191. {
  192.   printf("\nStatus information:\n\n");
  193.   if (thd)
  194.     thd->proc_info="locks";
  195.   thr_print_locks();                // Write some debug info
  196. #ifndef DBUG_OFF
  197.   if (thd)
  198.     thd->proc_info="table cache";
  199.   print_cached_tables();
  200. #endif
  201.   /* Print key cache status */
  202.   if (thd)
  203.     thd->proc_info="key cache";
  204.   pthread_mutex_lock(&THR_LOCK_keycache);
  205.   printf("key_cache status:\n\
  206. blocks used:%10lu\n\
  207. not flushed:%10lu\n\
  208. w_requests: %10lu\n\
  209. writes:     %10lu\n\
  210. r_requests: %10lu\n\
  211. reads:      %10lu\n",
  212.      _my_blocks_used,_my_blocks_changed,_my_cache_w_requests,
  213.      _my_cache_write,_my_cache_r_requests,_my_cache_read);
  214.   pthread_mutex_unlock(&THR_LOCK_keycache);
  215.  
  216.   if (thd)
  217.     thd->proc_info="status";
  218.   pthread_mutex_lock(&LOCK_status);
  219.   printf("\nhandler status:\n\
  220. read_key:   %10lu\n\
  221. read_next:  %10lu\n\
  222. read_rnd    %10lu\n\
  223. read_first: %10lu\n\
  224. write:      %10lu\n\
  225. delete      %10lu\n\
  226. update:     %10lu\n",
  227.      ha_read_key_count, ha_read_next_count,
  228.      ha_read_rnd_count, ha_read_first_count,
  229.      ha_write_count, ha_delete_count, ha_update_count);
  230.   pthread_mutex_unlock(&LOCK_status);
  231.   printf("\nTable status:\n\
  232. Opened tables: %10lu\n\
  233. Open tables:   %10lu\n\
  234. Open files:    %10lu\n\
  235. Open streams:  %10lu\n",
  236.      opened_tables,
  237.      (ulong) cached_tables(),
  238.      (ulong) my_file_opened,
  239.      (ulong) my_stream_opened);
  240.   fflush(stdout);
  241.   if (thd)
  242.     thd->proc_info="malloc";
  243.   TERMINATE(stdout);                // Write malloc information
  244.   if (thd)
  245.     thd->proc_info=0;
  246. }
  247.