~drizzle-trunk/drizzle/development

/* Copyright (C) 2000-2004 MySQL AB

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/* Function with list databases, tables or fields */

#include "mysql_priv.h"

#include "sql_select.h"                         // For select_describe

#include "sql_show.h"

#include "repl_failsafe.h"

#include <my_dir.h>

#define STR_OR_NIL(S) ((S) ? (S) : "<nil>")

/* Match the values of enum ha_choice */

static const char *ha_choice_values[] = {"", "0", "1"};

static void store_key_options(THD *thd, String *packet, TABLE *table,

                              KEY *key_info);

int wild_case_compare(CHARSET_INFO *cs, const char *str,const char *wildstr)

{

  register int flag;

  DBUG_ENTER("wild_case_compare");

  DBUG_PRINT("enter",("str: '%s'  wildstr: '%s'",str,wildstr));

  while (*wildstr)

  {

    while (*wildstr && *wildstr != wild_many && *wildstr != wild_one)

    {

      if (*wildstr == wild_prefix && wildstr[1])

	wildstr++;

      if (my_toupper(cs, *wildstr++) !=

          my_toupper(cs, *str++)) DBUG_RETURN(1);

    }

    if (! *wildstr ) DBUG_RETURN (*str != 0);

    if (*wildstr++ == wild_one)

    {

      if (! *str++) DBUG_RETURN (1);	/* One char; skip */

    }

    else

    {						/* Found '*' */

      if (!*wildstr) DBUG_RETURN(0);		/* '*' as last char: OK */

      flag=(*wildstr != wild_many && *wildstr != wild_one);

      do

      {

	if (flag)

	{

	  char cmp;

	  if ((cmp= *wildstr) == wild_prefix && wildstr[1])

	    cmp=wildstr[1];

	  cmp=my_toupper(cs, cmp);

	  while (*str && my_toupper(cs, *str) != cmp)

	    str++;

	  if (!*str) DBUG_RETURN (1);

	}

	if (wild_case_compare(cs, str,wildstr) == 0) DBUG_RETURN (0);

      } while (*str++);

      DBUG_RETURN(1);

    }

  }

  DBUG_RETURN (*str != '\0');

}

/***************************************************************************

** List all table types supported

***************************************************************************/

static int make_version_string(char *buf, int buf_length, uint version)

{

  return my_snprintf(buf, buf_length, "%d.%d", version>>8,version&0xff);

}

static my_bool show_plugins(THD *thd, plugin_ref plugin,

                            void *arg)

