~drizzle-trunk/drizzle/development

 *   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 "config.h"

 

#include <string>

 

#include <mystrings/m_ctype.h>

#include <sys/ioctl.h>

 

 

#if defined(HAVE_LOCALE_H)

#include <libdrizzle/gettext.h>

#define MAX_COLUMN_LENGTH       (uint32_t)1024

 

#ifdef __sun

#undef clear

#undef erase

#endif

#undef bcmp                             // Fix problem with new readline

#ifdef HAVE_READLINE_HISTORY_H

#include <readline/history.h>

#endif

/**

 Make the old readline interface look like the new one.

*/

#ifndef USE_NEW_READLINE_INTERFACE

typedef CPPFunction rl_completion_func_t;

typedef Function rl_compentry_func_t;

#define rl_completion_matches(str, func) \

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

#endif

 

using namespace std;

 

  vertical=0, line_numbers=1, column_names=1,

  opt_nopager=1, opt_outfile=0, named_cmds= 0,

static uint32_t opt_max_allowed_packet, opt_net_buffer_length;

  *delimiter_str= 0,* current_prompt= 0;

static string *glob_buffer;

static string *processed_prompt= NULL;

static char *default_prompt= NULL;

static uint32_t opt_connect_timeout= 0;

// TODO: Need to i18n these

static const CHARSET_INFO *charset_info= &my_charset_utf8_general_ci;

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 void safe_put_field(const char *pos,uint32_t length);

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

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

  char cmd_char;        /* msql command character */

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

  bool takes_params;        /* Max parameters for command */

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

  { "?",      '?', com_help,   1, N_("Synonym for `help'.") },

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

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

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

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

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

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

  { "help",   'h', com_help,   1, N_("Display this help.") },

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

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

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

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

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

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

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

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

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

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

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

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

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

static void initialize_readline (char *name);

static void fix_history(string *final_command);

static COMMANDS *find_command(const char *name,char cmd_name);

static bool add_line(string *buffer,char *line,char *in_string,

static void remove_cntrl(string *buffer);

static uint32_t start_timer(void);

static void end_timer(uint32_t start_time,char *buff);

static void drizzle_end_timer(uint32_t start_time,char *buff);

extern RETSIGTYPE drizzle_end(int sig);

extern RETSIGTYPE handle_sigint(int sig);

static RETSIGTYPE window_resize(int sig);

#if defined(ENABLE_NLS)

# if defined(HAVE_LOCALE_H)

  setlocale(LC_ALL, "");

# endif

  bindtextdomain("drizzle", LOCALEDIR);

  textdomain("drizzle");

#endif

 

  default_prompt= my_strdup(getenv("DRIZZLE_PS1") ?

                            getenv("DRIZZLE_PS1") :

                            "drizzle>> ", MYF(0));

  current_prompt= my_strdup(default_prompt, MYF(0));

  processed_prompt= new string();

  processed_prompt->reserve(32);

 

  my_stpcpy(pager, "stdout");  // the default, if --pager wasn't given

      my_stpcpy(default_pager, tmp);

  memset(&drizzle, 0, sizeof(drizzle));

  put_info(_("Welcome to the Drizzle client..  Commands end with ; or \\g."),

 

  glob_buffer= new string();

  glob_buffer->reserve(512);

  

  char * output_buff= (char *)malloc(512);

  memset(output_buff, '\0', 512);

 

  sprintf(output_buff,

          _("Your Drizzle connection id is %u\nServer version: %s\n"),

          drizzle_thread_id(&drizzle),

          server_version_string(&drizzle));

  put_info(output_buff, INFO_INFO, 0, 0);

 

  initialize_readline(current_prompt);

  if (!status.batch && !quick)

    if (getenv("DRIZZLE_HISTFILE"))

      histfile= strdup(getenv("DRIZZLE_HISTFILE"));

        free(histfile);

        tee_fprintf(stdout, _("Reading history-file %s\n"),histfile);

        fprintf(stderr, _("Couldn't allocate memory for temp histfile!\n"));

          _("Type 'help;' or '\\h' for help. Type '\\c' to clear the buffer.\n"));

 

RETSIGTYPE drizzle_end(int sig)

  if (!status.batch && !quick && histfile)

      tee_fprintf(stdout, _("Writing history-file %s\n"),histfile);

    put_info(sig ? _("Aborted") : _("Bye"), INFO_RESULT,0,0);

  if (glob_buffer)

    delete glob_buffer;

  if (processed_prompt)

    delete processed_prompt;

  free(opt_password);

  free(opt_drizzle_unix_port);

  free(histfile);

  free(histfile_tmp);

  free(current_db);

  free(current_host);

  free(current_user);

  free(full_username);

  free(part_username);

  free(default_prompt);

  free(current_prompt);

RETSIGTYPE handle_sigint(int sig)

  kill_drizzle= drizzle_create(kill_drizzle);

  tee_fprintf(stdout, _("Query aborted by Ctrl+C\n"));

RETSIGTYPE window_resize(int sig __attribute__((unused)))

  {"help", '?', N_("Display this help and exit."), 0, 0, 0, GET_NO_ARG, NO_ARG, 0,

  {"help", 'I', N_("Synonym for -?"), 0, 0, 0, GET_NO_ARG, NO_ARG, 0,

   N_("Enable automatic rehashing. One doesn't need to use 'rehash' to get table and field completion, but startup and reconnecting may take a longer time. Disable with --disable-auto-rehash."),

   N_("No automatic rehashing. One has to use 'rehash' to get table and field completion. This gives a quicker start of DRIZZLE and disables rehashing on reconnect. WARNING: options deprecated; use --disable-auto-rehash instead."),

   N_("Automatically switch to vertical output mode if the result is wider than the terminal width."),

   N_("Don't use history file. Disable interactive behavior. (Enables --silent)"), 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

   N_("Directory where character sets are."), (char**) &charsets_dir,

  {"column-type-info", OPT_COLUMN_TYPES, N_("Display column type information."),

  {"comments", 'c', N_("Preserve comments. Send comments to the server. The default is --skip-comments (discard comments), enable with --comments"),

  {"compress", 'C', N_("Use compression in server/client protocol."),

  {"debug-check", OPT_DEBUG_CHECK, N_("Check memory and open file usage at exit ."),

  {"debug-info", 'T', N_("Print some debug info at exit."), (char**) &debug_info_flag,

  {"database", 'D', N_("Database to use."), (char**) &current_db,

   N_("(not used)"), 0,

   0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"delimiter", OPT_DELIMITER, N_("Delimiter to be used."), (char**) &delimiter_str,

  {"execute", 'e', N_("Execute command and quit. (Disables --force and history file)"), 0,

  {"vertical", 'E', N_("Print the output of a query (rows) vertically."),

  {"force", 'f', N_("Continue even if we get an sql error."),

   N_("Enable named commands. Named commands mean this program's internal commands; see drizzle> help . When enabled, the named commands can be used from any line of the query, otherwise only from the first line, before an enter. Disable with --disable-named-commands. This option is disabled by default."),

   N_("Named commands are disabled. Use \\* form only, or use named commands only in the beginning of a line ending with a semicolon (;) Since version 10.9 the client now starts with this option ENABLED by default! Disable with '-G'. Long format commands still work from the first line. WARNING: option deprecated; use --disable-named-commands instead."),

  {"ignore-spaces", 'i', N_("Ignore space after function names."), 0, 0, 0,

  {"local-infile", OPT_LOCAL_INFILE, N_("Enable/disable LOAD DATA LOCAL INFILE."),