~drizzle-trunk/drizzle/development : revision 212

18

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

19

*/

20

21

/* mysql command tool

21

/* drizzle command tool

22

* Commands compatible with mSQL by David J. Hughes

23

*

24

* Written by:

39

#include <stdarg.h>

40

#include <my_dir.h>

41

#ifndef __GNU_LIBRARY__

42

#define __GNU_LIBRARY__ // Skip warnings in getopt.h

42

#define __GNU_LIBRARY__ // Skip warnings in getopt.h

43

#endif

44

#include <readline/history.h>

45

#include "my_readline.h"

53

const char *VER= "14.14";

54

55

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

56

#define MAX_COLUMN_LENGTH 1024

56

#define MAX_COLUMN_LENGTH 1024

57

58

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

59

#define MAX_SERVER_VERSION_LENGTH 128

60

61

/* Array of options to pass to libemysqld */

61

/* Array of options to pass to libdrizzled */

62

#define MAX_SERVER_ARGS 64

63

64

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

64

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

65

void sql_element_free(void *ptr);

66

67

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

74

#elif defined(HAVE_TERMBITS_H)

75

#include <termbits.h>

76

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

77

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

77

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

78

#endif

79

#undef VOID

80

#if defined(HAVE_TERMCAP_H)

83

#ifdef HAVE_CURSES_H

84

#include <curses.h>

85

#endif

86

#undef SYSV // hack to avoid syntax error

86

#undef SYSV // hack to avoid syntax error

87

#ifdef HAVE_TERM_H

88

#include <term.h>

89

#endif

90

#endif

91

#endif

92

93

#undef bcmp // Fix problem with new readline

93

#undef bcmp // Fix problem with new readline

94

95

#include <readline/readline.h>

96

107

108

#if !defined(HAVE_VIDATTR)

109

#undef vidattr

110

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

110

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

111

#endif

112

113

#ifdef FN_NO_CASE_SENCE

137

enum enum_info_type { INFO_INFO,INFO_ERROR,INFO_RESULT};

138

typedef enum enum_info_type INFO_TYPE;

139

140

static MYSQL mysql; /* The connection */

141

static bool ignore_errors=0,wait_flag=0,quick=0,

140

static DRIZZLE drizzle; /* The connection */

141

static bool ignore_errors=0,quick=0,

142

connected=0,opt_raw_data=0,unbuffered=0,output_tables=0,

143

opt_rehash=1,skip_updates=0,safe_updates=0,one_database=0,

144

opt_compress=0, using_opt_local_infile=0,

153

static bool column_types_flag;

154

static bool preserve_comments= 0;

155

static ulong opt_max_allowed_packet, opt_net_buffer_length;

156

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

156

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

157

static uint my_end_arg;

158

static char * opt_mysql_unix_port=0;

158

static char * opt_drizzle_unix_port=0;

159

static int connect_flag=CLIENT_INTERACTIVE;

160

static char *current_host,*current_db,*current_user=0,*opt_password=0,

161

*delimiter_str= 0,*current_prompt=0,

166

static DYNAMIC_STRING *processed_prompt= NULL;

167

static char *default_prompt= NULL;

168

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

169

static int wait_time = 5;

170

169

static STATUS status;

171

170

static uint32_t select_limit;

172

171

static uint32_t max_join_size;

173

172

static ulong opt_connect_timeout= 0;

174

static char mysql_charsets_dir[FN_REFLEN+1];

173

static char drizzle_charsets_dir[FN_REFLEN+1];

175

174

static const char *xmlmeta[] = {

176

175

"&", "&",

177

176

"<", "<",

191

190

static uint delimiter_length= 1;

192

191

unsigned short terminal_width= 80;

193

192

194

static uint opt_protocol= MYSQL_PROTOCOL_TCP;

193

static uint opt_protocol= DRIZZLE_PROTOCOL_TCP;

195

194

static CHARSET_INFO *charset_info= &my_charset_latin1;

196

195

197

const char *default_dbug_option="d:t:o,/tmp/mysql.trace";

198

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

199

int mysql_store_result_for_lazy(MYSQL_RES **result);

196

const char *default_dbug_option="d:t:o,/tmp/drizzle.trace";

197

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

198

int drizzle_store_result_for_lazy(DRIZZLE_RES **result);

200

199

201

200

202

201

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

223

222

static int read_and_execute(bool interactive);

224

223

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

225

224

uint silent);

226

static const char *server_version_string(MYSQL *mysql);

225

static const char *server_version_string(DRIZZLE *drizzle);

227

226

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

228

227

const char *sql_state);

229

static int put_error(MYSQL *mysql);

228

static int put_error(DRIZZLE *drizzle);

230

229

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

231

230

static void xmlencode_print(const char *src, uint length);

232

231

static void init_pager(void);

237

236

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

238

237

static void init_username(void);

239

238

static void add_int_to_prompt(int toadd);

240

static int get_result_width(MYSQL_RES *res);

241

static int get_field_disp_length(MYSQL_FIELD * field);

239

static int get_result_width(DRIZZLE_RES *res);

240

static int get_field_disp_length(DRIZZLE_FIELD * field);

242

241

243

242

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

244

243

can understand. */

245

244

typedef struct {

246

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

247

char cmd_char; /* msql command character */

245

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

246

char cmd_char; /* msql command character */

248

247

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

249

bool takes_params; /* Max parameters for command */

250

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

248

bool takes_params; /* Max parameters for command */

249

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

251

250

} COMMANDS;

252

251

253

252

259

258

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

260

259

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

261

260

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

262

"Send command to mysql server, display result vertically."},

263

{ "exit", 'q', com_quit, 0, "Exit mysql. Same as quit."},

264

{ "go", 'g', com_go, 0, "Send command to mysql server." },

261

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

262

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

263

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

265

264

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

266

265

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

267

266

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

268

267

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

269

268

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

270

269

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

271

{ "prompt", 'R', com_prompt, 1, "Change your mysql prompt."},

272

{ "quit", 'q', com_quit, 0, "Quit mysql." },

270

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

271

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

273

272

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

274

273

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

275

274

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

994

993

{ (char *)NULL, 0, 0, 0, ""}

995

994

};

996

995

997

static const char *load_default_groups[]= { "mysql","client",0 };

996

static const char *load_default_groups[]= { "drizzle","client",0 };

998

997

999

998

static int embedded_server_arg_count= 0;

1000

999

static char *embedded_server_args[MAX_SERVER_ARGS];

1001

static const char *embedded_server_groups[]=

1002

{ "server", "mysql_SERVER", 0 };

1003

1000

1004

1001

int history_length;

1005

1002

static int not_in_history(const char *line);

1010

1007

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

1011

1008

bool *ml_comment);

1012

1009

static void remove_cntrl(DYNAMIC_STRING *buffer);

1013

static void print_table_data(MYSQL_RES *result);

1014

static void print_table_data_html(MYSQL_RES *result);

1015

static void print_table_data_xml(MYSQL_RES *result);

1016

static void print_tab_data(MYSQL_RES *result);

1017

static void print_table_data_vertically(MYSQL_RES *result);

1010

static void print_table_data(DRIZZLE_RES *result);

1011

static void print_table_data_html(DRIZZLE_RES *result);

1012

static void print_table_data_xml(DRIZZLE_RES *result);

1013

static void print_tab_data(DRIZZLE_RES *result);

1014

static void print_table_data_vertically(DRIZZLE_RES *result);

1018

1015

static void print_warnings(void);

1019

1016

static ulong start_timer(void);

1020

1017

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

1021

static void mysql_end_timer(ulong start_time,char *buff);

1018

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

1022

1019

static void nice_time(double sec,char *buff,bool part_second);

1023

extern sig_handler mysql_end(int sig);

1020

extern sig_handler drizzle_end(int sig);

1024

1021

extern sig_handler handle_sigint(int sig);

1025

1022

#if defined(HAVE_TERMIOS_H) && defined(GWINSZ_IN_SYS_IOCTL)

1026

1023

static sig_handler window_resize(int sig);

1042

1039

1043

1040

prompt_counter=0;

1044

1041

1045

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

1046

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

1042

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

1043

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

1047

1044

{

1048

1045

char *tmp=getenv("PAGER");

1049

1046

if (tmp && strlen(tmp))

1090

1087

my_end(0);

1091

1088

exit(1);

1092

1089

}

1093

if (mysql_server_init(embedded_server_arg_count, embedded_server_args,

1094

(char**) embedded_server_groups))

1095

{

1096

put_error(NULL);

1097

free_defaults(defaults_argv);

1098

my_end(0);

1099

exit(1);

1100

}

1101

1090

completion_hash_init(&ht, 128);

1102

1091

init_alloc_root(&hash_mem_root, 16384, 0);

1103

bzero((char*) &mysql, sizeof(mysql));

1092

bzero((char*) &drizzle, sizeof(drizzle));

1104

1093

if (sql_connect(current_host,current_db,current_user,opt_password,

1105

1094

opt_silent))

1106

1095

{

1107

quick= 1; // Avoid history

1096

quick= 1; // Avoid history

1108

1097

status.exit_status= 1;

1109

mysql_end(-1);

1098

drizzle_end(-1);

1110

1099

}

1111

1100

if (!status.batch)

1112

ignore_errors=1; // Don't abort monitor