{

  TABLE *table= (TABLE*) arg;

  struct st_mysql_plugin *plug= plugin_decl(plugin);

  struct st_plugin_dl *plugin_dl= plugin_dlib(plugin);

  CHARSET_INFO *cs= system_charset_info;

  char version_buf[20];

  restore_record(table, s->default_values);

  table->field[0]->store(plugin_name(plugin)->str,

                         plugin_name(plugin)->length, cs);

  table->field[1]->store(version_buf,

        make_version_string(version_buf, sizeof(version_buf), plug->version),

        cs);

  switch (plugin_state(plugin)) {

  /* case PLUGIN_IS_FREED: does not happen */

  case PLUGIN_IS_DELETED:

    table->field[2]->store(STRING_WITH_LEN("DELETED"), cs);

    break;

  case PLUGIN_IS_UNINITIALIZED:

    table->field[2]->store(STRING_WITH_LEN("INACTIVE"), cs);

    break;

  case PLUGIN_IS_READY:

    table->field[2]->store(STRING_WITH_LEN("ACTIVE"), cs);

    break;

  default:

    DBUG_ASSERT(0);

  }

  table->field[3]->store(plugin_type_names[plug->type].str,

                         plugin_type_names[plug->type].length,

                         cs);

  table->field[4]->store(version_buf,

        make_version_string(version_buf, sizeof(version_buf),

                            *(uint *)plug->info), cs);

  if (plugin_dl)

  {

    table->field[5]->store(plugin_dl->dl.str, plugin_dl->dl.length, cs);

    table->field[5]->set_notnull();

    table->field[6]->store(version_buf,

          make_version_string(version_buf, sizeof(version_buf),

                              plugin_dl->version),

          cs);

    table->field[6]->set_notnull();

  }

  else

  {

    table->field[5]->set_null();

    table->field[6]->set_null();

  }

  if (plug->author)

  {

    table->field[7]->store(plug->author, strlen(plug->author), cs);

    table->field[7]->set_notnull();

  }

  else

    table->field[7]->set_null();

  if (plug->descr)

  {

    table->field[8]->store(plug->descr, strlen(plug->descr), cs);

    table->field[8]->set_notnull();

  }

  else

    table->field[8]->set_null();

  switch (plug->license) {

  case PLUGIN_LICENSE_GPL:

    table->field[9]->store(PLUGIN_LICENSE_GPL_STRING, 

                           strlen(PLUGIN_LICENSE_GPL_STRING), cs);

    break;

  case PLUGIN_LICENSE_BSD:

    table->field[9]->store(PLUGIN_LICENSE_BSD_STRING, 

                           strlen(PLUGIN_LICENSE_BSD_STRING), cs);

    break;

  default:

    table->field[9]->store(PLUGIN_LICENSE_PROPRIETARY_STRING, 

                           strlen(PLUGIN_LICENSE_PROPRIETARY_STRING), cs);

    break;

  }

  table->field[9]->set_notnull();

  return schema_table_store_record(thd, table);

}

int fill_plugins(THD *thd, TABLE_LIST *tables, COND *cond)

{

  DBUG_ENTER("fill_plugins");

  TABLE *table= tables->table;

  if (plugin_foreach_with_mask(thd, show_plugins, MYSQL_ANY_PLUGIN,

                               ~PLUGIN_IS_FREED, table))

    DBUG_RETURN(1);

  DBUG_RETURN(0);

}

/*

  find_files() - find files in a given directory.

  SYNOPSIS

    find_files()

    thd                 thread handler

    files               put found files in this list

    db                  database name to set in TABLE_LIST structure

    path                path to database

    wild                filter for found files

    dir                 read databases in path if TRUE, read .frm files in

                        database otherwise

  RETURN

    FIND_FILES_OK       success

    FIND_FILES_OOM      out of memory error

    FIND_FILES_DIR      no such directory, or directory can't be read

*/

find_files_result

find_files(THD *thd, List<LEX_STRING> *files, const char *db,

           const char *path, const char *wild, bool dir)

