~drizzle-trunk/drizzle/development

/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-

 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:

 *

 *  Copyright (C) 2008 Sun Microsystems

 *

 *  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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

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

#include <drizzled/server_includes.h>

#include <drizzled/sql_select.h>

#include <drizzled/show.h>

#include <mysys/my_dir.h>

#include <drizzled/gettext.h>

#include <drizzled/util/convert.h>

#include <drizzled/error.h>

#include <drizzled/tztime.h>

#include <drizzled/data_home.h>

#include <drizzled/item/blob.h>

#include <drizzled/item/cmpfunc.h>

#include <drizzled/item/return_int.h>

#include <drizzled/item/empty_string.h>

#include <drizzled/item/return_date_time.h>

#include <drizzled/sql_base.h>

#include <drizzled/db.h>

#include <drizzled/field/timestamp.h>

#include <drizzled/field/decimal.h>

#include <drizzled/lock.h>

#include <drizzled/item/return_date_time.h>

#include <drizzled/item/empty_string.h>

#include "drizzled/plugin_registry.h"

#include <string>

#include <iostream>

#include <sstream>

#include <vector>

#include <algorithm>

using namespace std;

extern "C"

int show_var_cmp(const void *var1, const void *var2);

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(Session *session, String *packet, Table *table,

                              KEY *key_info);

static vector<InfoSchemaTable *> all_schema_tables;

Table *create_schema_table(Session *session, TableList *table_list);

int make_old_format(Session *session, InfoSchemaTable *schema_table);

void add_infoschema_table(InfoSchemaTable *schema_table)

{

  if (schema_table->create_table == NULL)

    schema_table->create_table= create_schema_table;

  if (schema_table->old_format == NULL)

    schema_table->old_format= make_old_format;

  if (schema_table->idx_field1 == 0)

    schema_table->idx_field1= -1;

  if (schema_table->idx_field2)

   schema_table->idx_field2= -1;

  all_schema_tables.push_back(schema_table);

}

void remove_infoschema_table(InfoSchemaTable *table)

{

  all_schema_tables.erase(remove_if(all_schema_tables.begin(),

                                    all_schema_tables.end(),

                                    bind2nd(equal_to<InfoSchemaTable *>(),

                                            table)),

                          all_schema_tables.end());

}

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

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

class ShowPlugins : public unary_function<st_plugin_int *, bool>

{

  Session *session;

  Table *table;

public:

  ShowPlugins(Session *session_arg, Table *table_arg)

    : session(session_arg), table(table_arg) {}

  result_type operator() (argument_type plugin)

  {

    struct drizzled_plugin_manifest *plug= plugin_decl(plugin);

    const CHARSET_INFO * const cs= system_charset_info;

    table->restoreRecordAsDefault();

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

    if (plugin->isInited)

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

    else

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

    if (plug->author)

    {

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

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

    }

    else

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

    if (plug->descr)

    {

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

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

    }

    else

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

    switch (plug->license) {

    case PLUGIN_LICENSE_GPL:

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

                             strlen(PLUGIN_LICENSE_GPL_STRING), cs);

      break;

    case PLUGIN_LICENSE_BSD:

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

                             strlen(PLUGIN_LICENSE_BSD_STRING), cs);

      break;

    case PLUGIN_LICENSE_LGPL:

      table->field[5]->store(PLUGIN_LICENSE_LGPL_STRING,

                             strlen(PLUGIN_LICENSE_LGPL_STRING), cs);

      break;

    default:

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

                             strlen(PLUGIN_LICENSE_PROPRIETARY_STRING), cs);

      break;

    }

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

    return schema_table_store_record(session, table);

  }

};

int fill_plugins(Session *session, TableList *tables, COND *)

{

  Table *table= tables->table;

  PluginRegistry &registry= PluginRegistry::getPluginRegistry();

  vector<st_plugin_int *> plugins= registry.get_list(true);

  vector<st_plugin_int *>::iterator iter=

    find_if(plugins.begin(), plugins.end(), ShowPlugins(session, table));

  if (iter != plugins.end())

    return 1;

  return(0);

}

/*

  find_files() - find files in a given directory.

  SYNOPSIS

    find_files()

    session                 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(Session *session, List<LEX_STRING> *files, const char *db,

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

{

  uint32_t i;

  char *ext;

  MY_DIR *dirp;

  FILEINFO *file;

  LEX_STRING *file_name= 0;

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

            session->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),".dfe") ||

          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=

          session->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 drizzled_show_create(Session *session, TableList *table_list)

{

  Protocol *protocol= session->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(session, table_list, 0))

  {

    if (session->is_error())

      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(session, true);

    session->clear_error();

  }

  buffer.length(0);

  if (store_create_info(session, 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->sendFields(&field_list,

                           Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))

  {

    return(true);

  }

  protocol->prepareForResend();

  {

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

  session->my_eof();

  return(false);

}

bool mysqld_show_create_db(Session *session, char *dbname,

                           HA_CREATE_INFO *create_info)

{

  char buff[2048];

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

  Protocol *protocol=session->protocol;

  if (store_db_create_info(session, 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->sendFields(&field_list,

                           Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))

    return(true);

  protocol->prepareForResend();

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

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

  if (protocol->write())

    return(true);

  session->my_eof();

  return(false);

}

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

  Return only fields for API mysql_list_fields

  Use "show table wildcard" in mysql instead of this

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

void

mysqld_list_fields(Session *session, TableList *table_list, const char *wild)

{

  Table *table;

  if (open_normal_and_derived_tables(session, 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));

    }

  }

  table->restoreRecordAsDefault();              // Get empty record

  table->use_all_columns();

  if (session->protocol->sendFields(&field_list, Protocol::SEND_DEFAULTS))

    return;

  session->my_eof();

  return;

}

/*

  Get the quote character for displaying an identifier.

  SYNOPSIS

    get_quote_char_for_identifier()

    session		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(Session *, const char *, uint32_t)

{

  return '`';

}

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

static void append_directory(Session *,

                             String *packet, const char *dir_type,

                             const char *filename)

{

  if (filename)

  {

    uint32_t 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(Session *,

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

  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;

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

    session               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(Session *session, TableList *table_list, String *packet,

                      HA_CREATE_INFO *create_info_arg)

{

  List<Item> field_list;

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

  const char *alias;

  string buff;

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

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

  Field **ptr,*field;

  uint32_t primary_key;

  KEY *key_info;

  Table *table= table_list->table;

  handler *file= table->file;

  TableShare *share= table->s;

  HA_CREATE_INFO create_info;

  bool show_table_options= false;

  bitset<MAX_FIELDS> *old_bitmap;

  table->restoreRecordAsDefault(); // 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;

  }

  packet->append_identifier(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_bitmap= table->use_all_columns(table->read_set);

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

  {

    uint32_t flags = field->flags;

    if (ptr != table->field)

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