1101

ignore_errors=1; // Don't abort monitor

1113

1102

1114

1103

if (opt_sigint_ignore)

1115

1104

signal(SIGINT, SIG_IGN);

1116

1105

else

1117

1106

signal(SIGINT, handle_sigint); // Catch SIGINT to clean up

1118

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

1107

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

1119

1108

1120

1109

#if defined(HAVE_TERMIOS_H) && defined(GWINSZ_IN_SYS_IOCTL)

1121

1110

/* Readline will call this if it installs a handler */

1133

1122

/* this is a slight abuse of the DYNAMIC_STRING interface. deal. */

1134

1123

sprintf(glob_buffer->str,

1135

1124

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

1136

mysql_thread_id(&mysql), server_version_string(&mysql));

1125

drizzle_thread_id(&drizzle), server_version_string(&drizzle));

1137

1126

put_info(glob_buffer->str, INFO_INFO, 0, 0);

1138

1127

dynstr_set(glob_buffer, NULL);

1139

1128

1140

1129

initialize_readline(my_progname);

1141

1130

if (!status.batch && !quick && !opt_html && !opt_xml)

1142

1131

{

1143

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

1132

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

1144

1133

if (getenv("MYSQL_HISTFILE"))

1145

1134

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

1146

1135

else if (getenv("HOME"))

1147

1136

{

1148

1137

histfile=(char*) my_malloc((uint) strlen(getenv("HOME"))

1149

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

1138

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

1150

1139

MYF(MY_WME));

1151

1140

if (histfile)

1152

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

1141

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

1153

1142

char link_name[FN_REFLEN];

1154

1143

if (my_readlink(link_name, histfile, 0) == 0 &&

1155

1144

strncmp(link_name, "/dev/null", 10) == 0)

1156

1145

{

1157

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

1146

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

1158

1147

my_free(histfile, MYF(MY_ALLOW_ZERO_PTR));

1159

1148

histfile= 0;

1160

1149

}

1180

1169

status.exit_status= read_and_execute(!status.batch);

1181

1170

if (opt_outfile)

1182

1171

end_tee();

1183

mysql_end(0);

1172

drizzle_end(0);

1184

1173

#ifndef _lint

1185

return(0); // Keep compiler happy

1174

return(0); // Keep compiler happy

1186

1175

#endif

1187

1176

}

1188

1177

1189

sig_handler mysql_end(int sig)

1178

sig_handler drizzle_end(int sig)

1190

1179

{

1191

mysql_close(&mysql);

1180

drizzle_close(&drizzle);

1192

1181

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

1193

1182

{

1194

1183

/* write-history */

1210

1199

dynstr_free(processed_prompt);

1211

1200

my_free(processed_prompt,MYF(MY_ALLOW_ZERO_PTR));

1212

1201

my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));

1213

my_free(opt_mysql_unix_port,MYF(MY_ALLOW_ZERO_PTR));

1202

my_free(opt_drizzle_unix_port,MYF(MY_ALLOW_ZERO_PTR));

1214

1203

my_free(histfile,MYF(MY_ALLOW_ZERO_PTR));

1215

1204

my_free(histfile_tmp,MYF(MY_ALLOW_ZERO_PTR));

1216

1205

my_free(current_db,MYF(MY_ALLOW_ZERO_PTR));

1222

1211

my_free(current_prompt,MYF(MY_ALLOW_ZERO_PTR));

1223

1212

while (embedded_server_arg_count > 1)

1224

1213

my_free(embedded_server_args[--embedded_server_arg_count],MYF(0));

1225

mysql_server_end();

1214

drizzle_server_end();

1226

1215

free_defaults(defaults_argv);

1227

1216

my_end(my_end_arg);

1228

1217

exit(status.exit_status);

1237

1226

sig_handler handle_sigint(int sig)

1238

1227

{

1239

1228

char kill_buffer[40];

1240

MYSQL *kill_mysql= NULL;

1229

DRIZZLE *kill_drizzle= NULL;

1241

1230

1242

1231

/* terminate if no query being executed, or we already tried interrupting */

1243

1232

if (!executing_query || interrupted_query) {

1244

1233

goto err;

1245

1234

}

1246

1235

1247

kill_mysql= mysql_init(kill_mysql);

1248

if (!mysql_real_connect(kill_mysql,current_host, current_user, opt_password,

1249

"", opt_mysql_port, opt_mysql_unix_port,0))

1236

kill_drizzle= drizzle_create(kill_drizzle);

1237

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

1238

"", opt_drizzle_port, opt_drizzle_unix_port,0))

1250

1239

{

1251

1240

goto err;

1252

1241

}

1253

1242

1254

1243

/* kill_buffer is always big enough because max length of %lu is 15 */

1255

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

1256

mysql_real_query(kill_mysql, kill_buffer, strlen(kill_buffer));

1257

mysql_close(kill_mysql);

1244

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

1245

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

1246

drizzle_close(kill_drizzle);

1258

1247

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

1259

1248

1260

1249

interrupted_query= 1;

1262

1251

return;

1263

1252

1264

1253

err:

1265

mysql_end(sig);

1254

drizzle_end(sig);

1266

1255

}

1267

1256

1268

1257

1287

1276

(char**) &opt_rehash, (char**) &opt_rehash, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0,

1288

1277

0, 0},

1289

1278