{

  uint i;

  char *ext;

  MY_DIR *dirp;

  FILEINFO *file;

  LEX_STRING *file_name= 0;

  uint file_name_len;

  TABLE_LIST table_list;

  DBUG_ENTER("find_files");

  if (wild && !wild[0])

    wild=0;

  bzero((char*) &table_list,sizeof(table_list));

  if (!(dirp = my_dir(path,MYF(dir ? MY_WANT_STAT : 0))))

  {

    if (my_errno == ENOENT)

      my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), db);

    else

      my_error(ER_CANT_READ_DIR, MYF(ME_BELL+ME_WAITTANG), path, my_errno);

    DBUG_RETURN(FIND_FILES_DIR);

  }

  for (i=0 ; i < (uint) dirp->number_off_files  ; i++)

  {

    char uname[NAME_LEN + 1];                   /* Unencoded name */

    file=dirp->dir_entry+i;

    if (dir)

    {                                           /* Return databases */

      if ((file->name[0] == '.' && 

          ((file->name[1] == '.' && file->name[2] == '\0') ||

            file->name[1] == '\0')))

        continue;                               /* . or .. */

#ifdef USE_SYMDIR

      char *ext;

      char buff[FN_REFLEN];

      if (my_use_symdir && !strcmp(ext=fn_ext(file->name), ".sym"))

      {

	/* Only show the sym file if it points to a directory */

	char *end;

        *ext=0;                                 /* Remove extension */

	unpack_dirname(buff, file->name);

	end= strend(buff);

	if (end != buff && end[-1] == FN_LIBCHAR)

	  end[-1]= 0;				// Remove end FN_LIBCHAR

        if (stat(buff, file->mystat))

               continue;

       }

#endif

      if (!MY_S_ISDIR(file->mystat->st_mode))

        continue;

      file_name_len= filename_to_tablename(file->name, uname, sizeof(uname));

      if (wild && wild_compare(uname, wild, 0))

        continue;

      if (!(file_name= 

            thd->make_lex_string(file_name, uname, file_name_len, TRUE)))

      {

        my_dirend(dirp);

        DBUG_RETURN(FIND_FILES_OOM);

      }

    }

    else

    {

        // Return only .frm files which aren't temp files.

      if (my_strcasecmp(system_charset_info, ext=fn_rext(file->name),reg_ext) ||

          is_prefix(file->name, tmp_file_prefix))

        continue;

      *ext=0;

      file_name_len= filename_to_tablename(file->name, uname, sizeof(uname));

      if (wild)

      {

	if (lower_case_table_names)

	{

	  if (wild_case_compare(files_charset_info, uname, wild))

	    continue;

	}

	else if (wild_compare(uname, wild, 0))

	  continue;

      }

    }

    if (!(file_name= 

          thd->make_lex_string(file_name, uname, file_name_len, TRUE)) ||

        files->push_back(file_name))

    {

      my_dirend(dirp);

      DBUG_RETURN(FIND_FILES_OOM);

    }

  }

  DBUG_PRINT("info",("found: %d files", files->elements));

  my_dirend(dirp);

  DBUG_RETURN(FIND_FILES_OK);

}

bool

mysqld_show_create(THD *thd, TABLE_LIST *table_list)

{

  Protocol *protocol= thd->protocol;

  char buff[2048];

  String buffer(buff, sizeof(buff), system_charset_info);

  DBUG_ENTER("mysqld_show_create");

  DBUG_PRINT("enter",("db: %s  table: %s",table_list->db,

                      table_list->table_name));

  /* Only one table for now, but VIEW can involve several tables */

  if (open_normal_and_derived_tables(thd, table_list, 0))

  {

    if (thd->is_error() && thd->main_da.sql_errno() != ER_VIEW_INVALID)

      DBUG_RETURN(TRUE);

    /*

      Clear all messages with 'error' level status and

      issue a warning with 'warning' level status in 

      case of invalid view and last error is ER_VIEW_INVALID

    */

    mysql_reset_errors(thd, true);

    thd->clear_error();

  }

  buffer.length(0);

  if (store_create_info(thd, table_list, &buffer, NULL))

    DBUG_RETURN(TRUE);

  List<Item> field_list;

  {

    field_list.push_back(new Item_empty_string("Table",NAME_CHAR_LEN));

    // 1024 is for not to confuse old clients

    field_list.push_back(new Item_empty_string("Create Table",

                                               max(buffer.length(),1024)));

  }

  if (protocol->send_fields(&field_list,

                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))

    DBUG_RETURN(TRUE);

  protocol->prepare_for_resend();

  {

    if (table_list->schema_table)

      protocol->store(table_list->schema_table->table_name,

                      system_charset_info);

    else

      protocol->store(table_list->table->alias, system_charset_info);

  }

  protocol->store(buffer.ptr(), buffer.length(), buffer.charset());

  if (protocol->write())

    DBUG_RETURN(TRUE);

  my_eof(thd);

  DBUG_RETURN(FALSE);

}

bool mysqld_show_create_db(THD *thd, char *dbname,

                           HA_CREATE_INFO *create_info)

