/* Copyright (C) 1979-1996 TcX AB & Monty Program KB & Detron HB

   This software is distributed with NO WARRANTY OF ANY KIND.  No author or
   distributor accepts any responsibility for the consequences of using it, or
   for whether it serves any particular purpose or works at all, unless he or
   she says so in writing.  Refer to the Free Public License (the "License")
   for full details.

   Every copy of this file must include a copy of the License, normally in a
   plain ASCII text file named PUBLIC.	The License grants you the right to
   copy, modify and redistribute this file, but only under certain conditions
   described in the License.  Among other things, the License requires that
   the copyright notice and this notice be preserved on all copies. */

/* Write some debug info */


#include "mysql_priv.h"
#include "sql_select.h"
#include <hash.h>

/* Intern key cache variables */
extern "C" pthread_mutex_t THR_LOCK_keycache;
extern "C" ulong _my_cache_w_requests,_my_cache_write,_my_cache_r_requests,
		_my_cache_read;
extern "C" uint	_my_blocks_used,_my_blocks_changed;
extern "C" int	my_file_opened,my_stream_opened;

#ifndef DBUG_OFF
extern "C" {
extern pthread_mutex_t THR_LOCK_dbug;
}

void
print_where(COND *cond,char *info)
{
  if (cond)
  {
    char buff[256];
    String str(buff,(uint32) sizeof(buff));
    str.length(0);
    cond->print(&str);
    str.append('\0');
    pthread_mutex_lock(&THR_LOCK_dbug);
    (void) fprintf(DBUG_FILE,"\nWHERE:(%s) ",info);
    (void) fputs(str.ptr(),DBUG_FILE);
    (void) fputc('\n',DBUG_FILE);
    pthread_mutex_unlock(&THR_LOCK_dbug);
  }
}

	/* This is for debugging purposes */

extern HASH open_cache;
extern TABLE *unused_tables;

void print_cached_tables(void)
{
  uint index,count,unused;
  TABLE *start_link,*link;

  VOID(pthread_mutex_lock(&LOCK_open));
  puts("DB         Table                             Version  Thread  L.thread  Open");

  for (index=unused=0 ; index < open_cache.records ; index++)
  {
    TABLE *entry=(TABLE*) hash_element(&open_cache,index);
    printf("%-10s %-34s%6ld%8ld%10ld%6d\n",
	   entry->table_cache_key,entry->real_name,entry->version,
	   entry->in_use ? entry->in_use->thread_id : 0L,
	   entry->in_use ? entry->in_use->dbug_thread_id : 0L,
	   entry->db_stat ? 1 : 0);
    if (!entry->in_use)
      unused++;
  }
  count=0;
  if ((start_link=link=unused_tables))
  {
    do
    {
      if (link != link->next->prev || link != link->prev->next)
      {
	printf("unused_links isn't linked properly\n");
	return;
      }
    } while (count++ < open_cache.records && (link=link->next) != start_link);
    if (link != start_link)
    {
      printf("Unused_links aren't connected\n");
    }
  }
  if (count != unused)
    printf("Unused_links (%d) dosen't match open_cache: %d\n", count,unused);
  printf("\nCurrent refresh version: %ld\n",refresh_version);
  if (hash_check(&open_cache))
    printf("Error: File hash table is corrupted\n");
  fflush(stdout);
  VOID(pthread_mutex_unlock(&LOCK_open));
  return;
}


void TEST_filesort(TABLE **table,SORT_FIELD *sortorder,uint s_length,
		   ulong special)
{
  char buff[256],buff2[256];
  String str(buff,sizeof(buff)),out(buff2,sizeof(buff2));
  my_string sep;
  DBUG_ENTER("TEST_filesort");

  out.length(0);
  for (sep=""; s_length-- ; sortorder++, sep=" ")
  {
    out.append(sep);
    if (sortorder->reverse)
      out.append('-');
    if (sortorder->field)
    {
      if (sortorder->field->table_name)
      {
	out.append(sortorder->field->table_name);
	out.append('.');
      }
      out.append(sortorder->field->field_name);
    }
    else
    {
      str.length(0);
      sortorder->item->print(&str);
      out.append(str);
    }
  }
  out.append('\0');				// Purify doesn't like c_ptr()
  pthread_mutex_lock(&THR_LOCK_dbug);
  VOID(fputs("\nInfo about FILESORT\n",DBUG_FILE));
  if (special)
    fprintf(DBUG_FILE,"Records to sort: %ld\n",special);
  fprintf(DBUG_FILE,"Sortorder: %s\n",out.ptr());
  pthread_mutex_unlock(&THR_LOCK_dbug);
  DBUG_VOID_RETURN;
}