{"no-auto-rehash", 'A',

1290

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

1279

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

1291

1280

0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

1292

1281

{"auto-vertical-output", OPT_AUTO_VERTICAL_OUTPUT,

1293

1282

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

1328

1317

(char**) &ignore_errors, (char**) &ignore_errors, 0, GET_BOOL, NO_ARG, 0, 0,

1329

1318

0, 0, 0, 0},

1330

1319

{"named-commands", 'G',

1331

"Enable named commands. Named commands mean this program's internal commands; see mysql> 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.",

1320

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

1332

1321

(char**) &named_cmds, (char**) &named_cmds, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

1333

1322

0, 0},

1334

1323

{"no-named-commands", 'g',

1384

1373

"/etc/services, "

1385

1374

#endif

1386

1375

"built-in default (" STRINGIFY_ARG(MYSQL_PORT) ").",

1387

(char**) &opt_mysql_port,

1388

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

1389

{"prompt", OPT_PROMPT, "Set the mysql prompt to this value.",

1376

(char**) &opt_drizzle_port,

1377

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

1378

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

1390

1379

(char**) &current_prompt, (char**) &current_prompt, 0, GET_STR_ALLOC,

1391

1380

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

1392

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

1381

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

1393

1382

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

1394

1383

{"quick", 'q',

1395

1384

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

1402

1391

{"silent", 's', "Be more silent. Print results with a tab as separator, each row on new line.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0,

1403

1392

0, 0},

1404

1393

{"socket", 'S', "Socket file to use for connection.",

1405

(char**) &opt_mysql_unix_port, (char**) &opt_mysql_unix_port, 0, GET_STR_ALLOC,

1394

(char**) &opt_drizzle_unix_port, (char**) &opt_drizzle_unix_port, 0, GET_STR_ALLOC,

1406

1395

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

1407

1396

{"table", 't', "Output in table format.", (char**) &output_tables,

1408

1397

(char**) &output_tables, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1474

1463

if (version)

1475

1464

return;

1476

1465

printf("\

1477

1466

1478

1467

This software comes with ABSOLUTELY NO WARRANTY. This is free software,\n \

1479

1468

and you are welcome to modify and redistribute it under the GPL license\n");

1480

1469

printf("Usage: %s [OPTIONS] [database]\n", my_progname);

1490

1479

{

1491

1480

switch(optid) {

1492

1481

case OPT_CHARSETS_DIR:

1493

strmake(mysql_charsets_dir, argument, sizeof(mysql_charsets_dir) - 1);

1494

charsets_dir = mysql_charsets_dir;

1482

strmake(drizzle_charsets_dir, argument, sizeof(drizzle_charsets_dir) - 1);

1483

charsets_dir = drizzle_charsets_dir;

1495

1484

break;

1496

1485

case OPT_DEFAULT_CHARSET:

1497

1486

default_charset_used= 1;

1557

1546

printf("WARNING: option deprecated; use --disable-pager instead.\n");

1558

1547

opt_nopager= 1;

1559

1548

break;

1560

case OPT_MYSQL_PROTOCOL:

1549

case OPT_DRIZZLE_PROTOCOL:

1561

1550

opt_protocol= find_type_or_exit(argument, &sql_protocol_typelib,

1562

1551

opt->name);

1563

1552

break;

1586

1575

break;

1587

1576

case 'p':

1588

1577

if (argument == disabled_my_option)

1589

argument= (char*) ""; // Don't require password

1578

argument= (char*) ""; // Don't require password

1590

1579

if (argument)

1591

1580

{

1592

1581

char *start= argument;

1593

1582

my_free(opt_password, MYF(MY_ALLOW_ZERO_PTR));

1594

1583

opt_password= strdup(argument);

1595

while (*argument) *argument++= 'x'; // Destroy argument

1584

while (*argument) *argument++= 'x'; // Destroy argument

1596

1585

if (*start)

1597

1586

start[1]=0 ;

1598

1587

tty_password= 0;

1634

1623

{

1635

1624

char *tmp, *pagpoint;

1636

1625

int ho_error;

1637

MYSQL_PARAMETERS *mysql_params= mysql_get_parameters();

1626

DRIZZLE_PARAMETERS *drizzle_params= drizzle_get_parameters();

1638

1627

1639

1628

tmp= (char *) getenv("MYSQL_HOST");

1640

1629

if (tmp)

1650

1639

strmov(pager, pagpoint);

1651

1640

strmov(default_pager, pager);

1652

1641

1653

opt_max_allowed_packet= *mysql_params->p_max_allowed_packet;

1654

opt_net_buffer_length= *mysql_params->p_net_buffer_length;

1642

opt_max_allowed_packet= *drizzle_params->p_max_allowed_packet;

1643

opt_net_buffer_length= *drizzle_params->p_net_buffer_length;

1655

1644

1656

1645

if ((ho_error=handle_options(&argc, &argv, my_long_options, get_one_option)))

1657

1646

exit(ho_error);

1658

1647

1659

*mysql_params->p_max_allowed_packet= opt_max_allowed_packet;

1660

*mysql_params->p_net_buffer_length= opt_net_buffer_length;

1648

*drizzle_params->p_max_allowed_packet= opt_max_allowed_packet;

1649

*drizzle_params->p_net_buffer_length= opt_net_buffer_length;

1661

1650

1662

1651

if (status.batch) /* disable pager and outfile in this case */

1663

1652

{

1753

1742

}

1754

1743

1755

1744

/*

1756

Check if line is a mysql command line

1745

Check if line is a drizzle command line

1757

1746

(We want to allow help, print and clear anywhere at line start

1758

1747

*/

1759

1748

if ((named_cmds || (glob_buffer->length==0))

1820

1809

while (my_isspace(charset_info,*end))

1821

1810

end++;

1822

1811

if (!*end)

1823

end=0; // no arguments to function

1812

end=0; // no arguments to function

1824

1813

}

1825

1814

else

1826

1815

len=(uint) strlen(name);

1882

1871

}

1883

1872

#endif

1884

1873

if (!*ml_comment && inchar == '\\' &&

1885

!(mysql.server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES))

1874

!(drizzle.server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES))

1886

1875

{

1887

1876

// Found possbile one character command like \c

1888

1877

1889

1878

if (!(inchar = (uchar) *++pos))

1890

break; // readline adds one '\'

1891

if (*in_string || inchar == 'N') // \N is short for NULL

1892

{ // Don't allow commands in string

1879

break; // readline adds one '\'

1880

if (*in_string || inchar == 'N') // \N is short for NULL

1881

{ // Don't allow commands in string

1893

1882

*out++='\\';

1894

1883

*out++= (char) inchar;

1895

1884

continue;

1923

1912

for (pos++ ;

1924

1913

*pos && (*pos != *delimiter ||

1925

1914

!is_prefix(pos + 1, delimiter + 1)) ; pos++)

1926

; // Remove parameters

1915

; // Remove parameters

1927

1916

if (!*pos)

1928

1917

pos--;

1929

1918

else

2112

2101

static char **mysql_completion (const char *text, int start, int end);

2113

2102

static char *new_command_generator(const char *text, int);

2114

2103

2115

2116

2104

/*

2117

2105

Tell the GNU Readline library how to complete. We want to try to complete

2118

2106

on command names if this is the first word in the line, or on filenames

2239

2227

textlen=(uint) strlen(text);

2240

2228

2241

2229

if (textlen>0)

2242

{ /* lookup in the hash */

2230

{ /* lookup in the hash */

2243

2231

if (!state)

2244

2232

{

2245

2233

uint len;

2275

2263

}

2276

2264

ptr= NullS;

2277

2265

while (e && !ptr)

2278

{ /* find valid entry in bucket */

2266

{ /* find valid entry in bucket */

2279

2267

if ((uint) strlen(e->str) == b->nKeyLength)

2280

2268

ptr = strdup(e->str);

2281

2269

/* find the next used entry */

2311

2299

static void build_completion_hash(bool rehash, bool write_info)

2312

2300

{

2313

2301

COMMANDS *cmd=commands;

2314

MYSQL_RES *databases=0,*tables=0;

2315

MYSQL_RES *fields;

2302

DRIZZLE_RES *databases=0,*tables=0;

2303

DRIZZLE_RES *fields;

2316

2304

static char ***field_names= 0;

2317

MYSQL_ROW database_row,table_row;

2318

MYSQL_FIELD *sql_field;

2319

char buf[NAME_LEN*2+2]; // table name plus field name plus 2

2305

DRIZZLE_ROW database_row,table_row;

2306

DRIZZLE_FIELD *sql_field;

2307

char buf[NAME_LEN*2+2]; // table name plus field name plus 2

2320

2308

int i,j,num_fields;

2321

2309

2322

2310

2323

2311

if (status.batch || quick || !current_db)

2324

return; // We don't need completion in batches

2312

return; // We don't need completion in batches

2325

2313

if (!rehash)

2326

2314

return;

2327

2315

2340

2328

/* hash Drizzle functions (to be implemented) */

2341

2329

2342

2330

/* hash all database names */

2343

if (mysql_query(&mysql,"show databases") == 0)

2331

if (drizzle_query(&drizzle,"show databases") == 0)

2344

2332

{

2345

if (!(databases = mysql_store_result(&mysql)))

2346

put_info(mysql_error(&mysql),INFO_INFO,0,0);

2333

if (!(databases = drizzle_store_result(&drizzle)))

2334

put_info(drizzle_error(&drizzle),INFO_INFO,0,0);

2347

2335

else

2348

2336

{

2349

while ((database_row=mysql_fetch_row(databases)))

2337

while ((database_row=drizzle_fetch_row(databases)))

2350

2338

{

2351

2339

char *str=strdup_root(&hash_mem_root, (char*) database_row[0]);

2352

2340

if (str)

2353

2341

add_word(&ht,(char*) str);

2354

2342

}

2355

mysql_free_result(databases);

2343

drizzle_free_result(databases);

2356

2344

}

2357

2345

}

2358

2346

/* hash all table names */

2359

if (mysql_query(&mysql,"show tables")==0)

2347

if (drizzle_query(&drizzle,"show tables")==0)

2360

2348

{

2361

if (!(tables = mysql_store_result(&mysql)))

2362

put_info(mysql_error(&mysql),INFO_INFO,0,0);

2349

if (!(tables = drizzle_store_result(&drizzle)))

2350

put_info(drizzle_error(&drizzle),INFO_INFO,0,0);

2363

2351

else

2364

2352

{

2365

if (mysql_num_rows(tables) > 0 && !opt_silent && write_info)

2353

if (drizzle_num_rows(tables) > 0 && !opt_silent && write_info)

2366

2354

{

2367

2355

tee_fprintf(stdout, "\

2368

2356

Reading table information for completion of table and column names\n \

2369

2357

You can turn off this feature to get a quicker startup with -A\n\n");

2370

2358

}

2371

while ((table_row=mysql_fetch_row(tables)))

2359

while ((table_row=drizzle_fetch_row(tables)))

2372

2360

{

2373

2361

char *str=strdup_root(&hash_mem_root, (char*) table_row[0]);

2374

2362

if (str &&

2379

2367

}

2380

2368

2381

2369

/* hash all field names, both with the table prefix and without it */

2382

if (!tables) /* no tables */

2370

if (!tables) /* no tables */

2383

2371

{

2384

2372

return;

2385

2373

}

2386

mysql_data_seek(tables,0);

2374

drizzle_data_seek(tables,0);

2387

2375

if (!(field_names= (char ***) alloc_root(&hash_mem_root,sizeof(char **) *

2388

(uint) (mysql_num_rows(tables)+1))))

2376

(uint) (drizzle_num_rows(tables)+1))))

2389

2377

{

2390

mysql_free_result(tables);

2378

drizzle_free_result(tables);

2391

2379

return;

2392

2380

}

2393

2381

i=0;

2394

while ((table_row=mysql_fetch_row(tables)))

2382

while ((table_row=drizzle_fetch_row(tables)))

2395

2383

{

2396

if ((fields=mysql_list_fields(&mysql,(const char*) table_row[0],NullS)))

2384

if ((fields=drizzle_list_fields(&drizzle,(const char*) table_row[0],NullS)))

2397

2385

{

2398

num_fields=mysql_num_fields(fields);

2386

num_fields=drizzle_num_fields(fields);

2399

2387

if (!(field_names[i] = (char **) alloc_root(&hash_mem_root,

2400

2388

sizeof(char *) *

2401

2389

(num_fields*2+1))))

2402

2390

{

2403

mysql_free_result(fields);

2391

drizzle_free_result(fields);

2404

2392

break;

2405

2393

}

2406

2394

field_names[i][num_fields*2]= '\0';

2407

2395

j=0;

2408

while ((sql_field=mysql_fetch_field(fields)))

2396

while ((sql_field=drizzle_fetch_field(fields)))

2409

2397

{

2410

2398

sprintf(buf,"%.64s.%.64s",table_row[0],sql_field->name);

2411

2399

field_names[i][j] = strdup_root(&hash_mem_root,buf);

2417

2405

add_word(&ht,field_names[i][num_fields+j]);

2418

2406

j++;

2419

2407

}

2420

mysql_free_result(fields);

2408

drizzle_free_result(fields);

2421

2409

}

2422

2410

else

2423

2411

field_names[i]= 0;

2424

2412

2425

2413

i++;

2426

2414

}

2427

mysql_free_result(tables);

2428

field_names[i]=0; // End pointer

2415

drizzle_free_result(tables);

2416

field_names[i]=0; // End pointer

2429

2417

return;

2430

2418

}

2431

2419

2474

2462

2475

2463

static void get_current_db(void)

2476

2464

{

2477

MYSQL_RES *res;

2465

DRIZZLE_RES *res;

2478

2466

2479

2467

my_free(current_db, MYF(MY_ALLOW_ZERO_PTR));

2480

2468

current_db= NULL;

2481

2469

/* In case of error below current_db will be NULL */

2482

if (!mysql_query(&mysql, "SELECT DATABASE()") &&

2483

(res= mysql_use_result(&mysql)))

2470

if (!drizzle_query(&drizzle, "SELECT DATABASE()") &&

2471

(res= drizzle_use_result(&drizzle)))

2484

2472

{

2485

MYSQL_ROW row= mysql_fetch_row(res);

2473

DRIZZLE_ROW row= drizzle_fetch_row(res);

2486

2474

if (row[0])

2487

2475

current_db= strdup(row[0]);

2488

mysql_free_result(res);

2476

drizzle_free_result(res);

2489

2477

}

2490

2478

}

2491

2479

2493

2481

The different commands

2494

2482

***************************************************************************/

2495

2483

2496

int mysql_real_query_for_lazy(const char *buf, int length)

2484

int drizzle_real_query_for_lazy(const char *buf, int length)

2497

2485

{

2498

2486

for (uint retry=0;; retry++)

2499

2487

{

2500

2488

int error;

2501

if (!mysql_real_query(&mysql,buf,length))

2489

if (!drizzle_real_query(&drizzle,buf,length))

2502

2490

return 0;

2503

error= put_error(&mysql);

2504

if (mysql_errno(&mysql) != CR_SERVER_GONE_ERROR || retry > 1 ||

2491

error= put_error(&drizzle);

2492

if (drizzle_errno(&drizzle) != CR_SERVER_GONE_ERROR || retry > 1 ||

2505

2493

!opt_reconnect)

2506

2494

return error;

2507

2495

if (reconnect())

2509

2497

}

2510

2498

}

2511

2499

2512

int mysql_store_result_for_lazy(MYSQL_RES **result)

2500

int drizzle_store_result_for_lazy(DRIZZLE_RES **result)

2513

2501

{

2514

if ((*result=mysql_store_result(&mysql)))

2502

if ((*result=drizzle_store_result(&drizzle)))

2515

2503

return 0;

2516

2504

2517

if (mysql_error(&mysql)[0])

2518

return put_error(&mysql);

2505

if (drizzle_error(&drizzle)[0])

2506

return put_error(&drizzle);

2519

2507

return 0;

2520

2508

}

2521

2509

2522

static void print_help_item(MYSQL_ROW *cur, int num_name, int num_cat, char *last_char)

2510

static void print_help_item(DRIZZLE_ROW *cur, int num_name, int num_cat, char *last_char)

2523

2511

{

2524

2512

char ccat= (*cur)[num_cat][0];

2525

2513

if (*last_char != ccat)

2535

2523

char *line __attribute__((unused)),

2536

2524

char *help_arg)

2537

2525

{

2538

MYSQL_ROW cur;

2526

DRIZZLE_ROW cur;

2539

2527

const char *server_cmd= buffer->str;

2540

2528

char cmd_buf[100];

2541

MYSQL_RES *result;

2529

DRIZZLE_RES *result;

2542

2530

int error;

2543

2531

2544

2532

if (help_arg[0] != '\'')

2557

2545

if (!connected && reconnect())

2558

2546

return 1;

2559

2547

2560

if ((error= mysql_real_query_for_lazy(server_cmd,(int)strlen(server_cmd))) ||

2561

(error= mysql_store_result_for_lazy(&result)))

2548

if ((error= drizzle_real_query_for_lazy(server_cmd,(int)strlen(server_cmd))) ||

2549

(error= drizzle_store_result_for_lazy(&result)))

2562

2550

return error;

2563

2551

2564

2552

if (result)

2565

2553

{

2566

unsigned int num_fields= mysql_num_fields(result);

2567

uint64_t num_rows= mysql_num_rows(result);

2568

mysql_fetch_fields(result);

2554

unsigned int num_fields= drizzle_num_fields(result);

2555

uint64_t num_rows= drizzle_num_rows(result);

2556

drizzle_fetch_fields(result);

2569

2557

if (num_fields==3 && num_rows==1)

2570

2558

{

2571

if (!(cur= mysql_fetch_row(result)))

2559

if (!(cur= drizzle_fetch_row(result)))

2572

2560

{

2573

2561

error= -1;

2574

2562

goto err;

2596

2584

num_name= 0;

2597

2585

num_cat= 1;

2598

2586

}

2599

else if ((cur= mysql_fetch_row(result)))

2587

else if ((cur= drizzle_fetch_row(result)))

2600

2588

{

2601

2589

tee_fprintf(PAGER, "You asked for help about help category: \"%s\"\n", cur[0]);

2602

2590

put_info("For more information, type 'help <item>', where <item> is one of the following", INFO_INFO,0,0);

2605

2593

print_help_item(&cur,1,2,&last_char);

2606

2594

}

2607

2595

2608

while ((cur= mysql_fetch_row(result)))

2596

while ((cur= drizzle_fetch_row(result)))

2609

2597

print_help_item(&cur,num_name,num_cat,&last_char);

2610

2598

tee_fprintf(PAGER, "\n");

2611

2599

end_pager();

2618

2606

}

2619

2607

2620

2608

err:

2621

mysql_free_result(result);

2609

drizzle_free_result(result);

2622

2610

return error;

2623

2611

}

2624

2612

2648

2636

tee_fprintf(stdout, "%s(\\%c) %s\n", buff,

2649

2637

commands[i].cmd_char, commands[i].doc);

2650

2638

}

2651

if (connected && mysql_get_server_version(&mysql) >= 40100)

2639

if (connected && drizzle_get_server_version(&drizzle) >= 40100)

2652

2640

put_info("\nFor server side help, type 'help contents'\n", INFO_INFO,0,0);

2653

2641

return 0;

2654

2642

}

2679

2667

if (new_cs)

2680

2668

{

2681

2669

charset_info= new_cs;

2682

mysql_set_character_set(&mysql, charset_info->csname);

2670

drizzle_set_character_set(&drizzle, charset_info->csname);

2683

2671

default_charset= (char *)charset_info->csname;

2684

2672

default_charset_used= 1;

2685

2673

put_info("Charset changed", INFO_INFO,0,0);

2700

2688

{

2701

2689

char buff[200]; /* about 110 chars used so far */

2702

2690

char time_buff[52+3+1]; /* time max + space&parens + NUL */

2703

MYSQL_RES *result;

2691

DRIZZLE_RES *result;

2704

2692

ulong timer, warnings= 0;

2705

2693

uint error= 0;

2706

2694

int err= 0;

2736

2724

2737

2725

timer=start_timer();

2738

2726

executing_query= 1;

2739

error= mysql_real_query_for_lazy(buffer->str,buffer->length);

2727

error= drizzle_real_query_for_lazy(buffer->str,buffer->length);

2740

2728

2741

2729

if (status.add_to_history)

2742

2730

{

2756

2744

2757

2745

if (quick)

2758

2746

{

2759

if (!(result=mysql_use_result(&mysql)) && mysql_field_count(&mysql))

2747

if (!(result=drizzle_use_result(&drizzle)) && drizzle_field_count(&drizzle))

2760

2748

{

2761

error= put_error(&mysql);

2749

error= put_error(&drizzle);

2762

2750

goto end;

2763

2751

}

2764

2752

}

2765

2753

else

2766

2754

{

2767

error= mysql_store_result_for_lazy(&result);

2755

error= drizzle_store_result_for_lazy(&result);

2768

2756

if (error)

2769

2757

goto end;

2770

2758

}

2771

2759

2772

2760

if (verbose >= 3 || !opt_silent)

2773

mysql_end_timer(timer,time_buff);

2761

drizzle_end_timer(timer,time_buff);

2774

2762

else

2775

2763

time_buff[0]= '\0';

2776

2764

2777

2765

/* Every branch must truncate buff . */

2778

2766

if (result)

2779

2767

{

2780

if (!mysql_num_rows(result) && ! quick && !column_types_flag)

2768

if (!drizzle_num_rows(result) && ! quick && !column_types_flag)

2781

2769

{

2782

2770

strmov(buff, "Empty set");

2783

2771

if (opt_xml)

2806

2794

else

2807

2795

print_table_data(result);

2808

2796

sprintf(buff,"%ld %s in set",

2809

(long) mysql_num_rows(result),

2810

(long) mysql_num_rows(result) == 1 ? "row" : "rows");

2797

(long) drizzle_num_rows(result),

2798

(long) drizzle_num_rows(result) == 1 ? "row" : "rows");

2811

2799

end_pager();

2812

if (mysql_errno(&mysql))

2813

error= put_error(&mysql);

2800

if (drizzle_errno(&drizzle))

2801

error= put_error(&drizzle);

2814

2802

}

2815

2803

}

2816

else if (mysql_affected_rows(&mysql) == ~(uint64_t) 0)

2804

else if (drizzle_affected_rows(&drizzle) == ~(uint64_t) 0)

2817

2805

strmov(buff,"Query OK");

2818

2806

else

2819

2807

sprintf(buff,"Query OK, %ld %s affected",

2820

(long) mysql_affected_rows(&mysql),

2821

(long) mysql_affected_rows(&mysql) == 1 ? "row" : "rows");

2808

(long) drizzle_affected_rows(&drizzle),

2809

(long) drizzle_affected_rows(&drizzle) == 1 ? "row" : "rows");

2822

2810

2823

2811

pos=strend(buff);

2824

if ((warnings= mysql_warning_count(&mysql)))

2812

if ((warnings= drizzle_warning_count(&drizzle)))

2825

2813

{

2826

2814

*pos++= ',';

2827

2815

*pos++= ' ';

2832

2820

}

2833

2821

strmov(pos, time_buff);

2834

2822

put_info(buff,INFO_RESULT,0,0);

2835

if (mysql_info(&mysql))

2836

put_info(mysql_info(&mysql),INFO_RESULT,0,0);

2837

put_info("",INFO_RESULT,0,0); // Empty row

2823

if (drizzle_info(&drizzle))

2824

put_info(drizzle_info(&drizzle),INFO_RESULT,0,0);

2825

put_info("",INFO_RESULT,0,0); // Empty row

2838

2826

2839

if (result && !mysql_eof(result)) /* Something wrong when using quick */

2840

error= put_error(&mysql);

2827

if (result && !drizzle_eof(result)) /* Something wrong when using quick */

2828

error= put_error(&drizzle);

2841

2829

else if (unbuffered)

2842

2830

fflush(stdout);

2843

mysql_free_result(result);

2844

} while (!(err= mysql_next_result(&mysql)));

2831

drizzle_free_result(result);

2832

} while (!(err= drizzle_next_result(&drizzle)));

2845

2833

if (err >= 1)

2846

error= put_error(&mysql);

2834

error= put_error(&drizzle);

2847

2835

2848

2836

end:

2849

2837

2852

2840

print_warnings();

2853

2841

2854

2842

if (!error && !status.batch &&

2855

(mysql.server_status & SERVER_STATUS_DB_DROPPED))

2843

(drizzle.server_status & SERVER_STATUS_DB_DROPPED))

2856

2844

get_current_db();

2857

2845

2858

2846

executing_query= 0;

2859

return error; /* New command follows */

2847

return error; /* New command follows */

2860

2848

}

2861

2849

2862

2850

2976

2964

}

2977

2965

2978

2966

static void

2979

print_field_types(MYSQL_RES *result)

2967

print_field_types(DRIZZLE_RES *result)

2980

2968

{

2981

MYSQL_FIELD *field;

2969

DRIZZLE_FIELD *field;

2982

2970

uint i=0;

2983

2971

2984

while ((field = mysql_fetch_field(result)))

2972

while ((field = drizzle_fetch_field(result)))

2985

2973

{

2986

2974

tee_fprintf(PAGER, "Field %3u: `%s`\n"

2987

2975

"Catalog: `%s`\n"

3006

2994

3007

2995

3008

2996

static void

3009

print_table_data(MYSQL_RES *result)

2997

print_table_data(DRIZZLE_RES *result)

3010

2998

{

3011

MYSQL_ROW cur;

3012

MYSQL_FIELD *field;

2999

DRIZZLE_ROW cur;

3000

DRIZZLE_FIELD *field;

3013

3001

bool *num_flag;

3014

3002

DYNAMIC_STRING *separator=

3015

3003

(DYNAMIC_STRING *)my_malloc(sizeof(DYNAMIC_STRING), MYF(0));

3016

3004

init_dynamic_string(separator, "", 256, 256);

3017

3005

3018

num_flag=(bool*) my_malloc(sizeof(bool)*mysql_num_fields(result),

3006

num_flag=(bool*) my_malloc(sizeof(bool)*drizzle_num_fields(result),

3019

3007

MYF(MY_WME));

3020

3008

if (column_types_flag)

3021

3009

{

3022

3010

print_field_types(result);

3023

if (!mysql_num_rows(result))

3011

if (!drizzle_num_rows(result))

3024

3012

return;

3025

mysql_field_seek(result,0);

3013

drizzle_field_seek(result,0);

3026

3014

}

3027

3015

dynstr_append(separator, "+");

3028

while ((field = mysql_fetch_field(result)))

3016

while ((field = drizzle_fetch_field(result)))

3029

3017

{

3030

3018

uint length= column_names ? field->name_length : 0;

3031

3019

if (quick)

3045

3033

tee_puts((char*) separator->str, PAGER);

3046

3034

if (column_names)

3047

3035

{

3048

mysql_field_seek(result,0);

3036

drizzle_field_seek(result,0);

3049

3037

(void) tee_fputs("|", PAGER);

3050

for (uint off=0; (field = mysql_fetch_field(result)) ; off++)

3038

for (uint off=0; (field = drizzle_fetch_field(result)) ; off++)

3051

3039

{

3052

3040

uint name_length= (uint) strlen(field->name);

3053

3041

uint numcells= charset_info->cset->numcells(charset_info,

3063

3051

tee_puts((char*) separator->str, PAGER);

3064

3052

}

3065

3053

3066

while ((cur= mysql_fetch_row(result)))

3054

while ((cur= drizzle_fetch_row(result)))

3067

3055

{

3068

3056

if (interrupted_query)

3069

3057

break;

3070

uint32_t *lengths= mysql_fetch_lengths(result);

3058

uint32_t *lengths= drizzle_fetch_lengths(result);

3071

3059

(void) tee_fputs("| ", PAGER);

3072

mysql_field_seek(result, 0);

3073

for (uint off= 0; off < mysql_num_fields(result); off++)

3060

drizzle_field_seek(result, 0);

3061

for (uint off= 0; off < drizzle_num_fields(result); off++)

3074

3062

{

3075

3063

const char *buffer;

3076

3064

uint data_length;

3089

3077

data_length= (uint) lengths[off];

3090

3078

}

3091

3079

3092

field= mysql_fetch_field(result);

3080

field= drizzle_fetch_field(result);

3093

3081

field_max_length= field->max_length;

3094

3082

3095

3083

/*

3137

3125

3138

3126

@returns number of character positions to be used, at most

3139

3127

*/

3140

static int get_field_disp_length(MYSQL_FIELD *field)

3128

static int get_field_disp_length(DRIZZLE_FIELD *field)

3141

3129

{

3142

3130

uint length= column_names ? field->name_length : 0;

3143

3131

3147

3135

length= max(length, field->max_length);

3148

3136

3149

3137

if (length < 4 && !IS_NOT_NULL(field->flags))

3150

length= 4; /* Room for "NULL" */

3138

length= 4; /* Room for "NULL" */

3151

3139

3152

3140

return length;

3153

3141

}

3160

3148

3161

3149

@returns The max number of characters in any row of this result

3162

3150

*/

3163

static int get_result_width(MYSQL_RES *result)

3151

static int get_result_width(DRIZZLE_RES *result)

3164

3152

{

3165

3153

unsigned int len= 0;

3166

MYSQL_FIELD *field;

3167

MYSQL_FIELD_OFFSET offset;

3154

DRIZZLE_FIELD *field;

3155

DRIZZLE_FIELD_OFFSET offset;

3168

3156

3169

offset= mysql_field_tell(result);

3157

offset= drizzle_field_tell(result);

3170

3158

assert(offset == 0);

3171

3159

3172

while ((field= mysql_fetch_field(result)) != NULL)

3160

while ((field= drizzle_fetch_field(result)) != NULL)

3173

3161

len+= get_field_disp_length(field) + 3; /* plus bar, space, & final space */

3174

3162

3175

(void) mysql_field_seek(result, offset);

3163

(void) drizzle_field_seek(result, offset);

3176

3164

3177

3165

return len + 1; /* plus final bar. */

3178

3166

}

3208

3196

3209

3197

3210

3198

static void

3211

print_table_data_html(MYSQL_RES *result)

3199

print_table_data_html(DRIZZLE_RES *result)

3212

3200

{

3213

MYSQL_ROW cur;

3214

MYSQL_FIELD *field;

3201

DRIZZLE_ROW cur;

3202

DRIZZLE_FIELD *field;

3215

3203

3216

mysql_field_seek(result,0);

3204

drizzle_field_seek(result,0);

3217

3205

(void) tee_fputs("<TABLE BORDER=1><TR>", PAGER);

3218

3206

if (column_names)

3219

3207

{

3220

while((field = mysql_fetch_field(result)))

3208

while((field = drizzle_fetch_field(result)))

3221

3209

{

3222

3210

tee_fprintf(PAGER, "<TH>%s</TH>", (field->name ?

3223

3211

(field->name[0] ? field->name :

3225

3213

}

3226

3214

(void) tee_fputs("</TR>", PAGER);

3227

3215

}

3228

while ((cur = mysql_fetch_row(result)))

3216

while ((cur = drizzle_fetch_row(result)))

3229

3217

{

3230

3218

if (interrupted_query)

3231

3219

break;

3232

uint32_t *lengths=mysql_fetch_lengths(result);

3220

uint32_t *lengths=drizzle_fetch_lengths(result);

3233

3221

(void) tee_fputs("<TR>", PAGER);

3234

for (uint32_t i= 0; i < mysql_num_fields(result); i++)

3222

for (uint32_t i= 0; i < drizzle_num_fields(result); i++)

3235

3223

{

3236

3224

(void) tee_fputs("<TD>", PAGER);

3237

3225

safe_put_field(cur[i],lengths[i]);

3244

3232

3245

3233

3246

3234

static void

3247

print_table_data_xml(MYSQL_RES *result)

3235

print_table_data_xml(DRIZZLE_RES *result)

3248

3236

{

3249

MYSQL_ROW cur;

3250

MYSQL_FIELD *fields;

3237

DRIZZLE_ROW cur;

3238

DRIZZLE_FIELD *fields;

3251

3239

3252

mysql_field_seek(result,0);

3240

drizzle_field_seek(result,0);

3253

3241

3254

3242

tee_fputs("<?xml version=\"1.0\"?>\n\n<resultset statement=\"", PAGER);

3255

3243

xmlencode_print(glob_buffer->str, glob_buffer->length);

3256

3244

tee_fputs("\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">",

3257

3245

PAGER);

3258

3246

3259

fields = mysql_fetch_fields(result);

3260

while ((cur = mysql_fetch_row(result)))

3247

fields = drizzle_fetch_fields(result);

3248

while ((cur = drizzle_fetch_row(result)))

3261

3249

{

3262

3250

if (interrupted_query)

3263

3251

break;

3264

uint32_t *lengths=mysql_fetch_lengths(result);

3252

uint32_t *lengths=drizzle_fetch_lengths(result);

3265

3253

(void) tee_fputs("\n <row>\n", PAGER);

3266

for (uint i=0; i < mysql_num_fields(result); i++)

3254

for (uint i=0; i < drizzle_num_fields(result); i++)

3267

3255

{

3268

3256

tee_fprintf(PAGER, "\t<field name=\"");

3269

3257

xmlencode_print(fields[i].name, (uint) strlen(fields[i].name));

3283

3271

3284

3272

3285

3273

static void

3286

print_table_data_vertically(MYSQL_RES *result)

3274

print_table_data_vertically(DRIZZLE_RES *result)

3287

3275

{

3288

MYSQL_ROW cur;

3289

uint max_length=0;

3290

MYSQL_FIELD *field;

3276

DRIZZLE_ROW cur;

3277

uint max_length=0;

3278

DRIZZLE_FIELD *field;

3291

3279

3292

while ((field = mysql_fetch_field(result)))

3280

while ((field = drizzle_fetch_field(result)))

3293

3281

{

3294

3282

uint length= field->name_length;

3295

3283

if (length > max_length)

3297

3285

field->max_length=length;

3298

3286

}

3299

3287

3300

mysql_field_seek(result,0);

3301

for (uint row_count=1; (cur= mysql_fetch_row(result)); row_count++)

3288

drizzle_field_seek(result,0);

3289

for (uint row_count=1; (cur= drizzle_fetch_row(result)); row_count++)

3302

3290

{

3303

3291

if (interrupted_query)

3304

3292

break;

3305

mysql_field_seek(result,0);

3293

drizzle_field_seek(result,0);

3306

3294

tee_fprintf(PAGER,

3307

3295

"*************************** %d. row ***************************\n", row_count);

3308

for (uint off=0; off < mysql_num_fields(result); off++)

3296

for (uint off=0; off < drizzle_num_fields(result); off++)

3309

3297

{

3310

field= mysql_fetch_field(result);

3298

field= drizzle_fetch_field(result);

3311

3299

tee_fprintf(PAGER, "%*s: ",(int) max_length,field->name);

3312

3300

tee_fprintf(PAGER, "%s\n",cur[off] ? (char*) cur[off] : "NULL");

3313

3301

}

3320

3308

static void print_warnings()

3321

3309

{

3322

3310

const char *query;

3323

MYSQL_RES *result;

3324

MYSQL_ROW cur;

3311

DRIZZLE_RES *result;

3312

DRIZZLE_ROW cur;

3325

3313

uint64_t num_rows;

3326

3314

3327

3315

/* Save current error before calling "show warnings" */

3328

uint error= mysql_errno(&mysql);

3316

uint error= drizzle_errno(&drizzle);

3329

3317

3330

3318

/* Get the warnings */

3331

3319

query= "show warnings";

3332

mysql_real_query_for_lazy(query, strlen(query));

3333

mysql_store_result_for_lazy(&result);

3320

drizzle_real_query_for_lazy(query, strlen(query));

3321

drizzle_store_result_for_lazy(&result);

3334

3322

3335

3323

/* Bail out when no warnings */

3336

if (!(num_rows= mysql_num_rows(result)))

3324

if (!(num_rows= drizzle_num_rows(result)))

3337

3325

goto end;

3338

3326

3339

cur= mysql_fetch_row(result);

3327

cur= drizzle_fetch_row(result);

3340

3328

3341

3329

/*

3342

3330

Don't print a duplicate of the current error. It is possible for SHOW

3352

3340

do

3353

3341

{

3354

3342

tee_fprintf(PAGER, "%s (Code %s): %s\n", cur[0], cur[1], cur[2]);

3355

} while ((cur= mysql_fetch_row(result)));

3343

} while ((cur= drizzle_fetch_row(result)));

3356

3344

end_pager();

3357

3345

3358

3346

end:

3359

mysql_free_result(result);

3347

drizzle_free_result(result);

3360

3348

}

3361

3349

3362

3350

3426

3414

3427

3415

3428

3416

static void

3429

print_tab_data(MYSQL_RES *result)

3417

print_tab_data(DRIZZLE_RES *result)

3430

3418

{

3431

MYSQL_ROW cur;

3432

MYSQL_FIELD *field;

3433

uint32_t *lengths;

3419

DRIZZLE_ROW cur;

3420

DRIZZLE_FIELD *field;

3421

uint32_t *lengths;

3434

3422

3435

3423

if (opt_silent < 2 && column_names)

3436

3424

{

3437

3425

int first=0;

3438

while ((field = mysql_fetch_field(result)))

3426

while ((field = drizzle_fetch_field(result)))

3439

3427

{

3440

3428

if (first++)

3441

3429

(void) tee_fputs("\t", PAGER);

3443

3431

}

3444

3432

(void) tee_fputs("\n", PAGER);

3445

3433

}

3446

while ((cur = mysql_fetch_row(result)))

3434

while ((cur = drizzle_fetch_row(result)))

3447

3435

{

3448

lengths= mysql_fetch_lengths(result);

3436

lengths= drizzle_fetch_lengths(result);

3449

3437

safe_put_field(cur[0],lengths[0]);

3450

for (uint off=1 ; off < mysql_num_fields(result); off++)

3438

for (uint off=1 ; off < drizzle_num_fields(result); off++)

3451

3439

{

3452

3440

(void) tee_fputs("\t", PAGER);

3453

3441

safe_put_field(cur[off], lengths[off]);

3478

3466

return 0;

3479

3467

}

3480

3468

else

3481

param = outfile; //resume using the old outfile

3469

param = outfile; //resume using the old outfile

3482

3470

}

3483

3471

3484

3472

/* eliminate the spaces before the parameters */

3650

3638

3651

3639

if (connected)

3652

3640

{

3653

sprintf(buff,"Connection id: %u",mysql_thread_id(&mysql));

3641

sprintf(buff,"Connection id: %u",drizzle_thread_id(&drizzle));

3654

3642

put_info(buff,INFO_INFO,0,0);

3655

3643

sprintf(buff,"Current database: %.128s\n",

3656

3644

current_db ? current_db : "*** NONE ***");

3671

3659

/* Skip space from file name */

3672

3660

while (my_isspace(charset_info,*line))

3673

3661

line++;

3674

if (!(param = strchr(line, ' '))) // Skip command name

3662

if (!(param = strchr(line, ' '))) // Skip command name

3675

3663

return put_info("Usage: \\. <filename> | source <filename>",

3676

3664

INFO_ERROR, 0,0);

3677

3665

while (my_isspace(charset_info,*param))

3773

3761

if (one_database)

3774

3762

{

3775

3763

skip_updates= 1;

3776

select_db= 0; // don't do mysql_select_db()

3764

select_db= 0; // don't do drizzle_select_db()

3777

3765

}

3778

3766

else

3779

select_db= 2; // do mysql_select_db() and build_completion_hash()

3767

select_db= 2; // do drizzle_select_db() and build_completion_hash()

3780

3768

}

3781

3769

else

3782

3770

{

3783

3771

/*

3784

3772

USE to the current db specified.

3785

We do need to send mysql_select_db() to make server

3773

We do need to send drizzle_select_db() to make server

3786

3774

update database level privileges, which might

3787

3775

change since last USE (see bug#10979).

3788

3776

For performance purposes, we'll skip rebuilding of completion hash.

3789

3777

*/

3790

3778

skip_updates= 0;

3791

select_db= 1; // do only mysql_select_db(), without completion

3779

select_db= 1; // do only drizzle_select_db(), without completion

3792

3780

}

3793

3781

3794

3782

if (select_db)

3799

3787

*/

3800

3788

if (!connected && reconnect())

3801

3789

return opt_reconnect ? -1 : 1; // Fatal error

3802

if (mysql_select_db(&mysql,tmp))

3790

if (drizzle_select_db(&drizzle,tmp))

3803

3791

{

3804

if (mysql_errno(&mysql) != CR_SERVER_GONE_ERROR)

3805

return put_error(&mysql);

3792

if (drizzle_errno(&drizzle) != CR_SERVER_GONE_ERROR)

3793

return put_error(&drizzle);

3806

3794

3807

3795

if (reconnect())

3808

3796

return opt_reconnect ? -1 : 1; // Fatal error

3809

if (mysql_select_db(&mysql,tmp))

3810

return put_error(&mysql);

3797

if (drizzle_select_db(&drizzle,tmp))

3798

return put_error(&drizzle);

3811

3799

}

3812

3800

my_free(current_db,MYF(MY_ALLOW_ZERO_PTR));

3813

3801

current_db= strdup(tmp);

3900

3888

3901

3889

3902

3890

static int

3903

sql_real_connect(char *host,char *database,char *user,char *password,

3891

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

3904

3892

uint silent)

3905

3893

{

3906

3894

if (connected)

3907

3895

{

3908

3896

connected= 0;

3909

mysql_close(&mysql);

3897

drizzle_close(&drizzle);

3910

3898

}

3911

mysql_init(&mysql);

3899

drizzle_create(&drizzle);

3912

3900

if (opt_connect_timeout)

3913

3901

{

3914

3902

uint timeout=opt_connect_timeout;

3915

mysql_options(&mysql,MYSQL_OPT_CONNECT_TIMEOUT,

3903

drizzle_options(&drizzle,DRIZZLE_OPT_CONNECT_TIMEOUT,

3916

3904

(char*) &timeout);

3917

3905

}

3918

3906

if (opt_compress)

3919

mysql_options(&mysql,MYSQL_OPT_COMPRESS,NullS);

3907

drizzle_options(&drizzle,DRIZZLE_OPT_COMPRESS,NullS);

3920

3908

if (opt_secure_auth)

3921

mysql_options(&mysql, MYSQL_SECURE_AUTH, (char *) &opt_secure_auth);

3909

drizzle_options(&drizzle, DRIZZLE_SECURE_AUTH, (char *) &opt_secure_auth);

3922

3910

if (using_opt_local_infile)

3923

mysql_options(&mysql,MYSQL_OPT_LOCAL_INFILE, (char*) &opt_local_infile);

3911

drizzle_options(&drizzle,DRIZZLE_OPT_LOCAL_INFILE, (char*) &opt_local_infile);

3924

3912

if (opt_protocol)

3925

mysql_options(&mysql,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);

3913

drizzle_options(&drizzle,DRIZZLE_OPT_PROTOCOL,(char*)&opt_protocol);

3926

3914

if (safe_updates)

3927

3915

{

3928

3916

char init_command[100];

3929

3917

sprintf(init_command,

3930

"SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=%"PRIu32

3918

"SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=%"PRIu32

3931

3919

",SQL_MAX_JOIN_SIZE=%"PRIu32,

3932

select_limit, max_join_size);

3933

mysql_options(&mysql, MYSQL_INIT_COMMAND, init_command);

3920

select_limit, max_join_size);

3921

drizzle_options(&drizzle, DRIZZLE_INIT_COMMAND, init_command);

3934

3922

}

3935

3923

if (default_charset_used)

3936

mysql_options(&mysql, MYSQL_SET_CHARSET_NAME, default_charset);

3937

if (!mysql_real_connect(&mysql, host, user, password,

3938

database, opt_mysql_port, opt_mysql_unix_port,

3924

drizzle_options(&drizzle, DRIZZLE_SET_CHARSET_NAME, default_charset);

3925

if (!drizzle_connect(&drizzle, host, user, password,

3926

database, opt_drizzle_port, opt_drizzle_unix_port,

3939

3927

connect_flag | CLIENT_MULTI_STATEMENTS))

3940

3928

{

3941

3929

if (!silent ||

3942

(mysql_errno(&mysql) != CR_CONN_HOST_ERROR &&

3943

mysql_errno(&mysql) != CR_CONNECTION_ERROR))

3930

(drizzle_errno(&drizzle) != CR_CONN_HOST_ERROR &&

3931

drizzle_errno(&drizzle) != CR_CONNECTION_ERROR))

3944

3932

{

3945

(void) put_error(&mysql);

3933

(void) put_error(&drizzle);

3946

3934

(void) fflush(stdout);

3947

return ignore_errors ? -1 : 1; // Abort

3935

return ignore_errors ? -1 : 1; // Abort

3948

3936

}

3949

return -1; // Retryable

3937

return -1; // Retryable

3950

3938

}

3951

3939

connected=1;

3952

mysql.reconnect= debug_info_flag; // We want to know if this happens

3940

drizzle.reconnect= debug_info_flag; // We want to know if this happens

3953

3941

build_completion_hash(opt_rehash, 1);

3954

3942

return 0;

3955

3943

}

3956

3944

3957

3945

3958

3946

static int

3959

sql_connect(char *host,char *database,char *user,char *password,uint silent)

3960

{

3961

bool message=0;

3962

uint count=0;

3963

int error;

3964

for (;;)

3965

{

3966

if ((error=sql_real_connect(host,database,user,password,wait_flag)) >= 0)

3967

{

3968

if (count)

3969

{

3970

tee_fputs("\n", stderr);

3971

(void) fflush(stderr);

3972

}

3973

return error;

3974

}

3975

if (!wait_flag)

3976

return ignore_errors ? -1 : 1;

3977

if (!message && !silent)

3978

{

3979

message=1;

3980

tee_fputs("Waiting",stderr); (void) fflush(stderr);

3981

}

3982

(void) sleep(wait_time);

3983

if (!silent)

3984

{

3985

putc('.',stderr); (void) fflush(stderr);

3986

count++;

3987

}

3988

}

3989

}

3990

3991

3992

3993

static int

3994

3947

com_status(DYNAMIC_STRING *buffer __attribute__((unused)),

3995

3948

char *line __attribute__((unused)))

3996

3949

{

3997

3950

const char *status_str;

3998

3951

char buff[40];

3999

3952

uint64_t id;

4000

MYSQL_RES *result;

3953

DRIZZLE_RES *result;

4001

3954

4002

3955

tee_puts("--------------", stdout);

4003

usage(1); /* Print version */

3956

usage(1); /* Print version */

4004

3957

if (connected)

4005

3958

{

4006

tee_fprintf(stdout, "\nConnection id:\t\t%lu\n",mysql_thread_id(&mysql));

3959

tee_fprintf(stdout, "\nConnection id:\t\t%lu\n",drizzle_thread_id(&drizzle));

4007

3960

/*

4008

3961

Don't remove "limit 1",

4009

3962

it is protection againts SQL_SELECT_LIMIT=0

4010

3963

*/

4011

if (!mysql_query(&mysql,"select DATABASE(), USER() limit 1") &&

4012

(result=mysql_use_result(&mysql)))

3964

if (!drizzle_query(&drizzle,"select DATABASE(), USER() limit 1") &&

3965

(result=drizzle_use_result(&drizzle)))

4013

3966

{

4014

MYSQL_ROW cur=mysql_fetch_row(result);

3967

DRIZZLE_ROW cur=drizzle_fetch_row(result);

4015

3968

if (cur)

4016

3969

{

4017

3970

tee_fprintf(stdout, "Current database:\t%s\n", cur[0] ? cur[0] : "");

4018

3971

tee_fprintf(stdout, "Current user:\t\t%s\n", cur[1]);

4019

3972

}

4020

mysql_free_result(result);

3973

drizzle_free_result(result);

4021

3974

}

4022

3975

tee_puts("SSL:\t\t\tNot in use", stdout);

4023

3976

}

4037

3990

tee_fprintf(stdout, "Current pager:\t\t%s\n", pager);

4038

3991

tee_fprintf(stdout, "Using outfile:\t\t'%s'\n", opt_outfile ? outfile : "");

4039

3992

tee_fprintf(stdout, "Using delimiter:\t%s\n", delimiter);

4040

tee_fprintf(stdout, "Server version:\t\t%s\n", server_version_string(&mysql));

4041

tee_fprintf(stdout, "Protocol version:\t%d\n", mysql_get_proto_info(&mysql));

4042

tee_fprintf(stdout, "Connection:\t\t%s\n", mysql_get_host_info(&mysql));

4043

if ((id= mysql_insert_id(&mysql)))

3993

tee_fprintf(stdout, "Server version:\t\t%s\n", server_version_string(&drizzle));

3994

tee_fprintf(stdout, "Protocol version:\t%d\n", drizzle_get_proto_info(&drizzle));

3995

tee_fprintf(stdout, "Connection:\t\t%s\n", drizzle_get_host_info(&drizzle));

3996

if ((id= drizzle_insert_id(&drizzle)))

4044

3997

tee_fprintf(stdout, "Insert id:\t\t%s\n", llstr(id, buff));

4045

3998

4046

3999

/* "limit 1" is protection against SQL_SELECT_LIMIT=0 */

4047

if (!mysql_query(&mysql,"select @@character_set_client, @@character_set_connection, @@character_set_server, @@character_set_database limit 1") &&

4048

(result=mysql_use_result(&mysql)))

4000

if (!drizzle_query(&drizzle,"select @@character_set_client, @@character_set_connection, @@character_set_server, @@character_set_database limit 1") &&

4001

(result=drizzle_use_result(&drizzle)))

4049

4002

{

4050

MYSQL_ROW cur=mysql_fetch_row(result);

4003

DRIZZLE_ROW cur=drizzle_fetch_row(result);

4051

4004

if (cur)

4052

4005

{

4053

4006

tee_fprintf(stdout, "Server characterset:\t%s\n", cur[2] ? cur[2] : "");

4055

4008

tee_fprintf(stdout, "Client characterset:\t%s\n", cur[0] ? cur[0] : "");

4056

4009

tee_fprintf(stdout, "Conn. characterset:\t%s\n", cur[1] ? cur[1] : "");

4057

4010

}

4058

mysql_free_result(result);

4011

drizzle_free_result(result);

4059

4012

}

4060

4013

else

4061

4014

{

4062

4015

/* Probably pre-4.1 server */

4063

4016

tee_fprintf(stdout, "Client characterset:\t%s\n", charset_info->csname);

4064

tee_fprintf(stdout, "Server characterset:\t%s\n", mysql.charset->csname);

4017

tee_fprintf(stdout, "Server characterset:\t%s\n", drizzle.charset->csname);

4065

4018

}

4066

4019

4067

if (strstr(mysql_get_host_info(&mysql),"TCP/IP") || ! mysql.unix_socket)

4068

tee_fprintf(stdout, "TCP port:\t\t%d\n", mysql.port);

4020

if (strstr(drizzle_get_host_info(&drizzle),"TCP/IP") || ! drizzle.unix_socket)

4021

tee_fprintf(stdout, "TCP port:\t\t%d\n", drizzle.port);

4069

4022

else

4070

tee_fprintf(stdout, "UNIX socket:\t\t%s\n", mysql.unix_socket);

4071

if (mysql.net.compress)

4023

tee_fprintf(stdout, "UNIX socket:\t\t%s\n", drizzle.unix_socket);

4024

if (drizzle.net.compress)

4072

4025

tee_fprintf(stdout, "Protocol:\t\tCompressed\n");

4073

4026

4074

if ((status_str= mysql_stat(&mysql)) && !mysql_error(&mysql)[0])

4027

if ((status_str= drizzle_stat(&drizzle)) && !drizzle_error(&drizzle)[0])

4075

4028

{

4076

4029

ulong sec;

4077

4030

const char *pos= strchr(status_str,' ');

4080

4033

if ((status_str= str2int(pos,10,0,LONG_MAX,(long*) &sec)))

4081

4034

{

4082

4035

nice_time((double) sec,buff,0);

4083

tee_puts(buff, stdout); /* print nice time */

4036

tee_puts(buff, stdout); /* print nice time */

4084

4037

while (*status_str == ' ')

4085

4038

status_str++; /* to next info */

4086

4039

tee_putc('\n', stdout);

4104

4057

}

4105

4058

4106

4059

static const char *

4107

server_version_string(MYSQL *con)

4060

server_version_string(DRIZZLE *con)

4108

4061

{

4109

4062

static char buf[MAX_SERVER_VERSION_LENGTH] = "";

4110

4063

4112

4065

if (buf[0] == '\0')

4113

4066

{

4114

4067

char *bufp = buf;

4115

MYSQL_RES *result;

4068

DRIZZLE_RES *result;

4116

4069

4117

bufp= strnmov(buf, mysql_get_server_info(con), sizeof buf);

4070

bufp= strnmov(buf, drizzle_get_server_info(con), sizeof buf);

4118

4071

4119

4072

/* "limit 1" is protection against SQL_SELECT_LIMIT=0 */

4120

if (!mysql_query(con, "select @@version_comment limit 1") &&

4121

(result = mysql_use_result(con)))

4073

if (!drizzle_query(con, "select @@version_comment limit 1") &&

4074

(result = drizzle_use_result(con)))

4122

4075

{

4123

MYSQL_ROW cur = mysql_fetch_row(result);

4076

DRIZZLE_ROW cur = drizzle_fetch_row(result);

4124

4077

if (cur && cur[0])

4125

4078

{

4126

4079

bufp = strxnmov(bufp, sizeof buf - (bufp - buf), " ", cur[0], NullS);

4127

4080

}

4128

mysql_free_result(result);

4081

drizzle_free_result(result);

4129

4082

}

4130

4083

4131

4084

/* str*nmov doesn't guarantee NUL-termination */

4209

4162

4210

4163

4211

4164

static int

4212

put_error(MYSQL *con)

4165

put_error(DRIZZLE *con)

4213

4166

{

4214

return put_info(mysql_error(con), INFO_ERROR, mysql_errno(con),

4215

mysql_sqlstate(con));

4167

return put_info(drizzle_error(con), INFO_ERROR, drizzle_errno(con),

4168

drizzle_sqlstate(con));

4216

4169

}

4217

4170

4218

4171

4272

4225

}

4273

4226

4274

4227

#include <sys/times.h>

4275

#ifdef _SC_CLK_TCK // For mit-pthreads

4228

#ifdef _SC_CLK_TCK // For mit-pthreads

4276

4229

#undef CLOCKS_PER_SEC

4277

4230

#define CLOCKS_PER_SEC (sysconf(_SC_CLK_TCK))

4278

4231

#endif

4285

4238

4286

4239

4287

4240

/**

4288

Write as many as 52+1 bytes to buff, in the form of a legible duration of time.

4241

Write as many as 52+1 bytes to buff, in the form of a legible

4242

duration of time.

4289

4243

4290

4244

len("4294967296 days, 23 hours, 59 minutes, 60.00 seconds") -> 52

4291

4245

*/

4327

4281

}

4328

4282

4329

4283

4330

static void mysql_end_timer(ulong start_time,char *buff)

4284

static void drizzle_end_timer(ulong start_time,char *buff)

4331

4285

{

4332

4286

buff[0]=' ';

4333

4287

buff[1]='(';

4367

4321

break;

4368

4322

case 'v':

4369

4323

if (connected)

4370

dynstr_append(processed_prompt, mysql_get_server_info(&mysql));

4324

dynstr_append(processed_prompt, drizzle_get_server_info(&drizzle));

4371

4325

else

4372

4326

dynstr_append(processed_prompt, "not_connected");

4373

4327

break;

4377

4331

case 'h':

4378

4332

{

4379

4333

const char *prompt;

4380

prompt= connected ? mysql_get_host_info(&mysql) : "not_connected";

4334

prompt= connected ? drizzle_get_host_info(&drizzle) : "not_connected";

4381

4335

if (strstr(prompt, "Localhost"))

4382

4336

dynstr_append(processed_prompt, "localhost");

4383

4337

else

4395

4349

break;

4396

4350

}

4397

4351

4398

const char *host_info = mysql_get_host_info(&mysql);

4352

const char *host_info = drizzle_get_host_info(&drizzle);

4399

4353

if (strstr(host_info, "memory"))

4400

4354

{

4401

dynstr_append(processed_prompt, mysql.host);

4355

dynstr_append(processed_prompt, drizzle.host);

4402

4356

}

4403

4357

else if (strstr(host_info,"TCP/IP") ||

4404

!mysql.unix_socket)

4405

add_int_to_prompt(mysql.port);

4358

!drizzle.unix_socket)

4359

add_int_to_prompt(drizzle.port);

4406

4360

else

4407

4361

{

4408

char *pos=strrchr(mysql.unix_socket,'/');

4409

dynstr_append(processed_prompt, pos ? pos+1 : mysql.unix_socket);

4362

char *pos=strrchr(drizzle.unix_socket,'/');

4363

dynstr_append(processed_prompt, pos ? pos+1 : drizzle.unix_socket);

4410

4364

}

4411

4365

}

4412

4366

break;

4525

4479

my_free(full_username,MYF(MY_ALLOW_ZERO_PTR));

4526

4480

my_free(part_username,MYF(MY_ALLOW_ZERO_PTR));

4527

4481

4528

MYSQL_RES *result;

4529

if (!mysql_query(&mysql,"select USER()") &&

4530

(result=mysql_use_result(&mysql)))

4482

DRIZZLE_RES *result;

4483

if (!drizzle_query(&drizzle,"select USER()") &&

4484

(result=drizzle_use_result(&drizzle)))

4531

4485

{

4532

MYSQL_ROW cur=mysql_fetch_row(result);

4486

DRIZZLE_ROW cur=drizzle_fetch_row(result);

4533

4487

full_username= strdup(cur[0]);

4534

4488

part_username= strdup(strtok(cur[0],"@"));

4535

(void) mysql_fetch_row(result); // Read eof

4489

(void) drizzle_fetch_row(result); // Read eof

4536

4490

}

4537

4491

}

4538

4492

4539

static int com_prompt(DYNAMIC_STRING *buffer __attribute__((__unused__)), char *line)

4493

static int com_prompt(DYNAMIC_STRING *buffer __attribute__((__unused__)),

4494

char *line)

4540

4495

{

4541

4496

char *ptr=strchr(line, ' ');

4542

4497

prompt_counter = 0;