~drizzle-trunk/drizzle/development

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

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

 *

 *  Copyright (C) 2008 MySQL

 *

 *  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; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  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

 */

/* drizzle command tool

 * Commands compatible with mSQL by David J. Hughes

 *

 * Written by:

 *   Michael 'Monty' Widenius

 *   Andi Gutmans  <andi@zend.com>

 *   Zeev Suraski  <zeev@zend.com>

 *   Jani Tolonen  <jani@mysql.com>

 *   Matt Wagner   <matt@mysql.com>

 *   Jeremy Cole   <jcole@mysql.com>

 *   Tonu Samuel   <tonu@mysql.com>

 *   Harrison Fisk <harrison@mysql.com>

 *

 **/

#include "client_priv.h"

#include <string>

#include <drizzled/gettext.h>

#include <iostream>

#include <map>

#include <algorithm>

#include <limits.h>

#include <cassert>

#include "drizzled/charset_info.h"

#include <stdarg.h>

#include <math.h>

#include "client/linebuffer.h"

#include <signal.h>

#include <sys/ioctl.h>

#include <drizzled/configmake.h>

#include "drizzled/charset.h"

#if defined(HAVE_CURSES_H) && defined(HAVE_TERM_H)

#include <curses.h>

#ifdef __sun

#undef clear

#undef erase

#endif

#include <term.h>

#else

#if defined(HAVE_TERMIOS_H)

#include <termios.h>

#include <unistd.h>

#elif defined(HAVE_TERMBITS_H)

#include <termbits.h>

#elif defined(HAVE_ASM_TERMBITS_H) && (!defined __GLIBC__ || !(__GLIBC__ > 2 || __GLIBC__ == 2 && __GLIBC_MINOR__ > 0))

#include <asm/termbits.h>    // Standard linux

#endif

#if defined(HAVE_TERMCAP_H)

#include <termcap.h>

#else

#ifdef HAVE_CURSES_H

#include <curses.h>

#endif

#undef SYSV        // hack to avoid syntax error

#ifdef HAVE_TERM_H

#include <term.h>

#endif

#endif

#endif

#ifdef HAVE_LIBREADLINE

#  if defined(HAVE_READLINE_READLINE_H)

#    include <readline/readline.h>

#  elif defined(HAVE_READLINE_H)

#    include <readline.h>

#  else /* !defined(HAVE_READLINE_H) */

extern char *readline ();

#  endif /* !defined(HAVE_READLINE_H) */

char *cmdline = NULL;

#else /* !defined(HAVE_READLINE_READLINE_H) */

  /* no readline */

#  error Readline Required

#endif /* HAVE_LIBREADLINE */

#ifdef HAVE_READLINE_HISTORY

#  if defined(HAVE_READLINE_HISTORY_H)

#    include <readline/history.h>

#  elif defined(HAVE_HISTORY_H)

#    include <history.h>

#  else /* !defined(HAVE_HISTORY_H) */

extern void add_history ();

extern int write_history ();

extern int read_history ();

#  endif /* defined(HAVE_READLINE_HISTORY_H) */

    /* no history */

#endif /* HAVE_READLINE_HISTORY */

/**

 Make the old readline interface look like the new one.

*/

#ifndef HAVE_RL_COMPLETION

typedef char **rl_completion_func_t(const char *, int, int);

#define rl_completion_matches(str, func) \

  completion_matches((char *)str, (CPFunction *)func)

#endif

#ifdef HAVE_RL_COMPENTRY

# ifdef HAVE_WORKING_RL_COMPENTRY

typedef rl_compentry_func_t drizzle_compentry_func_t;

# else

/* Snow Leopard ships an rl_compentry which cannot be assigned to

 * rl_completion_entry_function. We must undo the complete and total

 * ass-bagery.

 */

typedef Function drizzle_compentry_func_t;

# endif

#else

typedef Function drizzle_compentry_func_t;

#endif

#if defined(HAVE_LOCALE_H)

#include <locale.h>

#endif

