~drizzle-trunk/drizzle/development

/* drizzle command tool

#include "config.h"

 

#include <string>

 

#include <mystrings/m_ctype.h>

#define __GNU_LIBRARY__          // Skip warnings in getopt.h

#include <sys/ioctl.h>

 

 

#if defined(HAVE_LOCALE_H)

#include <libdrizzle/gettext.h>

#define MAX_COLUMN_LENGTH       (uint32_t)1024

/* Array of options to pass to libdrizzled */

void* sql_alloc(unsigned size);       // Don't use drizzled alloc for these

 

#ifdef __sun

#undef clear

#undef erase

#endif

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

#undef SYSV        // hack to avoid syntax error

#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

 

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

using namespace std;

 

static DRIZZLE drizzle;      /* The connection */

static bool ignore_errors=0,quick=0,

  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;

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

static char * opt_drizzle_unix_port=0;

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

static char drizzle_charsets_dir[FN_REFLEN+1];

// TODO: Need to i18n these

static const CHARSET_INFO *charset_info= &my_charset_utf8_general_ci;

int drizzle_real_query_for_lazy(const char *buf, int length);

int drizzle_store_result_for_lazy(DRIZZLE_RES **result);

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 const char *server_version_string(DRIZZLE *drizzle);

static int put_error(DRIZZLE *drizzle);

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

static int get_result_width(DRIZZLE_RES *res);

static int get_field_disp_length(DRIZZLE_FIELD * field);

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 const char *load_default_groups[]= { "drizzle","client",0 };

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 void print_table_data(DRIZZLE_RES *result);

static void print_tab_data(DRIZZLE_RES *result);

static void print_table_data_vertically(DRIZZLE_RES *result);

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

 

  outfile[0]=0;      // no (default) outfile

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

      my_stpcpy(default_pager, tmp);

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

    quick= 1;          // Avoid history

    drizzle_end(-1);

    ignore_errors=1;        // Don't abort monitor

  signal(SIGQUIT, drizzle_end);      // Catch SIGQUIT to clean up

  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)

    /* read-history from file, default ~/.drizzle_history*/

    if (getenv("DRIZZLE_HISTFILE"))

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

                                 + (uint) strlen("/.drizzle_history")+2,

        sprintf(histfile,"%s/.drizzle_history",getenv("HOME"));

        /* The .drizzle_history file is a symlink to /dev/null, don't use it */

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

  drizzle_end(0);

 

  return(0);        // Keep compiler happy

RETSIGTYPE drizzle_end(int sig)

  drizzle_close(&drizzle);

  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)

  DRIZZLE *kill_drizzle= NULL;

  kill_drizzle= drizzle_create(kill_drizzle);

  if (!drizzle_connect(kill_drizzle,current_host, current_user, opt_password,

                          "", opt_drizzle_port, opt_drizzle_unix_port,0))

  sprintf(kill_buffer, "KILL /*!50000 QUERY */ %u", drizzle_thread_id(&drizzle));

  drizzle_real_query(kill_drizzle, kill_buffer, strlen(kill_buffer));

  drizzle_close(kill_drizzle);

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

  drizzle_end(sig);

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

  {"no-beep", 'b', N_("Turn off beep on error."), (char**) &opt_nobeep,

  {"host", 'h', N_("Connect to host."), (char**) &current_host,

  {"line-numbers", OPT_LINE_NUMBERS, N_("Write line numbers for errors."),

  {"skip-line-numbers", 'L', N_("Don't write line number for errors. WARNING: -L is deprecated, use long version of this option instead."), 0, 0, 0, GET_NO_ARG,

  {"unbuffered", 'n', N_("Flush buffer after each query."), (char**) &unbuffered,

  {"column-names", OPT_COLUMN_NAMES, N_("Write column names in results."),

   N_("Don't write column names in results. WARNING: -N is deprecated, use long version of this options instead."),

   N_("Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value."),

  {"sigint-ignore", OPT_SIGINT_IGNORE, N_("Ignore SIGINT (CTRL-C)"),

   N_("Only update the default database. This is useful for skipping updates to other database in the update log."),

   N_("Pager to use to display results. If you don't supply an option the default pager is taken from your ENV variable PAGER. Valid pagers are less, more, cat [> filename], etc. See interactive help (\\h) also. This option does not work in batch mode. Disable with --disable-pager. This option is disabled by default."),

   N_("Disable pager and print to stdout. See interactive help (\\h) also. WARNING: option deprecated; use --disable-pager instead."),

   N_("Password to use when connecting to server. If password is not given it's asked from the tty."),

  {"port", 'P', N_("Port number to use for connection or 0 for default to, in order of preference, my.cnf, $DRIZZLE_TCP_PORT, ")

   N_("built-in default") " (" STRINGIFY_ARG(DRIZZLE_PORT) ").",

   (char**) &opt_drizzle_port,

   (char**) &opt_drizzle_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0,  0},

  {"prompt", OPT_PROMPT, N_("Set the drizzle prompt to this value."),

  {"protocol", OPT_DRIZZLE_PROTOCOL, N_("The protocol of connection (tcp,socket,pipe,memory)."),

   N_("Don't cache result, print it row by row. This may slow down the server if the output is suspended. Doesn't use history file."),