{

  char buff[2048];

  String buffer(buff, sizeof(buff), system_charset_info);

  Protocol *protocol=thd->protocol;

  DBUG_ENTER("mysql_show_create_db");

  if (store_db_create_info(thd, dbname, &buffer, create_info))

  {

    /* 

      This assumes that the only reason for which store_db_create_info()

      can fail is incorrect database name (which is the case now).

    */

    my_error(ER_BAD_DB_ERROR, MYF(0), dbname);

    DBUG_RETURN(TRUE);    

  }

  List<Item> field_list;

  field_list.push_back(new Item_empty_string("Database",NAME_CHAR_LEN));

  field_list.push_back(new Item_empty_string("Create Database",1024));

  if (protocol->send_fields(&field_list,

                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))

    DBUG_RETURN(TRUE);

  protocol->prepare_for_resend();

  protocol->store(dbname, strlen(dbname), system_charset_info);

  protocol->store(buffer.ptr(), buffer.length(), buffer.charset());

  if (protocol->write())

    DBUG_RETURN(TRUE);

  my_eof(thd);

  DBUG_RETURN(FALSE);

}

/****************************************************************************

  Return only fields for API mysql_list_fields

  Use "show table wildcard" in mysql instead of this

****************************************************************************/

void

mysqld_list_fields(THD *thd, TABLE_LIST *table_list, const char *wild)

{

  TABLE *table;

  DBUG_ENTER("mysqld_list_fields");

  DBUG_PRINT("enter",("table: %s",table_list->table_name));

  if (open_normal_and_derived_tables(thd, table_list, 0))

    DBUG_VOID_RETURN;

  table= table_list->table;

  List<Item> field_list;

  Field **ptr,*field;

  for (ptr=table->field ; (field= *ptr); ptr++)

  {

    if (!wild || !wild[0] || 

        !wild_case_compare(system_charset_info, field->field_name,wild))

    {

      field_list.push_back(new Item_field(field));

    }

  }

  restore_record(table, s->default_values);              // Get empty record

  table->use_all_columns();

  if (thd->protocol->send_fields(&field_list, Protocol::SEND_DEFAULTS))

    DBUG_VOID_RETURN;

  my_eof(thd);

  DBUG_VOID_RETURN;

}

/*

  Go through all character combinations and ensure that sql_lex.cc can

  parse it as an identifier.

  SYNOPSIS

  require_quotes()

  name			attribute name

  name_length		length of name

  RETURN

    #	Pointer to conflicting character

    0	No conflicting character

*/

static const char *require_quotes(const char *name, uint name_length)

{

  uint length;

  bool pure_digit= TRUE;

  const char *end= name + name_length;

  for (; name < end ; name++)

  {

    uchar chr= (uchar) *name;

    length= my_mbcharlen(system_charset_info, chr);

    if (length == 1 && !system_charset_info->ident_map[chr])

      return name;

    if (length == 1 && (chr < '0' || chr > '9'))

      pure_digit= FALSE;

  }

  if (pure_digit)

    return name;

  return 0;

}

/*

  Quote the given identifier if needed and append it to the target string.

  If the given identifier is empty, it will be quoted.

  SYNOPSIS

  append_identifier()

  thd                   thread handler

  packet                target string

  name                  the identifier to be appended

  name_length           length of the appending identifier

*/

void

append_identifier(THD *thd, String *packet, const char *name, uint length)

{

  const char *name_end;

  char quote_char;

  int q= get_quote_char_for_identifier(thd, name, length);

  if (q == EOF)

  {

    packet->append(name, length, packet->charset());

    return;

  }

  /*

    The identifier must be quoted as it includes a quote character or

   it's a keyword

  */

  VOID(packet->reserve(length*2 + 2));

  quote_char= (char) q;

  packet->append(&quote_char, 1, system_charset_info);

  for (name_end= name+length ; name < name_end ; name+= length)

  {

    uchar chr= (uchar) *name;

    length= my_mbcharlen(system_charset_info, chr);

    /*

      my_mbcharlen can return 0 on a wrong multibyte

      sequence. It is possible when upgrading from 4.0,

      and identifier contains some accented characters.

      The manual says it does not work. So we'll just

      change length to 1 not to hang in the endless loop.

    */

    if (!length)

      length= 1;

    if (length == 1 && chr == (uchar) quote_char)

      packet->append(&quote_char, 1, system_charset_info);

    packet->append(name, length, system_charset_info);

  }

  packet->append(&quote_char, 1, system_charset_info);

}