#if !defined(HAVE_VIDATTR)

#undef vidattr

#define vidattr(A) {}      // Can't get this to work

#endif

using namespace drizzled;

using namespace std;

const string VER("14.14");

/* Don't try to make a nice table if the data is too big */

const uint32_t MAX_COLUMN_LENGTH= 1024;

/* Buffer to hold 'version' and 'version_comment' */

const int MAX_SERVER_VERSION_LENGTH= 128;

#define PROMPT_CHAR '\\'

#define DEFAULT_DELIMITER ";"

class Status

{

public:

  Status(int in_exit_status, 

         uint32_t in_query_start_line,

  	 char *in_file_name,

         LineBuffer *in_line_buff,

	 bool in_batch,

	 bool in_add_to_history)

    :

    exit_status(in_exit_status),

    query_start_line(in_query_start_line),

    file_name(in_file_name),

    line_buff(in_line_buff),

    batch(in_batch),

    add_to_history(in_add_to_history)

    {}

  Status()

    :

    exit_status(),

    query_start_line(),

    file_name(),

    line_buff(),

    batch(),        

    add_to_history()

    {}

  int getExitStatus() const

  {

    return exit_status;

  }

  uint32_t getQueryStartLine() const

  {

    return query_start_line;

  }

  const char *getFileName() const

  {

    return file_name;

  }

  LineBuffer *getLineBuff() const

  {

    return line_buff;

  }

  bool getBatch() const

  {

    return batch;

  }

  bool getAddToHistory() const

  {

    return add_to_history;

  }

  void setExitStatus(int in_exit_status)

  {

    exit_status= in_exit_status;

  }

  void setQueryStartLine(uint32_t in_query_start_line)

  {

    query_start_line= in_query_start_line;

  }

  void setFileName(char *in_file_name)

  {

    file_name= in_file_name;

  }

  void setLineBuff(int max_size, FILE *file=NULL)

  {

    line_buff= new(std::nothrow) LineBuffer(max_size, file);

  }

  void setLineBuff(LineBuffer *in_line_buff)

  {

    line_buff= in_line_buff;

  }

  void setBatch(bool in_batch)

  {

    batch= in_batch;

  }

  void setAddToHistory(bool in_add_to_history)

  {

    add_to_history= in_add_to_history;

  }

private:

  int exit_status;

  uint32_t query_start_line;

  char *file_name;

  LineBuffer *line_buff;

  bool batch,add_to_history;

}; 

static map<string, string>::iterator completion_iter;

static map<string, string>::iterator completion_end;

static map<string, string> completion_map;

static string completion_string;

static char **defaults_argv;

enum enum_info_type { INFO_INFO,INFO_ERROR,INFO_RESULT};

typedef enum enum_info_type INFO_TYPE;

static drizzle_st drizzle;      /* The library handle */

static drizzle_con_st con;      /* The connection */

static bool ignore_errors= false, quick= false,

  connected= false, opt_raw_data= false, unbuffered= false,

  output_tables= false, opt_rehash= true, skip_updates= false,

  safe_updates= false, one_database= false,

  opt_compress= false, opt_shutdown= false, opt_ping= false,

  vertical= false, line_numbers= true, column_names= true,

  opt_nopager= true, opt_outfile= false, named_cmds= false,

  tty_password= false, opt_nobeep= false, opt_reconnect= true,

  default_charset_used= false, opt_secure_auth= false,

  default_pager_set= false, opt_sigint_ignore= false,

  auto_vertical_output= false,

  show_warnings= false, executing_query= false, interrupted_query= false,

  opt_mysql= false;

static uint32_t  show_progress_size= 0;

static bool column_types_flag;

static bool preserve_comments= false;

static uint32_t opt_max_input_line, opt_drizzle_port= 0;

static int verbose= 0, opt_silent= 0, opt_local_infile= 0;

static drizzle_capabilities_t connect_flag= DRIZZLE_CAPABILITIES_NONE;

static char *current_host, *current_db, *current_user= NULL,

  *opt_password= NULL, *delimiter_str= NULL, *current_prompt= NULL;

