diff options
Diffstat (limited to 'client/mysqladmin.c')
-rw-r--r-- | client/mysqladmin.c | 1099 |
1 files changed, 1099 insertions, 0 deletions
diff --git a/client/mysqladmin.c b/client/mysqladmin.c new file mode 100644 index 00000000000..62c01fc1bfd --- /dev/null +++ b/client/mysqladmin.c @@ -0,0 +1,1099 @@ +/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB + + 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* maintaince of mysql databases */ + + +#include <global.h> +#include <my_sys.h> +#include <m_string.h> +#include <signal.h> +#include "mysql.h" +#include "errmsg.h" +#include <getopt.h> +#ifdef THREAD +#include <my_pthread.h> /* because of signal() */ +#endif + +#define ADMIN_VERSION "8.8" +#define MAX_MYSQL_VAR 64 +#define MAX_TIME_TO_WAIT 3600 /* Wait for shutdown */ +#define MAX_TRUNC_LENGTH 3 + +char truncated_var_names[MAX_MYSQL_VAR][MAX_TRUNC_LENGTH]; +char ex_var_names[MAX_MYSQL_VAR][FN_REFLEN]; +ulonglong last_values[MAX_MYSQL_VAR]; +static int interval=0; +static my_bool option_force=0,interrupted=0,new_line=0,option_silent=0, + opt_compress=0, opt_relative=0, opt_verbose=0, opt_vertical=0; +static uint tcp_port = 0, option_wait = 0; +static my_string unix_port=0; + +/* When using extended-status relatively, ex_val_max_len is the estimated + maximum length for any relative value printed by extended-status. The + idea is to try to keep the length of output as short as possible. */ +static uint ex_val_max_len[MAX_MYSQL_VAR]; +static my_bool ex_status_printed = 0; /* First output is not relative. */ +static uint ex_var_count, max_var_length, max_val_length; + +#include "sslopt-vars.h" + +static void print_version(void); +static void usage(void); +static my_bool sql_connect(MYSQL *mysql,const char *host, const char *user, + const char *password,uint wait); +static my_bool execute_commands(MYSQL *mysql,int argc, char **argv); +static int drop_db(MYSQL *mysql,const char *db); +static sig_handler endprog(int signal_number); +static void nice_time(ulong sec,char *buff); +static void print_header(MYSQL_RES *result); +static void print_top(MYSQL_RES *result); +static void print_row(MYSQL_RES *result,MYSQL_ROW cur, uint row); +static void print_relative_row(MYSQL_RES *result, MYSQL_ROW cur, uint row); +static void print_relative_row_vert(MYSQL_RES *result, MYSQL_ROW cur, uint row); +static void print_relative_header(); +static void print_relative_line(); +static void truncate_names(); +static my_bool get_pidfile(MYSQL *mysql, char *pidfile); +static void wait_pidfile(char *pidfile); +static void store_values(MYSQL_RES *result); + +/* + The order of commands must be the same as command_names, + except ADMIN_ERROR +*/ +enum commands { ADMIN_ERROR, ADMIN_CREATE, ADMIN_DROP, ADMIN_SHUTDOWN, + ADMIN_RELOAD, ADMIN_REFRESH, ADMIN_VER, ADMIN_PROCESSLIST, + ADMIN_STATUS, ADMIN_KILL, ADMIN_DEBUG, ADMIN_VARIABLES, + ADMIN_FLUSH_LOGS, ADMIN_FLUSH_HOSTS, ADMIN_FLUSH_TABLES, + ADMIN_PASSWORD, ADMIN_PING, ADMIN_EXTENDED_STATUS, + ADMIN_FLUSH_STATUS, ADMIN_FLUSH_PRIVILEGES, ADMIN_START_SLAVE, + ADMIN_STOP_SLAVE, ADMIN_FLUSH_THREADS +}; +static const char *command_names[]= +{"create","drop","shutdown","reload","refresh", + "version", "processlist","status","kill","debug", + "variables","flush-logs","flush-hosts", + "flush-tables","password","ping", + "extended-status","flush-status", + "flush-privileges", "start-slave","stop-slave", "flush-threads", NullS}; +static TYPELIB command_typelib= +{ array_elements(command_names)-1,"commands", command_names}; + +enum options { OPT_CHARSETS_DIR=256 }; + +static struct option long_options[] = +{ + {"compress", no_argument, 0, 'C'}, + {"character-sets-dir",required_argument, 0, OPT_CHARSETS_DIR}, + {"debug", optional_argument, 0, '#'}, + {"force", no_argument, 0, 'f'}, + {"help", no_argument, 0, '?'}, + {"host", required_argument, 0, 'h'}, + {"password", optional_argument, 0, 'p'}, +#ifdef __WIN__ + {"pipe", no_argument, 0, 'W'}, +#endif + {"port", required_argument, 0, 'P'}, + {"relative", no_argument, 0, 'r'}, + {"silent", no_argument, 0, 's'}, + {"socket", required_argument, 0, 'S'}, + {"sleep", required_argument, 0, 'i'}, +#include "sslopt-longopts.h" + {"timeout", required_argument, 0, 't'}, +#ifndef DONT_ALLOW_USER_CHANGE + {"user", required_argument, 0, 'u'}, +#endif + {"verbose", no_argument, 0, 'v'}, + {"version", no_argument, 0, 'V'}, + {"vertical", no_argument, 0, 'E'}, + {"wait", optional_argument, 0, 'w'}, + {0, 0, 0, 0} +}; + +static const char *load_default_groups[]= { "mysqladmin","client",0 }; + +int main(int argc,char *argv[]) +{ + int c, error = 0,option_index=0; + MYSQL mysql; + char *host = NULL,*password=0,*user=0,**commands; + my_bool tty_password=0; + MY_INIT(argv[0]); + mysql_init(&mysql); + load_defaults("my",load_default_groups,&argc,&argv); + + while ((c=getopt_long(argc,argv,"h:i:p::u:#::P:sS:Ct:fq?vVw::WrE", + long_options, &option_index)) != EOF) + { + switch(c) { + case 'C': + opt_compress=1; + break; + case 'h': + host = optarg; + break; + case 'q': /* Allow old 'q' option */ + case 'f': + option_force++; + break; + case 'p': + if (optarg) + { + my_free(password,MYF(MY_ALLOW_ZERO_PTR)); + password=my_strdup(optarg,MYF(MY_FAE)); + while (*optarg) *optarg++= 'x'; /* Destroy argument */ + } + else + tty_password=1; + break; +#ifndef DONT_ALLOW_USER_CHANGE + case 'u': + user= my_strdup(optarg,MYF(0)); + break; +#endif + case 'i': + interval=atoi(optarg); + break; + case 'P': + tcp_port= (unsigned int) atoi(optarg); + break; + case 'r': + opt_relative = 1; + break; + case 'E': + opt_vertical = 1; + break; + case 's': + option_silent = 1; + break; + case 'S': + unix_port= optarg; + break; + case 'W': +#ifdef __WIN__ + unix_port=MYSQL_NAMEDPIPE; +#endif + break; + case 't': + { + uint tmp=atoi(optarg); + mysql_options(&mysql,MYSQL_OPT_CONNECT_TIMEOUT, (char*) &tmp); + break; + } + case '#': + DBUG_PUSH(optarg ? optarg : "d:t:o,/tmp/mysqladmin.trace"); + break; + case 'V': + print_version(); + exit(0); + break; + case 'v': + opt_verbose=1; + break; + case 'w': + if (optarg) + { + if ((option_wait=atoi(optarg)) <= 0) + option_wait=1; + } + else + option_wait= ~0; + break; +#include "sslopt-case.h" + default: + fprintf(stderr,"Illegal option character '%c'\n",opterr); + /* Fall throught */ + case '?': + case 'I': /* Info */ + error++; + break; + case OPT_CHARSETS_DIR: +#if MYSQL_VERSION_ID > 32300 + charsets_dir = optarg; +#endif + break; + } + } + argc -= optind; + commands = argv + optind; + if (error || argc == 0) + { + usage(); + exit(1); + } + if (tty_password) + password = get_tty_password(NullS); + + VOID(signal(SIGINT,endprog)); /* Here if abort */ + VOID(signal(SIGTERM,endprog)); /* Here if abort */ + + mysql_init(&mysql); + if (opt_compress) + mysql_options(&mysql,MYSQL_OPT_COMPRESS,NullS); +#ifdef HAVE_OPENSSL + if (opt_use_ssl) + mysql_ssl_set(&mysql, opt_ssl_key, opt_ssl_cert, opt_ssl_ca, + opt_ssl_capath); +#endif /* HAVE_OPENSSL */ + if (sql_connect(&mysql,host,user,password,option_wait)) + error = 1; + else + { + error = 0; + while (!interrupted) + { + new_line = 0; + if (execute_commands(&mysql,argc,commands) && !option_force) + { + if (option_wait && !interrupted) + { + mysql_close(&mysql); + if (!sql_connect(&mysql,host,user,password,option_wait)) + continue; /* Retry */ + } + error=1; + break; + } + if (interval) + { + sleep(interval); + if (new_line) + puts(""); + } + else + break; + } + mysql_close(&mysql); + } + my_free(password,MYF(MY_ALLOW_ZERO_PTR)); + my_free(user,MYF(MY_ALLOW_ZERO_PTR)); + free_defaults(argv); + my_end(0); + exit(error); + return 0; +} + + +static sig_handler endprog(int signal_number __attribute__((unused))) +{ + interrupted=1; +} + + +static my_bool sql_connect(MYSQL *mysql,const char *host, const char *user, + const char *password,uint wait) +{ + my_bool info=0; + + for (;;) + { + if (mysql_real_connect(mysql,host,user,password,NullS,tcp_port,unix_port, + 0)) + { + if (info) + { + fputs("\n",stderr); + (void) fflush(stderr); + } + return 0; + } + + if (!wait) + { + if (!option_silent) + { + if (!host) + host=LOCAL_HOST; + my_printf_error(0,"connect to server at '%s' failed\nerror: '%s'", + MYF(ME_BELL), host, mysql_error(mysql)); + if (mysql_errno(mysql) == CR_CONNECTION_ERROR) + { + fprintf(stderr, + "Check that mysqld is running and that the socket: '%s' exists!\n", + unix_port ? unix_port : mysql_unix_port); + } + else if (mysql_errno(mysql) == CR_CONN_HOST_ERROR || + mysql_errno(mysql) == CR_UNKNOWN_HOST) + { + fprintf(stderr,"Check that mysqld is running on %s",host); + fprintf(stderr," and that the port is %d.\n", + tcp_port ? tcp_port: mysql_port); + fprintf(stderr,"You can check this by doing 'telnet %s %d'\n", + host, tcp_port ? tcp_port: mysql_port); + } + } + return 1; + } + if (wait != (uint) ~0) + wait--; /* One less retry */ + if ((mysql_errno(mysql) != CR_CONN_HOST_ERROR) && + (mysql_errno(mysql) != CR_CONNECTION_ERROR)) + { + fprintf(stderr,"Got error: %s\n", mysql_error(mysql)); + if (!option_force) + return 1; + sleep(5); + } + else if (!info) + { + info=1; + fputs("Waiting for MySQL server to answer",stderr); + (void) fflush(stderr); + sleep(5); + } + else + { + putc('.',stderr); + (void) fflush(stderr); + sleep(5); + } + } +} + + +static my_bool execute_commands(MYSQL *mysql,int argc, char **argv) +{ + char *status; + + for (; argc > 0 ; argv++,argc--) + { + switch (find_type(argv[0],&command_typelib,2)) { + case ADMIN_CREATE: + { + char buff[FN_REFLEN+20]; + if (argc < 2) + { + my_printf_error(0,"Too few arguments to create",MYF(ME_BELL)); + return 1; + } + sprintf(buff,"create database %.*s",FN_REFLEN,argv[1]); + if (mysql_query(mysql,buff)) + return 1; + else + { + argc--; argv++; + } + break; + } + case ADMIN_DROP: + { + if (argc < 2) + { + my_printf_error(0,"Too few arguments to drop",MYF(ME_BELL)); + return 1; + } + if (drop_db(mysql,argv[1])) + return 1; + else + { + argc--; argv++; + } + break; + } + case ADMIN_SHUTDOWN: + { + char pidfile[FN_REFLEN]; + my_bool got_pidfile=0; + /* Only wait for pidfile on local connections */ + /* If pidfile doesn't exist, continue without pid file checking */ + if (mysql->unix_socket) + got_pidfile= !get_pidfile(mysql, pidfile); + if (mysql_shutdown(mysql)) + { + my_printf_error(0,"shutdown failed; error: '%s'",MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + mysql_close(mysql); /* Close connection to avoid error messages */ + if (got_pidfile) + { + if (opt_verbose) + printf("Shutdown signal sent to server; Waiting for pid file to disappear\n"); + wait_pidfile(pidfile); /* Wait until pid file is gone */ + } + break; + } + case ADMIN_FLUSH_PRIVILEGES: + case ADMIN_RELOAD: + if (mysql_refresh(mysql,REFRESH_GRANT) < 0) + { + my_printf_error(0,"reload failed; error: '%s'",MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + break; + case ADMIN_REFRESH: + if (mysql_refresh(mysql, + (uint) ~(REFRESH_GRANT | REFRESH_STATUS | + REFRESH_READ_LOCK)) < 0) + { + my_printf_error(0,"refresh failed; error: '%s'",MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + break; + case ADMIN_FLUSH_THREADS: + if (mysql_refresh(mysql,(uint) REFRESH_THREADS) < 0) + { + my_printf_error(0,"refresh failed; error: '%s'",MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + break; + case ADMIN_VER: + new_line=1; + print_version(); + puts("TCX Datakonsult AB, by Monty\n"); + printf("Server version\t\t%s\n", mysql_get_server_info(mysql)); + printf("Protocol version\t%d\n", mysql_get_proto_info(mysql)); + printf("Connection\t\t%s\n",mysql_get_host_info(mysql)); + if (mysql->unix_socket) + printf("UNIX socket\t\t%s\n", mysql->unix_socket); + else + printf("TCP port\t\t%d\n", mysql->port); + status=mysql_stat(mysql); + { + char *pos,buff[40]; + ulong sec; + pos=strchr(status,' '); + *pos++=0; + printf("%s\t\t\t",status); /* print label */ + if ((status=str2int(pos,10,0,LONG_MAX,(long*) &sec))) + { + nice_time(sec,buff); + puts(buff); /* print nice time */ + while (*status == ' ') status++; /* to next info */ + } + } + putc('\n',stdout); + if (status) + puts(status); + break; + case ADMIN_PROCESSLIST: + { + MYSQL_RES *result; + MYSQL_ROW row; + + if (mysql_query(mysql, (opt_verbose ? "show full processlist" : + "show processlist")) || + !(result = mysql_store_result(mysql))) + { + my_printf_error(0,"process list failed; error: '%s'",MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + print_header(result); + while ((row=mysql_fetch_row(result))) + print_row(result,row,0); + print_top(result); + mysql_free_result(result); + new_line=1; + break; + } + case ADMIN_STATUS: + status=mysql_stat(mysql); + if (status) + puts(status); + break; + case ADMIN_KILL: + { + uint error=0; + char *pos; + if (argc < 2) + { + my_printf_error(0,"Too few arguments to 'kill'",MYF(ME_BELL)); + return 1; + } + pos=argv[1]; + for (;;) + { + if (mysql_kill(mysql,(ulong) atol(pos))) + { + my_printf_error(0,"kill failed on %ld; error: '%s'",MYF(ME_BELL), + atol(pos), mysql_error(mysql)); + error=1; + } + if (!(pos=strchr(pos,','))) + break; + pos++; + } + argc--; argv++; + if (error) + return error; + break; + } + case ADMIN_DEBUG: + if (mysql_dump_debug_info(mysql)) + { + my_printf_error(0,"debug failed; error: '%s'",MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + break; + case ADMIN_VARIABLES: + { + MYSQL_RES *res; + MYSQL_ROW row; + + new_line=1; + if (mysql_query(mysql,"show variables") || + !(res=mysql_store_result(mysql))) + { + my_printf_error(0,"unable to show variables; error: '%s'",MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + print_header(res); + while ((row=mysql_fetch_row(res))) + print_row(res,row,0); + print_top(res); + mysql_free_result(res); + break; + } + case ADMIN_EXTENDED_STATUS: + { + MYSQL_RES *res; + MYSQL_ROW row; + uint rownr = 0; + void (*func) (MYSQL_RES*, MYSQL_ROW, uint); + + new_line = 1; + if (mysql_query(mysql, "show status") || + !(res = mysql_store_result(mysql))) + { + my_printf_error(0, "unable to show status; error: '%s'", MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + if (!opt_vertical) + print_header(res); + else + { + if (!ex_status_printed) + { + store_values(res); + truncate_names(); /* Does some printing also */ + } + else + { + print_relative_line(); + print_relative_header(); + print_relative_line(); + } + } + + /* void (*func) (MYSQL_RES*, MYSQL_ROW, uint); */ + if (opt_relative && !opt_vertical) + func = print_relative_row; + else if (opt_vertical) + func = print_relative_row_vert; + else + func = print_row; + + while ((row = mysql_fetch_row(res))) + (*func)(res, row, rownr++); + if (opt_vertical) + { + if (ex_status_printed) + { + putchar('\n'); + print_relative_line(); + } + } + else + print_top(res); + + ex_status_printed = 1; /* From now on the output will be relative */ + mysql_free_result(res); + break; + } + case ADMIN_FLUSH_LOGS: + { + if (mysql_refresh(mysql,REFRESH_LOG)) + { + my_printf_error(0,"refresh failed; error: '%s'",MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + break; + } + case ADMIN_FLUSH_HOSTS: + { + if (mysql_refresh(mysql,REFRESH_HOSTS)) + { + my_printf_error(0,"refresh failed; error: '%s'",MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + break; + } + case ADMIN_FLUSH_TABLES: + { + if (mysql_refresh(mysql,REFRESH_TABLES)) + { + my_printf_error(0,"refresh failed; error: '%s'",MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + break; + } + case ADMIN_FLUSH_STATUS: + { + if (mysql_refresh(mysql,REFRESH_STATUS)) + { + my_printf_error(0,"refresh failed; error: '%s'",MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + break; + } + case ADMIN_PASSWORD: + { + char buff[128],crypted_pw[33]; + + if(argc < 2) + { + my_printf_error(0,"Too few arguments to change password",MYF(ME_BELL)); + return 1; + } + if (argv[1][0]) + make_scrambled_password(crypted_pw,argv[1]); + else + crypted_pw[0]=0; /* No password */ + sprintf(buff,"set password='%s',sql_log_off=0",crypted_pw); + + if (mysql_query(mysql,"set sql_log_off=1")) + { + my_printf_error(0, "Can't turn off logging; error: '%s'", + MYF(ME_BELL),mysql_error(mysql)); + return 1; + } + if (mysql_query(mysql,buff)) + { + my_printf_error(0,"unable to change password; error: '%s'", + MYF(ME_BELL),mysql_error(mysql)); + return 1; + } + argc--; argv++; + break; + } + + case ADMIN_START_SLAVE: + if (mysql_query(mysql, "SLAVE START")) + { + my_printf_error(0, "Error starting slave: %s", MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + else + puts("Slave started"); + break; + case ADMIN_STOP_SLAVE: + if (mysql_query(mysql, "SLAVE STOP")) + { + my_printf_error(0, "Error stopping slave: %s", MYF(ME_BELL), + mysql_error(mysql)); + return 1; + } + else + puts("Slave stopped"); + break; + + case ADMIN_PING: + mysql->reconnect=0; /* We want to know of reconnects */ + if (!mysql_ping(mysql)) + puts("mysqld is alive"); + else + { + if (mysql_errno(mysql) == CR_SERVER_GONE_ERROR) + { + mysql->reconnect=1; + if (!mysql_ping(mysql)) + puts("connection was down, but mysqld is now alive"); + } + else + { + my_printf_error(0,"mysqld doesn't answer to ping, error: '%s'", + MYF(ME_BELL),mysql_error(mysql)); + return 1; + } + } + mysql->reconnect=1; /* Automatic reconnect is default */ + break; + default: + my_printf_error(0,"Unknown command: '%s'",MYF(ME_BELL),argv[0]); + return 1; + } + } + return 0; +} + + +static void print_version(void) +{ + printf("%s Ver %s Distrib %s, for %s on %s\n",my_progname,ADMIN_VERSION, + MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE); +} + + +static void usage(void) +{ + print_version(); + puts("Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB"); + puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,\nand you are welcome to modify and redistribute it under the GPL license\n"); + puts("Administer program for the mysqld demon"); + printf("Usage: %s [OPTIONS] command command....\n", my_progname); + printf("\n\ + -#, --debug=... Output debug log. Often this is 'd:t:o,filename`\n\ + -f, --force Don't ask for confirmation on drop database; with\n\ + multiple commands, continue even if an error occurs\n\ + -?, --help Display this help and exit\n\ + --character-sets-dir=...\n\ + Set the character set directory\n\ + -C, --compress Use compression in server/client protocol\n\ + -h, --host=# Connect to host\n\ + -p, --password[=...] Password to use when connecting to server\n\ + If password is not given it's asked from the tty\n"); +#ifdef __WIN__ + puts("-W, --pipe Use named pipes to connect to server"); +#endif + printf("\ + -P --port=... Port number to use for connection\n\ + -i, --sleep=sec Execute commands again and again with a sleep between\n\ + -r, --relative Show difference between current and previous values\n\ + when used with -i. Currently works only with\n\ + extended-status\n\ + -E, --vertical Print output vertically. Is similar to --relative,\n\ + but prints output vertically.\n\ + -s, --silent Silently exit if one can't connect to server\n\ + -S, --socket=... Socket file to use for connection\n"); +#include "sslopt-usage.h" + printf("\ + -t, --timeout=... Timeout for connection to the mysqld server\n"); +#ifndef DONT_ALLOW_USER_CHANGE + printf("\ + -u, --user=# User for login if not current user\n"); +#endif + printf("\ + -v, --verbose Write more information\n\ + -V, --version Output version information and exit\n\ + -w, --wait[=retries] Wait and retry if connection is down\n"); + print_defaults("my",load_default_groups); + + puts("\nWhere command is a one or more of: (Commands may be shortened)\n\ + create databasename Create a new database\n\ + drop databasename Delete a database and all its tables\n\ + extended-status Gives an extended status message from the server\n\ + flush-hosts Flush all cached hosts\n\ + flush-logs Flush all logs\n\ + flush-status Clear status variables\n\ + flush-tables Flush all tables\n\ + flush-threads Flush the thread cache\n\ + flush-privileges Reload grant tables (same as reload)\n\ + kill id,id,... Kill mysql threads"); +#if MYSQL_VERSION_ID >= 32200 + puts("\ + password new-password Change old password to new-password"); +#endif + puts("\ + ping Check if mysqld is alive\n\ + processlist Show list of active threads in server\n\ + reload Reload grant tables\n\ + refresh Flush all tables and close and open logfiles\n\ + shutdown Take server down\n\ + status Gives a short status message from the server\n\ + variables Prints variables available\n\ + version Get version info from server"); +} + +static int drop_db(MYSQL *mysql, const char *db) +{ + char name_buff[FN_REFLEN+20], buf[10]; + if (!option_force) + { + puts("Dropping the database is potentially a very bad thing to do."); + puts("Any data stored in the database will be destroyed.\n"); + printf("Do you really want to drop the '%s' database [y/N]\n",db); + VOID(fgets(buf,sizeof(buf)-1,stdin)); + if ((*buf != 'y') && (*buf != 'Y')) + { + puts("\nOK, aborting database drop!"); + return -1; + } + } + sprintf(name_buff,"drop database %.*s",FN_REFLEN,db); + if (mysql_query(mysql,name_buff)) + { + my_printf_error(0,"drop of '%s' failed;\nerror: '%s'",MYF(ME_BELL), + db,mysql_error(mysql)); + return 1; + } + printf("Database \"%s\" dropped\n",db); + return 0; +} + + +static void nice_time(ulong sec,char *buff) +{ + ulong tmp; + + if (sec >= 3600L*24) + { + tmp=sec/(3600L*24); + sec-=3600L*24*tmp; + buff=int2str(tmp,buff,10); + buff=strmov(buff,tmp > 1 ? " days " : " day "); + } + if (sec >= 3600L) + { + tmp=sec/3600L; + sec-=3600L*tmp; + buff=int2str(tmp,buff,10); + buff=strmov(buff,tmp > 1 ? " hours " : " hour "); + } + if (sec >= 60) + { + tmp=sec/60; + sec-=60*tmp; + buff=int2str(tmp,buff,10); + buff=strmov(buff," min "); + } + strmov(int2str(sec,buff,10)," sec"); +} + + +static void print_header(MYSQL_RES *result) +{ + MYSQL_FIELD *field; + + print_top(result); + mysql_field_seek(result,0); + putchar('|'); + while ((field = mysql_fetch_field(result))) + { + printf(" %-*s|",field->max_length+1,field->name); + } + putchar('\n'); + print_top(result); +} + + +static void print_top(MYSQL_RES *result) +{ + uint i,length; + MYSQL_FIELD *field; + + putchar('+'); + mysql_field_seek(result,0); + while((field = mysql_fetch_field(result))) + { + if ((length=strlen(field->name)) > field->max_length) + field->max_length=length; + else + length=field->max_length; + for (i=length+2 ; i--> 0 ; ) + putchar('-'); + putchar('+'); + } + putchar('\n'); +} + + +/* 3.rd argument, uint row, is not in use. Don't remove! */ +static void print_row(MYSQL_RES *result, MYSQL_ROW cur, + uint row __attribute__((unused))) +{ + uint i,length; + MYSQL_FIELD *field; + + putchar('|'); + mysql_field_seek(result,0); + for (i=0 ; i < mysql_num_fields(result); i++) + { + field = mysql_fetch_field(result); + length=field->max_length; + printf(" %-*s|",length+1,cur[i] ? (char*) cur[i] : ""); + } + putchar('\n'); +} + + +static void print_relative_row(MYSQL_RES *result, MYSQL_ROW cur, uint row) +{ + ulonglong tmp; + char buff[22]; + MYSQL_FIELD *field; + + mysql_field_seek(result, 0); + field = mysql_fetch_field(result); + printf("| %-*s|", field->max_length + 1, cur[0]); + + field = mysql_fetch_field(result); + tmp = cur[1] ? strtoull(cur[1], NULL, 0) : (ulonglong) 0; + printf(" %-*s|\n", field->max_length + 1, + llstr((tmp - last_values[row]), buff)); + last_values[row] = tmp; +} + + +static void print_relative_row_vert(MYSQL_RES *result __attribute__((unused)), + MYSQL_ROW cur, + uint row __attribute__((unused))) +{ + uint length; + ulonglong tmp; + char buff[22]; + + if (!row) + putchar('|'); + + tmp = cur[1] ? strtoull(cur[1], NULL, 0) : (ulonglong) 0; + printf(" %-*s|", ex_val_max_len[row] + 1, + llstr((tmp - last_values[row]), buff)); + + /* Find the minimum row length needed to output the relative value */ + if ((length=strlen(buff) > ex_val_max_len[row]) && ex_status_printed) + ex_val_max_len[row] = length; + last_values[row] = tmp; +} + + +static void store_values(MYSQL_RES *result) +{ + uint i; + MYSQL_ROW row; + MYSQL_FIELD *field; + + field = mysql_fetch_field(result); + max_var_length = field->max_length; + field = mysql_fetch_field(result); + max_val_length = field->max_length; + + for (i = 0; (row = mysql_fetch_row(result)); i++) + { + strmov(ex_var_names[i], row[0]); + last_values[i]=strtoull(row[1],NULL,10); + ex_val_max_len[i]=2; /* Default print width for values */ + } + ex_var_count = i; + return; +} + + +static void print_relative_header() +{ + uint i; + + putchar('|'); + for (i = 0; i < ex_var_count; i++) + printf(" %-*s|", ex_val_max_len[i] + 1, truncated_var_names[i]); + putchar('\n'); +} + + +static void print_relative_line() +{ + uint i; + + putchar('+'); + for (i = 0; i < ex_var_count; i++) + { + uint j; + for (j = 0; j < ex_val_max_len[i] + 2; j++) + putchar('-'); + putchar('+'); + } + putchar('\n'); +} + + +static void truncate_names() +{ + uint i; + char *ptr,top_line[MAX_TRUNC_LENGTH+4+NAME_LEN+22+1],buff[22]; + + ptr=top_line; + *ptr++='+'; + ptr=strfill(ptr,max_var_length+2,'-'); + *ptr++='+'; + ptr=strfill(ptr,MAX_TRUNC_LENGTH+2,'-'); + *ptr++='+'; + ptr=strfill(ptr,max_val_length+2,'-'); + *ptr++='+'; + *ptr=0; + puts(top_line); + + for (i = 0 ; i < ex_var_count; i++) + { + uint sfx=1,j; + printf("| %-*s|", max_var_length + 1, ex_var_names[i]); + ptr = ex_var_names[i]; + /* Make sure no two same truncated names will become */ + for (j = 0; j < i; j++) + if (*truncated_var_names[j] == *ptr) + sfx++; + + truncated_var_names[i][0]= *ptr; /* Copy first var char */ + int10_to_str(sfx, truncated_var_names[i]+1,10); + printf(" %-*s|", MAX_TRUNC_LENGTH + 1, truncated_var_names[i]); + printf(" %-*s|\n", max_val_length + 1, llstr(last_values[i],buff)); + } + puts(top_line); + return; +} + + +static my_bool get_pidfile(MYSQL *mysql, char *pidfile) +{ + MYSQL_RES* result; + + if (mysql_query(mysql, "SHOW VARIABLES LIKE 'pid_file'")) + { + my_printf_error(0,"query failed; error: '%s'",MYF(ME_BELL), + mysql_error(mysql)); + } + result = mysql_store_result(mysql); + if (result) + { + strmov(pidfile, mysql_fetch_row(result)[1]); + mysql_free_result(result); + return 0; + } + return 1; /* Error */ +} + + +static void wait_pidfile(char *pidfile) +{ + char buff[FN_REFLEN]; + int fd; + uint count=0; + + system_filename(buff,pidfile); + while ((fd = open(buff, O_RDONLY)) >= 0 && count++ < MAX_TIME_TO_WAIT) + { + close(fd); + sleep(1); + } + if (fd >= 0) + { + close(fd); + fprintf(stderr, + "Warning; Aborted waiting on pid file: '%s' after %d seconds\n", + buff, count-1); + } +} |