/*

  Get the quote character for displaying an identifier.

  SYNOPSIS

    get_quote_char_for_identifier()

    thd		Thread handler

    name	name to quote

    length	length of name

  IMPLEMENTATION

    Force quoting in the following cases:

      - name is empty (for one, it is possible when we use this function for

        quoting user and host names for DEFINER clause);

      - name is a keyword;

      - name includes a special character;

    Otherwise identifier is quoted only if the option OPTION_QUOTE_SHOW_CREATE

    is set.

  RETURN

    EOF	  No quote character is needed

    #	  Quote character

*/

int get_quote_char_for_identifier(THD *thd, const char *name, uint length)

{

  if (length &&

      !is_keyword(name,length) &&

      !require_quotes(name, length) &&

      !(thd->options & OPTION_QUOTE_SHOW_CREATE))

    return EOF;

  return '"';

}

/* Append directory name (if exists) to CREATE INFO */

static void append_directory(THD *thd, String *packet, const char *dir_type,

			     const char *filename)

{

  if (filename)

  {

    uint length= dirname_length(filename);

    packet->append(' ');

    packet->append(dir_type);

    packet->append(STRING_WITH_LEN(" DIRECTORY='"));

    packet->append(filename, length);

    packet->append('\'');

  }

}

#define LIST_PROCESS_HOST_LEN 64

static bool get_field_default_value(THD *thd, Field *timestamp_field,

                                    Field *field, String *def_value,

                                    bool quoted)

{

  bool has_default;

  bool has_now_default;

  /* 

     We are using CURRENT_TIMESTAMP instead of NOW because it is

     more standard

  */

  has_now_default= (timestamp_field == field &&

                    field->unireg_check != Field::TIMESTAMP_UN_FIELD);

  has_default= (field->type() != FIELD_TYPE_BLOB &&

                !(field->flags & NO_DEFAULT_VALUE_FLAG) &&

                field->unireg_check != Field::NEXT_NUMBER

                  && has_now_default);

  def_value->length(0);

  if (has_default)

  {

    if (has_now_default)

      def_value->append(STRING_WITH_LEN("CURRENT_TIMESTAMP"));

    else if (!field->is_null())

    {                                             // Not null by default

      char tmp[MAX_FIELD_WIDTH];

      String type(tmp, sizeof(tmp), field->charset());

      field->val_str(&type);

      if (type.length())

      {

        String def_val;

        uint dummy_errors;

        /* convert to system_charset_info == utf8 */

        def_val.copy(type.ptr(), type.length(), field->charset(),

                     system_charset_info, &dummy_errors);

        if (quoted)

          append_unescaped(def_value, def_val.ptr(), def_val.length());

        else

          def_value->append(def_val.ptr(), def_val.length());

      }

      else if (quoted)

        def_value->append(STRING_WITH_LEN("''"));

    }

    else if (field->maybe_null() && quoted)

      def_value->append(STRING_WITH_LEN("NULL"));    // Null as default

    else

      return 0;

  }

  return has_default;

}

/*

  Build a CREATE TABLE statement for a table.

  SYNOPSIS

    store_create_info()

    thd               The thread

    table_list        A list containing one table to write statement

                      for.

    packet            Pointer to a string where statement will be

                      written.

    create_info_arg   Pointer to create information that can be used

                      to tailor the format of the statement.  Can be

                      NULL, in which case only SQL_MODE is considered

                      when building the statement.

  NOTE

    Currently always return 0, but might return error code in the

    future.

  RETURN

    0       OK

 */