static char *histfile;

static char *histfile_tmp;

static string *glob_buffer;

static string *processed_prompt= NULL;

static char *default_prompt= NULL;

static char *full_username= NULL,*part_username= NULL;

static Status status;

static uint32_t select_limit;

static uint32_t max_join_size;

static uint32_t opt_connect_timeout= 0;

// TODO: Need to i18n these

static const char *day_names[]= {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};

static const char *month_names[]= {"Jan","Feb","Mar","Apr","May","Jun","Jul",

                                  "Aug","Sep","Oct","Nov","Dec"};

static char default_pager[FN_REFLEN];

static char pager[FN_REFLEN], outfile[FN_REFLEN];

static FILE *PAGER, *OUTFILE;

static uint32_t prompt_counter;

static char delimiter[16]= DEFAULT_DELIMITER;

static uint32_t delimiter_length= 1;

unsigned short terminal_width= 80;

static const CHARSET_INFO *charset_info= &my_charset_utf8_general_ci;

int drizzleclient_real_query_for_lazy(const char *buf, int length,

                                      drizzle_result_st *result,

                                      uint32_t *error_code);

int drizzleclient_store_result_for_lazy(drizzle_result_st *result);

void tee_fprintf(FILE *file, const char *fmt, ...);

void tee_fputs(const char *s, FILE *file);

void tee_puts(const char *s, FILE *file);

void tee_putc(int c, FILE *file);

static void tee_print_sized_data(const char *, unsigned int, unsigned int, bool);

/* The names of functions that actually do the manipulation. */

static int get_options(int argc,char **argv);

static int com_quit(string *str,const char*),

  com_go(string *str,const char*), com_ego(string *str,const char*),

  com_print(string *str,const char*),

  com_help(string *str,const char*), com_clear(string *str,const char*),

  com_connect(string *str,const char*), com_status(string *str,const char*),

  com_use(string *str,const char*), com_source(string *str, const char*),

  com_rehash(string *str, const char*), com_tee(string *str, const char*),

  com_notee(string *str, const char*),

  com_prompt(string *str, const char*), com_delimiter(string *str, const char*),

  com_warnings(string *str, const char*), com_nowarnings(string *str, const char*),

  com_nopager(string *str, const char*), com_pager(string *str, const char*);

static int read_and_execute(bool interactive);

static int sql_connect(char *host,char *database,char *user,char *password,

                       uint32_t silent);

static const char *server_version_string(drizzle_con_st *con);

static int put_info(const char *str,INFO_TYPE info,uint32_t error,

                    const char *sql_state);

static int put_error(drizzle_con_st *con, drizzle_result_st *res);

static void safe_put_field(const char *pos,uint32_t length);

static void init_pager(void);

static void end_pager(void);

static void init_tee(const char *);

static void end_tee(void);

static const char* construct_prompt(void);

static char *get_arg(char *line, bool get_next_arg);

static void init_username(void);

static void add_int_to_prompt(int toadd);

static int get_result_width(drizzle_result_st *res);

static int get_field_disp_length(drizzle_column_st * field);

static const char * strcont(register const char *str, register const char *set);

/* A class which contains information on the commands this program

   can understand. */

class Commands

{

private:

  const char *name;        /* User printable name of the function. */

  char cmd_char;        /* msql command character */

public:

Commands(const char *in_name,

         char in_cmd_char,

         int (*in_func)(string *str,const char *name),

         bool in_takes_params,

         const char *in_doc)

  :

  name(in_name),

  cmd_char(in_cmd_char),

  func(in_func),

  takes_params(in_takes_params),

  doc(in_doc)

  {}

  Commands()

  :

  name(),

  cmd_char(),

  func(NULL),

  takes_params(false),

  doc()

  {}

  int (*func)(string *str,const char *);/* Function to call to do the job. */

  const char *getName() const

  {

    return name;

  }

  char getCmdChar() const

  {

    return cmd_char;

  }

