~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 <drizzled/server_includes.h>

#include <drizzled/sql_select.h>

#include <drizzled/sql_show.h>

#include "repl_failsafe.h"

#include <mysys/my_dir.h>

#include <libdrizzle/gettext.h>

inline const char *

str_or_nil(const char *str)

{

  return str ? str : "<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(const CHARSET_INFO * const cs, const char *str,const char *wildstr)

{

  register int flag;

  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++))

        return(1);

    }

    if (! *wildstr )

      return (*str != 0);

    if (*wildstr++ == wild_one)

    {

      if (! *str++)

        return (1);	/* One char; skip */

    }

    else

    {						/* Found '*' */

      if (!*wildstr)

        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)

      return (1);

	}

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

      return (0);

      } while (*str++);

      return(1);

    }

  }

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

}

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

** List all table types supported

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

static 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);

  const CHARSET_INFO * const cs= system_charset_info;

  restore_record(table, s->default_values);

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

                         plugin_name(plugin)->length, cs);

  if (plug->version)

  {

    table->field[1]->store(plug->version, strlen(plug->version), cs);

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

  }

  else

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

  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:

    assert(0);

  }

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

                         plugin_type_names[plug->type].length,

                         cs);

  if (plugin_dl)

  {

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

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

  }

  else

  {

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

  }

  if (plug->author)

  {

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

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

  }

  else

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

  if (plug->descr)

  {

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

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

  }

  else

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

  switch (plug->license) {

  case PLUGIN_LICENSE_GPL:

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

                           strlen(PLUGIN_LICENSE_GPL_STRING), cs);

    break;

  case PLUGIN_LICENSE_BSD:

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

                           strlen(PLUGIN_LICENSE_BSD_STRING), cs);

    break;

  default:

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

                           strlen(PLUGIN_LICENSE_PROPRIETARY_STRING), cs);

    break;

  }

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

  return schema_table_store_record(thd, table);

}

int fill_plugins(THD *thd, TableList *tables, COND *cond __attribute__((unused)))

{

  Table *table= tables->table;

  if (plugin_foreach_with_mask(thd, show_plugins, DRIZZLE_ANY_PLUGIN,

                               ~PLUGIN_IS_FREED, table))

    return(1);

  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 TableList 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;

  TableList table_list;

  if (wild && !wild[0])

    wild=0;

  memset(&table_list, 0, 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);

    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= strchr(buff, '\0');

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

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

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

               continue;

       }

#endif

      if (!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);

        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);

      return(FIND_FILES_OOM);

    }

  }

  my_dirend(dirp);

  return(FIND_FILES_OK);

}

bool

mysqld_show_create(THD *thd, TableList *table_list)

{

  Protocol *protocol= thd->protocol;

  char buff[2048];

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

  /* 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)

      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

    */

    drizzle_reset_errors(thd, true);

    thd->clear_error();

  }

  buffer.length(0);

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

    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",

                                               cmax(buffer.length(),(uint32_t)1024)));

  }

  if (protocol->send_fields(&field_list,

                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))

    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())

    return(true);

  my_eof(thd);

  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;

  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);

    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))

    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())

    return(true);

  my_eof(thd);

  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, TableList *table_list, const char *wild)

{

  Table *table;

  if (open_normal_and_derived_tables(thd, table_list, 0))

    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))

    return;

  my_eof(thd);

  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

  */

  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 __attribute__((unused)),

                             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 __attribute__((unused)),

                                    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() != DRIZZLE_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, TableList *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;

  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= table->use_all_columns(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));