int store_create_info(THD *thd, TABLE_LIST *table_list, String *packet,

                      HA_CREATE_INFO *create_info_arg)

{

  List<Item> field_list;

  char tmp[MAX_FIELD_WIDTH], *for_str, buff[128], def_value_buf[MAX_FIELD_WIDTH];

  const char *alias;

  String type(tmp, sizeof(tmp), system_charset_info);

  String def_value(def_value_buf, sizeof(def_value_buf), system_charset_info);

  Field **ptr,*field;

  uint primary_key;

  KEY *key_info;

  TABLE *table= table_list->table;

  handler *file= table->file;

  TABLE_SHARE *share= table->s;

  HA_CREATE_INFO create_info;

  bool show_table_options= FALSE;

  my_bitmap_map *old_map;

  DBUG_ENTER("store_create_info");

  DBUG_PRINT("enter",("table: %s", table->s->table_name.str));

  restore_record(table, s->default_values); // Get empty record

  if (share->tmp_table)

    packet->append(STRING_WITH_LEN("CREATE TEMPORARY TABLE "));

  else

    packet->append(STRING_WITH_LEN("CREATE TABLE "));

  if (create_info_arg &&

      (create_info_arg->options & HA_LEX_CREATE_IF_NOT_EXISTS))

    packet->append(STRING_WITH_LEN("IF NOT EXISTS "));

  if (table_list->schema_table)

    alias= table_list->schema_table->table_name;

  else

  {

    if (lower_case_table_names == 2)

      alias= table->alias;

    else

    {

      alias= share->table_name.str;

    }

  }

  append_identifier(thd, packet, alias, strlen(alias));

  packet->append(STRING_WITH_LEN(" (\n"));

  /*

    We need this to get default values from the table

    We have to restore the read_set if we are called from insert in case

    of row based replication.

  */

  old_map= tmp_use_all_columns(table, table->read_set);

  for (ptr=table->field ; (field= *ptr); ptr++)

  {

    uint flags = field->flags;

    if (ptr != table->field)

      packet->append(STRING_WITH_LEN(",\n"));

    packet->append(STRING_WITH_LEN("  "));

    append_identifier(thd,packet,field->field_name, strlen(field->field_name));

    packet->append(' ');

    // check for surprises from the previous call to Field::sql_type()

    if (type.ptr() != tmp)

      type.set(tmp, sizeof(tmp), system_charset_info);

    else

      type.set_charset(system_charset_info);

    field->sql_type(type);

    packet->append(type.ptr(), type.length(), system_charset_info);

    if (field->has_charset())

    {

      if (field->charset() != share->table_charset)

      {

	packet->append(STRING_WITH_LEN(" CHARACTER SET "));

	packet->append(field->charset()->csname);

      }

      /* 

	For string types dump collation name only if 

	collation is not primary for the given charset

      */

      if (!(field->charset()->state & MY_CS_PRIMARY))

      {

	packet->append(STRING_WITH_LEN(" COLLATE "));

	packet->append(field->charset()->name);

      }

    }

    if (flags & NOT_NULL_FLAG)

      packet->append(STRING_WITH_LEN(" NOT NULL"));

    else if (field->type() == MYSQL_TYPE_TIMESTAMP)

    {

      /*

        TIMESTAMP field require explicit NULL flag, because unlike

        all other fields they are treated as NOT NULL by default.

      */

      packet->append(STRING_WITH_LEN(" NULL"));

    }

    {

      /*

        Add field flags about FIELD FORMAT (FIXED or DYNAMIC)

        and about STORAGE (DISK or MEMORY).

      */

      enum ha_storage_media storage_type= (enum ha_storage_media)

        ((flags >> FIELD_STORAGE_FLAGS) & STORAGE_TYPE_MASK);

      enum column_format_type column_format= (enum column_format_type)

        ((flags >> COLUMN_FORMAT_FLAGS) & COLUMN_FORMAT_MASK);