  bool getTakesParams() const

  {

    return takes_params;

  }

  const char *getDoc() const

  {

    return doc;

  }

  void setName(const char *in_name)

  {

     name= in_name;

  }

  void setCmdChar(char in_cmd_char)

  {

    cmd_char= in_cmd_char;

  }

  void setTakesParams(bool in_takes_params)

  {

    takes_params= in_takes_params;

  }

  void setDoc(const char *in_doc)

  {

    doc= in_doc;

  }

private:

  bool takes_params;        /* Max parameters for command */

  const char *doc;        /* Documentation for this function.  */

}; 

static Commands commands[] = {

  Commands( "?",      '?', com_help,   0, N_("Synonym for `help'.") ),

  Commands( "clear",  'c', com_clear,  0, N_("Clear command.")),

  Commands( "connect",'r', com_connect,1,

    N_("Reconnect to the server. Optional arguments are db and host.")),

  Commands( "delimiter", 'd', com_delimiter,    1,

    N_("Set statement delimiter. NOTE: Takes the rest of the line as new delimiter.") ),

  Commands( "ego",    'G', com_ego,    0,

    N_("Send command to drizzle server, display result vertically.")),

  Commands( "exit",   'q', com_quit,   0, N_("Exit drizzle. Same as quit.")),

  Commands( "go",     'g', com_go,     0, N_("Send command to drizzle server.") ),

  Commands( "help",   'h', com_help,   0, N_("Display this help.") ),

  Commands( "nopager",'n', com_nopager,0, N_("Disable pager, print to stdout.") ),

  Commands( "notee",  't', com_notee,  0, N_("Don't write into outfile.") ),

  Commands( "pager",  'P', com_pager,  1,

    N_("Set PAGER [to_pager]. Print the query results via PAGER.") ),

  Commands( "print",  'p', com_print,  0, N_("Print current command.") ),

  Commands( "prompt", 'R', com_prompt, 1, N_("Change your drizzle prompt.")),

  Commands( "quit",   'q', com_quit,   0, N_("Quit drizzle.") ),

  Commands( "rehash", '#', com_rehash, 0, N_("Rebuild completion hash.") ),

  Commands( "source", '.', com_source, 1,

    N_("Execute an SQL script file. Takes a file name as an argument.")),

  Commands( "status", 's', com_status, 0, N_("Get status information from the server.")),

  Commands( "tee",    'T', com_tee,    1,

    N_("Set outfile [to_outfile]. Append everything into given outfile.") ),

  Commands( "use",    'u', com_use,    1,

    N_("Use another database. Takes database name as argument.") ),

  Commands( "warnings", 'W', com_warnings,  0,

    N_("Show warnings after every statement.") ),

  Commands( "nowarning", 'w', com_nowarnings, 0,

    N_("Don't show warnings after every statement.") ),

  /* Get bash-like expansion for some commands */

  Commands( "create table",     0, 0, 0, ""),

  Commands( "create database",  0, 0, 0, ""),

  Commands( "show databases",   0, 0, 0, ""),

  Commands( "show fields from", 0, 0, 0, ""),

  Commands( "show keys from",   0, 0, 0, ""),

  Commands( "show tables",      0, 0, 0, ""),

  Commands( "load data from",   0, 0, 0, ""),

  Commands( "alter table",      0, 0, 0, ""),

  Commands( "set option",       0, 0, 0, ""),

  Commands( "lock tables",      0, 0, 0, ""),

  Commands( "unlock tables",    0, 0, 0, ""),

  /* generated 2006-12-28.  Refresh occasionally from lexer. */

  Commands( "ACTION", 0, 0, 0, ""),

  Commands( "ADD", 0, 0, 0, ""),

  Commands( "AFTER", 0, 0, 0, ""),

  Commands( "AGAINST", 0, 0, 0, ""),

  Commands( "AGGREGATE", 0, 0, 0, ""),

  Commands( "ALL", 0, 0, 0, ""),

  Commands( "ALGORITHM", 0, 0, 0, ""),

  Commands( "ALTER", 0, 0, 0, ""),

  Commands( "ANALYZE", 0, 0, 0, ""),

  Commands( "AND", 0, 0, 0, ""),

  Commands( "ANY", 0, 0, 0, ""),

  Commands( "AS", 0, 0, 0, ""),

  Commands( "ASC", 0, 0, 0, ""),

  Commands( "ASCII", 0, 0, 0, ""),

  Commands( "ASENSITIVE", 0, 0, 0, ""),

  Commands( "AUTO_INCREMENT", 0, 0, 0, ""),

  Commands( "AVG", 0, 0, 0, ""),

  Commands( "AVG_ROW_LENGTH", 0, 0, 0, ""),

  Commands( "BACKUP", 0, 0, 0, ""),

  Commands( "BDB", 0, 0, 0, ""),

  Commands( "BEFORE", 0, 0, 0, ""),

  Commands( "BEGIN", 0, 0, 0, ""),

  Commands( "BERKELEYDB", 0, 0, 0, ""),

  Commands( "BETWEEN", 0, 0, 0, ""),

  Commands( "BIGINT", 0, 0, 0, ""),

  Commands( "BINARY", 0, 0, 0, ""),

  Commands( "BINLOG", 0, 0, 0, ""),

  Commands( "BIT", 0, 0, 0, ""),

  Commands( "BLOB", 0, 0, 0, ""),

  Commands( "BOOL", 0, 0, 0, ""),

  Commands( "BOOLEAN", 0, 0, 0, ""),

  Commands( "BOTH", 0, 0, 0, ""),

  Commands( "BTREE", 0, 0, 0, ""),

  Commands( "BY", 0, 0, 0, ""),

  Commands( "BYTE", 0, 0, 0, ""),

  Commands( "CACHE", 0, 0, 0, ""),

  Commands( "CALL", 0, 0, 0, ""),

  Commands( "CASCADE", 0, 0, 0, ""),

  Commands( "CASCADED", 0, 0, 0, ""),

  Commands( "CASE", 0, 0, 0, ""),

  Commands( "CHAIN", 0, 0, 0, ""),

  Commands( "CHANGE", 0, 0, 0, ""),

  Commands( "CHANGED", 0, 0, 0, ""),

  Commands( "CHAR", 0, 0, 0, ""),

  Commands( "CHARACTER", 0, 0, 0, ""),

  Commands( "CHARSET", 0, 0, 0, ""),

  Commands( "CHECK", 0, 0, 0, ""),

  Commands( "CHECKSUM", 0, 0, 0, ""),

  Commands( "CIPHER", 0, 0, 0, ""),

  Commands( "CLIENT", 0, 0, 0, ""),

  Commands( "CLOSE", 0, 0, 0, ""),

  Commands( "CODE", 0, 0, 0, ""),

  Commands( "COLLATE", 0, 0, 0, ""),

  Commands( "COLLATION", 0, 0, 0, ""),

  Commands( "COLUMN", 0, 0, 0, ""),

  Commands( "COLUMNS", 0, 0, 0, ""),

  Commands( "COMMENT", 0, 0, 0, ""),

  Commands( "COMMIT", 0, 0, 0, ""),

  Commands( "COMMITTED", 0, 0, 0, ""),

  Commands( "COMPACT", 0, 0, 0, ""),

  Commands( "COMPRESSED", 0, 0, 0, ""),

  Commands( "CONCURRENT", 0, 0, 0, ""),

  Commands( "CONDITION", 0, 0, 0, ""),

  Commands( "CONNECTION", 0, 0, 0, ""),

  Commands( "CONSISTENT", 0, 0, 0, ""),

  Commands( "CONSTRAINT", 0, 0, 0, ""),

  Commands( "CONTAINS", 0, 0, 0, ""),

  Commands( "CONTINUE", 0, 0, 0, ""),

  Commands( "CONVERT", 0, 0, 0, ""),

  Commands( "CREATE", 0, 0, 0, ""),

  Commands( "CROSS", 0, 0, 0, ""),

  Commands( "CUBE", 0, 0, 0, ""),

  Commands( "CURRENT_DATE", 0, 0, 0, ""),

  Commands( "CURRENT_TIMESTAMP", 0, 0, 0, ""),

  Commands( "CURRENT_USER", 0, 0, 0, ""),

  Commands( "CURSOR", 0, 0, 0, ""),

  Commands( "DATA", 0, 0, 0, ""),

  Commands( "DATABASE", 0, 0, 0, ""),

  Commands( "DATABASES", 0, 0, 0, ""),

  Commands( "DATE", 0, 0, 0, ""),

  Commands( "DATETIME", 0, 0, 0, ""),

  Commands( "DAY", 0, 0, 0, ""),

  Commands( "DAY_HOUR", 0, 0, 0, ""),

  Commands( "DAY_MICROSECOND", 0, 0, 0, ""),

  Commands( "DAY_MINUTE", 0, 0, 0, ""),

  Commands( "DAY_SECOND", 0, 0, 0, ""),

  Commands( "DEALLOCATE", 0, 0, 0, ""),

  Commands( "DEC", 0, 0, 0, ""),

  Commands( "DECIMAL", 0, 0, 0, ""),

  Commands( "DECLARE", 0, 0, 0, ""),

  Commands( "DEFAULT", 0, 0, 0, ""),

  Commands( "DEFINER", 0, 0, 0, ""),

  Commands( "DELAYED", 0, 0, 0, ""),

  Commands( "DELAY_KEY_WRITE", 0, 0, 0, ""),

  Commands( "DELETE", 0, 0, 0, ""),

  Commands( "DESC", 0, 0, 0, ""),

  Commands( "DESCRIBE", 0, 0, 0, ""),

  Commands( "DES_KEY_FILE", 0, 0, 0, ""),

  Commands( "DETERMINISTIC", 0, 0, 0, ""),

  Commands( "DIRECTORY", 0, 0, 0, ""),

  Commands( "DISABLE", 0, 0, 0, ""),

  Commands( "DISCARD", 0, 0, 0, ""),

  Commands( "DISTINCT", 0, 0, 0, ""),

  Commands( "DISTINCTROW", 0, 0, 0, ""),

  Commands( "DIV", 0, 0, 0, ""),

  Commands( "DO", 0, 0, 0, ""),

  Commands( "DOUBLE", 0, 0, 0, ""),

  Commands( "DROP", 0, 0, 0, ""),

  Commands( "DUAL", 0, 0, 0, ""),

  Commands( "DUMPFILE", 0, 0, 0, ""),

  Commands( "DUPLICATE", 0, 0, 0, ""),

  Commands( "DYNAMIC", 0, 0, 0, ""),

  Commands( "EACH", 0, 0, 0, ""),

  Commands( "ELSE", 0, 0, 0, ""),

  Commands( "ELSEIF", 0, 0, 0, ""),

  Commands( "ENABLE", 0, 0, 0, ""),

  Commands( "ENCLOSED", 0, 0, 0, ""),

  Commands( "END", 0, 0, 0, ""),

  Commands( "ENGINE", 0, 0, 0, ""),

  Commands( "ENGINES", 0, 0, 0, ""),

  Commands( "ENUM", 0, 0, 0, ""),

  Commands( "ERRORS", 0, 0, 0, ""),

  Commands( "ESCAPE", 0, 0, 0, ""),

  Commands( "ESCAPED", 0, 0, 0, ""),

  Commands( "EVENTS", 0, 0, 0, ""),

  Commands( "EXECUTE", 0, 0, 0, ""),

  Commands( "EXISTS", 0, 0, 0, ""),

  Commands( "EXIT", 0, 0, 0, ""),

  Commands( "EXPANSION", 0, 0, 0, ""),

  Commands( "EXPLAIN", 0, 0, 0, ""),

  Commands( "EXTENDED", 0, 0, 0, ""),

  Commands( "FALSE", 0, 0, 0, ""),