void
TEST_join(JOIN *join)
{
  uint i,ref;
  DBUG_ENTER("TEST_join");

  pthread_mutex_lock(&THR_LOCK_dbug);
  VOID(fputs("\nInfo about JOIN\n",DBUG_FILE));
  for (i=0 ; i < join->tables ; i++)
  {
    TABLE *form=join->join_tab[i].table;

    fprintf(DBUG_FILE,"%-16.16s  type: %-7s  q_keys: %4d  refs: %d  key: %d  len: %d\n",
	    form->table_name,
	    join_type_str[join->join_tab[i].type],
	    join->join_tab[i].keys,
	    form->reginfo.ref_fields,
	    form->reginfo.ref_key,
	    form->reginfo.ref_length);
    if (join->join_tab[i].select)
    {
      if (join->join_tab[i].use_quick == 2)
	fprintf(DBUG_FILE,
		"                  quick select checked for each record (keys: %d)\n",
		(int) join->join_tab[i].select->quick_keys);
      else if (join->join_tab[i].select->quick)
	fprintf(DBUG_FILE,"                  quick select used on key %s\n",
		form->key_info[join->join_tab[i].select->quick->index].name);
      else
	VOID(fputs("                  select used\n",DBUG_FILE));
    }
    if (form->reginfo.ref_fields)
    {
      VOID(fputs("                  refs: ",DBUG_FILE));
      for (ref=0 ; ref < form->reginfo.ref_fields ; ref++)
      {
	Field *field=form->reginfo.ref_field[ref].field;
	if (field)
	{
	  if (field->table_name)
	  {
	    fputs(field->table_name,DBUG_FILE);
	    VOID(fputc('.',DBUG_FILE));
	  }
	  fprintf(DBUG_FILE,"%s  ", field->field_name);
	}
	else
	{
	  char buff[MAX_FIELD_WIDTH];
	  String tmp(buff,sizeof(buff));
	  field->val_str(&tmp,&tmp);
	  fprintf(DBUG_FILE,"'%s' ",tmp.c_ptr());
	}
      }
      VOID(fputc('\n',DBUG_FILE));
    }
  }
  pthread_mutex_unlock(&THR_LOCK_dbug);
  DBUG_VOID_RETURN;
}

#endif

void mysql_print_status(void)
{
  printf("\nStatus information:\n\n");
  thr_print_locks();				// Write some debug info
#ifndef DBUG_OFF
  print_cached_tables();
#endif
  /* Print key cache status */
  pthread_mutex_lock(&THR_LOCK_keycache);
  printf("key_cache status:\n\
blocks used:%10u\n\
not flushed:%10u\n\
w_requests: %10lu\n\
writes:     %10lu\n\
r_requests: %10lu\n\
reads:      %10lu\n",
	 _my_blocks_used,_my_blocks_changed,_my_cache_w_requests,
	 _my_cache_write,_my_cache_r_requests,_my_cache_read);
  pthread_mutex_unlock(&THR_LOCK_keycache);

  pthread_mutex_lock(&LOCK_status);
  printf("\nhandler status:\n\
read_key:   %10lu\n\
read_next:  %10lu\n\
read_rnd    %10lu\n\
read_first: %10lu\n\
write:      %10lu\n\
delete      %10lu\n\
update:     %10lu\n",
	 ha_read_key_count, ha_read_next_count,
	 ha_read_rnd_count, ha_read_first_count,
	 ha_write_count, ha_delete_count, ha_update_count);
  pthread_mutex_unlock(&LOCK_status);
  printf("\nTable status:\n\
Opened tables: %10lu\n\
Open tables:   %10lu\n\
Open files:    %10lu\n\
Open streams:  %10lu\n",
	 opened_tables,
	 cached_tables(),
	 my_file_opened,
	 my_stream_opened);
  fflush(stdout);
  TERMINATE(stdout);				// Write malloc information
}