~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 <mystrings/m_ctype.h>

#include <stdarg.h>

#include <math.h>

#include "client/linebuffer.h"

#include <signal.h>

#include <sys/ioctl.h>

#include <drizzled/configmake.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

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

void sql_element_free(void *ptr);

#if !defined(HAVE_VIDATTR)

#undef vidattr

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

#endif

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

typedef struct st_status

{

  int exit_status;

  uint32_t query_start_line;

  char *file_name;

  LineBuffer *line_buff;

  bool batch,add_to_history;

} STATUS;

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;

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 char * opt_drizzle_unix_port= NULL;

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

extern "C" bool get_one_option(int optid, const struct my_option *opt,

                               char *argument);

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 structure which contains information on the commands this program

   can understand. */

typedef struct {

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

} COMMANDS;

static COMMANDS commands[] = {

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

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

  { "connect",'r', com_connect,1,

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

  { "delimiter", 'd', com_delimiter,    1,

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

  { "ego",    'G', com_ego,    0,

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

  { "pager",  'P', com_pager,  1,

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

  { "source", '.', com_source, 1,

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

  { "tee",    'T', com_tee,    1,

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

  { "use",    'u', com_use,    1,

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

  { "warnings", 'W', com_warnings,  0,

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

  { "nowarning", 'w', com_nowarnings, 0,

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

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

  { "create table",     0, 0, 0, ""},

  { "create database",  0, 0, 0, ""},

  { "show databases",   0, 0, 0, ""},

  { "show fields from", 0, 0, 0, ""},

  { "show keys from",   0, 0, 0, ""},

  { "show tables",      0, 0, 0, ""},

  { "load data from",   0, 0, 0, ""},

  { "alter table",      0, 0, 0, ""},

  { "set option",       0, 0, 0, ""},

  { "lock tables",      0, 0, 0, ""},

  { "unlock tables",    0, 0, 0, ""},

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

  { "ACTION", 0, 0, 0, ""},

  { "ADD", 0, 0, 0, ""},

  { "AFTER", 0, 0, 0, ""},

  { "AGAINST", 0, 0, 0, ""},

  { "AGGREGATE", 0, 0, 0, ""},

  { "ALL", 0, 0, 0, ""},

  { "ALGORITHM", 0, 0, 0, ""},

  { "ALTER", 0, 0, 0, ""},

  { "ANALYZE", 0, 0, 0, ""},

  { "AND", 0, 0, 0, ""},

  { "ANY", 0, 0, 0, ""},

  { "AS", 0, 0, 0, ""},

  { "ASC", 0, 0, 0, ""},

  { "ASCII", 0, 0, 0, ""},

  { "ASENSITIVE", 0, 0, 0, ""},

  { "AUTO_INCREMENT", 0, 0, 0, ""},

  { "AVG", 0, 0, 0, ""},

  { "AVG_ROW_LENGTH", 0, 0, 0, ""},

  { "BACKUP", 0, 0, 0, ""},

  { "BDB", 0, 0, 0, ""},

  { "BEFORE", 0, 0, 0, ""},

  { "BEGIN", 0, 0, 0, ""},

  { "BERKELEYDB", 0, 0, 0, ""},

  { "BETWEEN", 0, 0, 0, ""},

  { "BIGINT", 0, 0, 0, ""},

  { "BINARY", 0, 0, 0, ""},

  { "BINLOG", 0, 0, 0, ""},

  { "BIT", 0, 0, 0, ""},

  { "BLOB", 0, 0, 0, ""},

  { "BOOL", 0, 0, 0, ""},

  { "BOOLEAN", 0, 0, 0, ""},

  { "BOTH", 0, 0, 0, ""},

  { "BTREE", 0, 0, 0, ""},

  { "BY", 0, 0, 0, ""},

  { "BYTE", 0, 0, 0, ""},

  { "CACHE", 0, 0, 0, ""},

  { "CALL", 0, 0, 0, ""},

  { "CASCADE", 0, 0, 0, ""},

  { "CASCADED", 0, 0, 0, ""},

  { "CASE", 0, 0, 0, ""},

  { "CHAIN", 0, 0, 0, ""},

  { "CHANGE", 0, 0, 0, ""},

  { "CHANGED", 0, 0, 0, ""},

  { "CHAR", 0, 0, 0, ""},

  { "CHARACTER", 0, 0, 0, ""},

  { "CHARSET", 0, 0, 0, ""},

  { "CHECK", 0, 0, 0, ""},

  { "CHECKSUM", 0, 0, 0, ""},

  { "CIPHER", 0, 0, 0, ""},

  { "CLIENT", 0, 0, 0, ""},

  { "CLOSE", 0, 0, 0, ""},

  { "CODE", 0, 0, 0, ""},

  { "COLLATE", 0, 0, 0, ""},

  { "COLLATION", 0, 0, 0, ""},

  { "COLUMN", 0, 0, 0, ""},

  { "COLUMNS", 0, 0, 0, ""},

  { "COMMENT", 0, 0, 0, ""},

  { "COMMIT", 0, 0, 0, ""},

  { "COMMITTED", 0, 0, 0, ""},

  { "COMPACT", 0, 0, 0, ""},

  { "COMPRESSED", 0, 0, 0, ""},

  { "CONCURRENT", 0, 0, 0, ""},

  { "CONDITION", 0, 0, 0, ""},

  { "CONNECTION", 0, 0, 0, ""},

  { "CONSISTENT", 0, 0, 0, ""},

  { "CONSTRAINT", 0, 0, 0, ""},

  { "CONTAINS", 0, 0, 0, ""},

  { "CONTINUE", 0, 0, 0, ""},

  { "CONVERT", 0, 0, 0, ""},

  { "CREATE", 0, 0, 0, ""},

  { "CROSS", 0, 0, 0, ""},

  { "CUBE", 0, 0, 0, ""},

  { "CURRENT_DATE", 0, 0, 0, ""},

  { "CURRENT_TIMESTAMP", 0, 0, 0, ""},

  { "CURRENT_USER", 0, 0, 0, ""},

  { "CURSOR", 0, 0, 0, ""},

  { "DATA", 0, 0, 0, ""},

  { "DATABASE", 0, 0, 0, ""},

  { "DATABASES", 0, 0, 0, ""},

  { "DATE", 0, 0, 0, ""},

  { "DATETIME", 0, 0, 0, ""},

  { "DAY", 0, 0, 0, ""},

  { "DAY_HOUR", 0, 0, 0, ""},

  { "DAY_MICROSECOND", 0, 0, 0, ""},

  { "DAY_MINUTE", 0, 0, 0, ""},

  { "DAY_SECOND", 0, 0, 0, ""},

  { "DEALLOCATE", 0, 0, 0, ""},

  { "DEC", 0, 0, 0, ""},

  { "DECIMAL", 0, 0, 0, ""},

  { "DECLARE", 0, 0, 0, ""},

  { "DEFAULT", 0, 0, 0, ""},

  { "DEFINER", 0, 0, 0, ""},

  { "DELAYED", 0, 0, 0, ""},

  { "DELAY_KEY_WRITE", 0, 0, 0, ""},

  { "DELETE", 0, 0, 0, ""},

  { "DESC", 0, 0, 0, ""},

  { "DESCRIBE", 0, 0, 0, ""},

  { "DES_KEY_FILE", 0, 0, 0, ""},

  { "DETERMINISTIC", 0, 0, 0, ""},

  { "DIRECTORY", 0, 0, 0, ""},

  { "DISABLE", 0, 0, 0, ""},

  { "DISCARD", 0, 0, 0, ""},

  { "DISTINCT", 0, 0, 0, ""},

  { "DISTINCTROW", 0, 0, 0, ""},

  { "DIV", 0, 0, 0, ""},

  { "DO", 0, 0, 0, ""},

  { "DOUBLE", 0, 0, 0, ""},

  { "DROP", 0, 0, 0, ""},

  { "DUAL", 0, 0, 0, ""},

  { "DUMPFILE", 0, 0, 0, ""},

  { "DUPLICATE", 0, 0, 0, ""},

  { "DYNAMIC", 0, 0, 0, ""},

  { "EACH", 0, 0, 0, ""},

  { "ELSE", 0, 0, 0, ""},

  { "ELSEIF", 0, 0, 0, ""},

  { "ENABLE", 0, 0, 0, ""},

  { "ENCLOSED", 0, 0, 0, ""},

  { "END", 0, 0, 0, ""},

  { "ENGINE", 0, 0, 0, ""},

  { "ENGINES", 0, 0, 0, ""},

  { "ENUM", 0, 0, 0, ""},

  { "ERRORS", 0, 0, 0, ""},

  { "ESCAPE", 0, 0, 0, ""},

  { "ESCAPED", 0, 0, 0, ""},

  { "EVENTS", 0, 0, 0, ""},

  { "EXECUTE", 0, 0, 0, ""},

  { "EXISTS", 0, 0, 0, ""},

  { "EXIT", 0, 0, 0, ""},

  { "EXPANSION", 0, 0, 0, ""},

  { "EXPLAIN", 0, 0, 0, ""},

  { "EXTENDED", 0, 0, 0, ""},

  { "FALSE", 0, 0, 0, ""},

  { "FAST", 0, 0, 0, ""},

  { "FETCH", 0, 0, 0, ""},

  { "FIELDS", 0, 0, 0, ""},

  { "FILE", 0, 0, 0, ""},

  { "FIRST", 0, 0, 0, ""},

  { "FIXED", 0, 0, 0, ""},

  { "FLOAT", 0, 0, 0, ""},

  { "FLOAT4", 0, 0, 0, ""},

  { "FLOAT8", 0, 0, 0, ""},

  { "FLUSH", 0, 0, 0, ""},

  { "FOR", 0, 0, 0, ""},

  { "FORCE", 0, 0, 0, ""},

  { "FOREIGN", 0, 0, 0, ""},

  { "FOUND", 0, 0, 0, ""},

  { "FRAC_SECOND", 0, 0, 0, ""},

  { "FROM", 0, 0, 0, ""},

  { "FULL", 0, 0, 0, ""},

  { "FULLTEXT", 0, 0, 0, ""},

  { "FUNCTION", 0, 0, 0, ""},

  { "GLOBAL", 0, 0, 0, ""},

  { "GRANT", 0, 0, 0, ""},

  { "GRANTS", 0, 0, 0, ""},

  { "GROUP", 0, 0, 0, ""},

  { "HANDLER", 0, 0, 0, ""},

  { "HASH", 0, 0, 0, ""},

  { "HAVING", 0, 0, 0, ""},

  { "HELP", 0, 0, 0, ""},

  { "HIGH_PRIORITY", 0, 0, 0, ""},

  { "HOSTS", 0, 0, 0, ""},

  { "HOUR", 0, 0, 0, ""},

  { "HOUR_MICROSECOND", 0, 0, 0, ""},

  { "HOUR_MINUTE", 0, 0, 0, ""},

  { "HOUR_SECOND", 0, 0, 0, ""},

  { "IDENTIFIED", 0, 0, 0, ""},

  { "IF", 0, 0, 0, ""},

  { "IGNORE", 0, 0, 0, ""},

  { "IMPORT", 0, 0, 0, ""},

  { "IN", 0, 0, 0, ""},

  { "INDEX", 0, 0, 0, ""},

  { "INDEXES", 0, 0, 0, ""},

  { "INFILE", 0, 0, 0, ""},

  { "INNER", 0, 0, 0, ""},

  { "INNOBASE", 0, 0, 0, ""},

  { "INNODB", 0, 0, 0, ""},

  { "INOUT", 0, 0, 0, ""},

  { "INSENSITIVE", 0, 0, 0, ""},

  { "INSERT", 0, 0, 0, ""},

  { "INSERT_METHOD", 0, 0, 0, ""},

  { "INT", 0, 0, 0, ""},

  { "INT1", 0, 0, 0, ""},

  { "INT2", 0, 0, 0, ""},

  { "INT3", 0, 0, 0, ""},

  { "INT4", 0, 0, 0, ""},

  { "INT8", 0, 0, 0, ""},

  { "INTEGER", 0, 0, 0, ""},

  { "INTERVAL", 0, 0, 0, ""},

  { "INTO", 0, 0, 0, ""},

  { "IO_THREAD", 0, 0, 0, ""},

  { "IS", 0, 0, 0, ""},

  { "ISOLATION", 0, 0, 0, ""},

  { "ISSUER", 0, 0, 0, ""},

  { "ITERATE", 0, 0, 0, ""},

  { "INVOKER", 0, 0, 0, ""},

  { "JOIN", 0, 0, 0, ""},

  { "KEY", 0, 0, 0, ""},

  { "KEYS", 0, 0, 0, ""},

  { "KILL", 0, 0, 0, ""},

  { "LANGUAGE", 0, 0, 0, ""},

  { "LAST", 0, 0, 0, ""},

  { "LEADING", 0, 0, 0, ""},

  { "LEAVE", 0, 0, 0, ""},

  { "LEAVES", 0, 0, 0, ""},

  { "LEFT", 0, 0, 0, ""},

  { "LEVEL", 0, 0, 0, ""},

  { "LIKE", 0, 0, 0, ""},

  { "LIMIT", 0, 0, 0, ""},

  { "LINES", 0, 0, 0, ""},

  { "LINESTRING", 0, 0, 0, ""},

  { "LOAD", 0, 0, 0, ""},

  { "LOCAL", 0, 0, 0, ""},

  { "LOCALTIMESTAMP", 0, 0, 0, ""},

  { "LOCK", 0, 0, 0, ""},