~drizzle-trunk/drizzle/development

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

1282

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

1275

1283

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

1276

1284

{"auto-vertical-output", OPT_AUTO_VERTICAL_OUTPUT,

1277

1285

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

1312

1320

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

1313

1321

0, 0, 0, 0},

1314

1322

{"named-commands", 'G',

1315

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

1323

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

1316

1324

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

1317

1325

0, 0},

1318

1326

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

1368

1376

"/etc/services, "

1369

1377

#endif

1370

1378

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

1371

(char**) &opt_mysql_port,

1372

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

1373

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

1379

(char**) &opt_drizzle_port,

1380

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

1381

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

1374

1382

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

1375

1383

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

1376

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

1384

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

1377

1385

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

1378

1386

{"quick", 'q',

1379

1387

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

1386

1394

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

1387

1395

0, 0},

1388

1396

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

1389

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

1397

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

1390

1398

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

1391

1399

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

1392

1400

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

1458

1466

if (version)

1459

1467

return;

1460

1468

printf("\

1461

1469

1462

1470

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

1463

1471

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

1464

1472

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

1474

1482

{

1475

1483

switch(optid) {

1476

1484

case OPT_CHARSETS_DIR:

1477

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

1478

charsets_dir = mysql_charsets_dir;

1485

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

1486

charsets_dir = drizzle_charsets_dir;

1479

1487

break;

1480

1488

case OPT_DEFAULT_CHARSET:

1481

1489

default_charset_used= 1;

1541

1549

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

1542

1550

opt_nopager= 1;

1543

1551

break;

1544

case OPT_MYSQL_PROTOCOL:

1552

case OPT_DRIZZLE_PROTOCOL:

1545

1553

opt_protocol= find_type_or_exit(argument, &sql_protocol_typelib,

1546

1554

opt->name);

1547

1555

break;

1548

1556

case OPT_SERVER_ARG:

1549

#ifdef EMBEDDED_LIBRARY

1550

1551

When the embedded server is being tested, the client needs to be

1552

able to pass command-line arguments to the embedded server so it can

1553

locate the language files and data directory.

1554

1555

if (!embedded_server_arg_count)

1556

{

1557

embedded_server_arg_count= 1;

1558

embedded_server_args[0]= (char*) "";

1559

}

1560

if (embedded_server_arg_count == MAX_SERVER_ARGS-1 ||

1561

!(embedded_server_args[embedded_server_arg_count++]=

1562

g_strdup(argument)))

1563

{

1564

put_info("Can't use server argument", INFO_ERROR);

1565

return 0;

1566

}

1567

#else /*EMBEDDED_LIBRARY */

1568

1557

printf("WARNING: --server-arg option not supported in this configuration.\n");

1569

#endif

1570

1558

break;

1571

1559

case 'A':

1572

1560

opt_rehash= 0;

1590

1578

break;

1591

1579

case 'p':

1592

1580

if (argument == disabled_my_option)

1593

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

1581

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

1594

1582

if (argument)

1595

1583

{

1596

1584

char *start= argument;

1597

1585

my_free(opt_password, MYF(MY_ALLOW_ZERO_PTR));

1598

opt_password= g_strdup(argument);

1599

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

1586

opt_password= strdup(argument);

1587

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

1600

1588

if (*start)

1601

1589

start[1]=0 ;

1602

1590

tty_password= 0;

1638

1626

{

1639

1627

char *tmp, *pagpoint;

1640

1628

int ho_error;

1641

MYSQL_PARAMETERS *mysql_params= mysql_get_parameters();

1629

DRIZZLE_PARAMETERS *drizzle_params= drizzle_get_parameters();

1642

1630

1643

1631

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

1644

1632

if (tmp)

1654

1642

strmov(pager, pagpoint);

1655

1643

strmov(default_pager, pager);

1656

1644

1657

opt_max_allowed_packet= *mysql_params->p_max_allowed_packet;

1658

opt_net_buffer_length= *mysql_params->p_net_buffer_length;

1645

opt_max_allowed_packet= *drizzle_params->p_max_allowed_packet;

1646

opt_net_buffer_length= *drizzle_params->p_net_buffer_length;

1659

1647

1660

1648

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

1661

1649

exit(ho_error);

1662

1650

1663

*mysql_params->p_max_allowed_packet= opt_max_allowed_packet;

1664

*mysql_params->p_net_buffer_length= opt_net_buffer_length;

1651

*drizzle_params->p_max_allowed_packet= opt_max_allowed_packet;

1652

*drizzle_params->p_net_buffer_length= opt_net_buffer_length;

1665

1653

1666

1654

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

1667

1655

{

1687

1675

{

1688

1676

skip_updates= 0;

1689

1677

my_free(current_db, MYF(MY_ALLOW_ZERO_PTR));

1690

current_db= g_strdup(*argv);

1678

current_db= strdup(*argv);

1691

1679

}

1692

1680

if (tty_password)

1693

1681

opt_password= get_tty_password(NullS);

1724

1712

(uchar) line[2] == 0xBF)

1725

1713

line+= 3;

1726

1714

line_number++;

1727

if (glob_buffer->len!=0)

1715

if (glob_buffer->length!=0)

1728

1716

status.query_start_line=line_number;

1729

1717

}

1730

1718

else

1731

1719

{

1732

1720

char *prompt= (char*) (ml_comment ? " /*> " :

1733

(glob_buffer->len == 0) ? construct_prompt() :

1721

(glob_buffer->length == 0) ? construct_prompt() :

1734

1722

!in_string ? " -> " :

1735

1723

in_string == '\'' ?

1736

1724

" '> " : (in_string == '`' ?

1737

1725

" `> " :

1738

1726

" \"> "));

1739

if (opt_outfile && (glob_buffer->len==0))

1727

if (opt_outfile && (glob_buffer->length==0))

1740

1728

fflush(OUTFILE);

1741

1729

1742

1730

if (opt_outfile)

1757

1745

}

1758

1746

1759

1747

1760

Check if line is a mysql command line

1748

Check if line is a drizzle command line

1761

1749

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

1762

1750

1763

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

1751

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

1764

1752

&& !ml_comment && !in_string && (com=find_command(line,0)))

1765

1753

{

1766

1754

if ((*com->func)(glob_buffer,line) > 0)

1767

1755

break;

1768

1756

// If buffer was emptied

1769

if (glob_buffer->len==0)

1757

if (glob_buffer->length==0)

1770

1758

in_string=0;

1771

1759

if (interactive && status.add_to_history && not_in_history(line))

1772

1760

add_history(line);

1780

1768

if (!interactive && !status.exit_status)

1781

1769

{

1782

1770

remove_cntrl(glob_buffer);

1783

if (glob_buffer->len != 0)

1771

if (glob_buffer->length != 0)

1784

1772

{

1785

1773

status.exit_status=1;

1786

1774

if (com_go(glob_buffer,line) <= 0)

1824

1812

while (my_isspace(charset_info,*end))

1825

1813

end++;

1826

1814

if (!*end)

1827

end=0; // no arguments to function

1815

end=0; // no arguments to function

1828

1816

}

1829

1817

else

1830

1818

len=(uint) strlen(name);

1842

1830

}

1843

1831

1844

1832

1845

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

1833

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

1846

1834

bool *ml_comment)

1847

1835

{

1848

1836

uchar inchar;

1852

1840

bool ss_comment= 0;

1853

1841

1854

1842

1855

if (!line[0] && (buffer->len==0))

1843

if (!line[0] && (buffer->length==0))

1856

1844

return(0);

1857

1845

if (status.add_to_history && line[0] && not_in_history(line))

1858

1846

add_history(line);

1864

1852

{

1865

1853

// Skip spaces at the beggining of a statement

1866

1854

if (my_isspace(charset_info,inchar) && (out == line) &&

1867

(buffer->len==0))

1855

(buffer->length==0))

1868

1856

continue;

1869

1857

}

1870

1858

1886

1874

}

1887

1875

#endif

1888

1876

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

1889

!(mysql.server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES))

1877

!(drizzle.server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES))

1890

1878

{

1891

1879

// Found possbile one character command like \c

1892

1880

1893

1881

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

1894

break; // readline adds one '\'

1895

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

1896

{ // Don't allow commands in string

1882

break; // readline adds one '\'

1883

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

1884

{ // Don't allow commands in string

1897

1885

*out++='\\';

1898

1886

*out++= (char) inchar;

1899

1887

continue;

1903

1891

// Flush previously accepted characters

1904

1892

if (out != line)

1905

1893

{

1906

g_string_append_len(buffer, line, (gssize) (out-line));

1894

dynstr_append_mem(buffer, line, (out-line));

1907

1895

out= line;

1908

1896

}

1909

1897

1927

1915

for (pos++ ;

1928

1916

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

1929

1917

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

1930

; // Remove parameters

1918

; // Remove parameters

1931

1919

if (!*pos)

1932

1920

pos--;

1933

1921

else

1953

1941

// Flush previously accepted characters

1954

1942

if (out != line)

1955

1943

{

1956

g_string_append_len(buffer, line, (gssize) (out - line));

1944

dynstr_append_mem(buffer, line, (out - line));

1957

1945

out= line;

1958

1946

}

1959

1947

1960

1948

// Flush possible comments in the buffer

1961

if (buffer->len != 0)

1949

if (buffer->length != 0)

1962

1950

{

1963

1951

if (com_go(buffer, 0) > 0) // < 0 is not fatal

1964

1952

return(1);

1965

1953

assert(buffer!=NULL);

1966

g_string_truncate(buffer,0);

1954

dynstr_set(buffer, NULL);

1967

1955

}

1968

1956

1969

1957

1970

1958

Delimiter wants the get rest of the given line as argument to

1971

1959

allow one to change ';' to ';;' and back

1972

1960

1973

g_string_append(buffer,pos);

1961

dynstr_append(buffer,pos);

1974

1962

if (com_delimiter(buffer, pos) > 0)

1975

1963

return(1);

1976

1964

1977

g_string_truncate(buffer,0);

1965

dynstr_set(buffer, NULL);

1978

1966

break;

1979

1967

}

1980

1968

else if (!*ml_comment && !*in_string && is_prefix(pos, delimiter))

1990

1978

// Flush previously accepted characters

1991

1979

if (out != line)

1992

1980

{

1993

g_string_append_len(buffer, line, (gssize) (out-line));

1981

dynstr_append_mem(buffer, line, (out-line));

1994

1982

out= line;

1995

1983

}

1996

1984

2000

1988

my_isspace(charset_info, pos[2]))))

2001

1989

{

2002

1990

// Add trailing single line comments to this statement

2003

g_string_append(buffer, pos);

1991

dynstr_append(buffer, pos);

2004

1992

pos+= strlen(pos);

2005

1993

}

2006

1994

2017

2005

if (com_go(buffer, 0) > 0) // < 0 is not fatal

2018

2006

return(1);

2019

2007

}

2020

g_string_truncate(buffer,0);

2008

dynstr_set(buffer, NULL);

2021

2009

}

2022

2010

else if (!*ml_comment

2023

2011

&& (!*in_string

2029

2017

// Flush previously accepted characters

2030

2018

if (out != line)

2031

2019

{

2032

g_string_append_len(buffer, line, (gssize) (out - line));

2020

dynstr_append_mem(buffer, line, (out - line));

2033

2021

out= line;

2034

2022

}

2035

2023

2036

2024

// comment to end of line

2037

2025

if (preserve_comments)

2038

g_string_append(buffer,pos);

2026

dynstr_append(buffer,pos);

2039

2027

2040

2028

break;

2041

2029

}

2052

2040

*ml_comment= 1;

2053

2041

if (out != line)

2054

2042

{

2055

g_string_append_len(buffer, line, (gssize) (out-line));

2043

dynstr_append_mem(buffer, line, (out-line));

2056

2044

out=line;

2057

2045

}

2058

2046

}

2068

2056

*ml_comment= 0;

2069

2057

if (out != line)

2070

2058

{

2071

g_string_append_len(buffer, line, (gssize) (out - line));

2059

dynstr_append_mem(buffer, line, (out - line));

2072

2060

out= line;

2073

2061

}

2074

2062

// Consumed a 2 chars or more, and will add 1 at most,

2097

2085

}

2098

2086

}

2099

2087

}

2100

if (out != line || (buffer->len > 0))

2088

if (out != line || (buffer->length > 0))

2101

2089

{

2102

2090

*out++='\n';

2103

2091

uint length=(uint) (out-line);

2104

2092

if ((!*ml_comment || preserve_comments)

2105

&& (g_string_append_len(buffer, line, length) == NULL))

2093

&& dynstr_append_mem(buffer, line, length))

2106

2094

return(1);

2107

2095

}

2108

2096

return(0);

2113

2101

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

2114

2102

2115

2103

2104

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

2116

2105

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

2117

extern char **new_mysql_completion (const char *text, int start, int end);

2118

2106

2119

2107

2120

2108

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

2121

2109

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

2122

2110

if not.

2123

2111

2124

2125

#if defined(USE_NEW_READLINE_INTERFACE) || defined(USE_LIBEDIT_INTERFACE)

2126

extern char *no_completion(const char*,int);

2127

#else

2128

char *no_completion(void);

2129

char *no_completion(void)

2112

static char *no_completion(const char * a __attribute__((unused)),

2113

int b __attribute__((unused)))

2130

2114

{

2131

2115

/* No filename completion */

2132

2116

return 0;

2133

2117

}

2134

#endif

2118

2135

2119

2136

2120

/* glues pieces of history back together if in pieces */

2137

static void fix_history(GString *final_command)

2121

static void fix_history(DYNAMIC_STRING *final_command)

2138

2122

{

2139

2123

int total_lines = 1;

2140

2124

const char *ptr = final_command->str;

2125

char str_char = '\0'; /* Character if we are in a string or not */

2126

2141

2127

/* Converted buffer */

2142

GString * fixed_buffer;

2143

fixed_buffer = g_string_sized_new(16);

2144

char str_char = '\0'; /* Character if we are in a string or not */

2128

DYNAMIC_STRING *fixed_buffer=

2129

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

2130

2131

init_dynamic_string(fixed_buffer, "", 512, 512);

2145

2132

2146

2133

/* find out how many lines we have and remove newlines */

2147

2134

while (*ptr != '\0')

2156

2143

str_char = *ptr;

2157

2144

else if (str_char == *ptr) /* close string */

2158

2145

str_char = '\0';

2159

g_string_append_len(fixed_buffer, ptr, 1);

2146

dynstr_append_mem(fixed_buffer, ptr, 1);

2160

2147

break;

2161

2148

case '\n':

2162

2149

2163

2150

not in string, change to space

2164

2151

if in string, leave it alone

2165

2152

2166

g_string_append(fixed_buffer,(str_char == '\0') ? " " : "\n");

2153

dynstr_append(fixed_buffer,(str_char == '\0') ? " " : "\n");

2167

2154

total_lines++;

2168

2155

break;

2169

2156

case '\\':

2170

g_string_append_c(fixed_buffer, '\\');

2157

dynstr_append(fixed_buffer, "\\");

2171

2158

/* need to see if the backslash is escaping anything */

2172

2159

if (str_char)

2173

2160

{

2174

2161

ptr++;

2175

2162

/* special characters that need escaping */

2176

2163

if (*ptr == '\'' || *ptr == '"' || *ptr == '\\')

2177

g_string_append_len(fixed_buffer, ptr, 1);

2164

dynstr_append_mem(fixed_buffer, ptr, 1);

2178

2165

else

2179

2166

ptr--;

2180

2167

}

2181

2168

break;

2182

2169

default:

2183

g_string_append_len(fixed_buffer, ptr, 1);

2170

dynstr_append_mem(fixed_buffer, ptr, 1);

2184

2171

}

2185

2172

ptr++;

2186

2173

}

2206

2193

static void initialize_readline (const char *name)

2207

2194

{

2208

2195

/* Allow conditional parsing of the ~/.inputrc file. */

2209

rl_readline_name= name;

2196

rl_readline_name= (char *)name;

2210

2197

2211

2198

/* Tell the completer that we want a crack first. */

2212

rl_attempted_completion_function= (rl_completion_func_t*)&new_mysql_completion;

2213

rl_completion_entry_function= (rl_compentry_func_t*)&no_completion;

2199

rl_attempted_completion_function= (typeof rl_attempted_completion_function)&new_mysql_completion;

2200

rl_completion_entry_function= (typeof rl_completion_entry_function)&no_completion;

2214

2201

}

2215

2202

2203

2216

2204

2217

2205

Attempt to complete on the contents of TEXT. START and END show the

2218

2206

region of TEXT that contains the word to complete. We can use the

2219

2207

entire line in case we want to do some simple parsing. Return the

2220

2208

array of matches, or NULL if there aren't any.

2221

2209

2222

2223

char **new_mysql_completion (const char *text,

2224

int start __attribute__((unused)),

2225

int end __attribute__((unused)))

2210

char **mysql_completion (const char *text,

2211

int start __attribute__((unused)),

2212

int end __attribute__((unused)))

2226

2213

{

2227

2214

if (!status.batch && !quick)

2215

#ifdef HAVE_DECL_COMPLETION_MATCHES

2216

return completion_matches(text, new_command_generator);

2217

#else

2228

2218

return rl_completion_matches(text, new_command_generator);

2219

#endif

2229

2220

else

2230

2221

return (char**) 0;

2231

2222

}

2232

2223

2224

2233

2225

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

2234

2226

{

2235

2227

static int textlen;

2242

2234

textlen=(uint) strlen(text);

2243

2235

2244

2236

if (textlen>0)

2245

{ /* lookup in the hash */

2237

{ /* lookup in the hash */

2246

2238

if (!state)

2247

2239

{

2248

2240

uint len;

2255

2247

2256

2248

if (e)

2257

2249

{

2258

ptr= g_strdup(e->str);

2250

ptr= strdup(e->str);

2259

2251

e = e->pNext;

2260

2252

return ptr;

2261

2253

}

2278

2270

}

2279

2271

ptr= NullS;

2280

2272

while (e && !ptr)

2281

{ /* find valid entry in bucket */

2273

{ /* find valid entry in bucket */

2282

2274

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

2283

ptr = g_strdup(e->str);

2275

ptr = strdup(e->str);

2284

2276

/* find the next used entry */

2285

2277

e = e->pNext;

2286

2278

if (!e)

2314

2306

static void build_completion_hash(bool rehash, bool write_info)

2315

2307

{

2316

2308

COMMANDS *cmd=commands;

2317

MYSQL_RES *databases=0,*tables=0;

2318

MYSQL_RES *fields;

2309

DRIZZLE_RES *databases=0,*tables=0;

2310

DRIZZLE_RES *fields;

2319

2311

static char ***field_names= 0;

2320

MYSQL_ROW database_row,table_row;

2321

MYSQL_FIELD *sql_field;

2322

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

2312

DRIZZLE_ROW database_row,table_row;

2313

DRIZZLE_FIELD *sql_field;

2314

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

2323

2315

int i,j,num_fields;

2324

2316

2325

2317

2326

2318

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

2327

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

2319

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

2328

2320

if (!rehash)

2329

2321

return;

2330

2322

2343

2335

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

2344

2336

2345

2337

/* hash all database names */

2346

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

2338

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

2347

2339

{

2348

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

2349

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

2340

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

2341

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

2350

2342

else

2351

2343

{

2352

while ((database_row=mysql_fetch_row(databases)))

2344

while ((database_row=drizzle_fetch_row(databases)))

2353

2345

{

2354

2346

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

2355

2347

if (str)

2356

2348

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

2357

2349

}

2358

mysql_free_result(databases);

2350

drizzle_free_result(databases);

2359

2351

}

2360

2352

}

2361

2353

/* hash all table names */

2362

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

2354

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

2363

2355

{

2364

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

2365

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

2356

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

2357

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

2366

2358

else

2367

2359

{

2368

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

2360

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

2369

2361

{

2370

2362

tee_fprintf(stdout, "\

2371

2363

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

2372

2364

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

2373

2365

}

2374

while ((table_row=mysql_fetch_row(tables)))

2366

while ((table_row=drizzle_fetch_row(tables)))

2375

2367

{

2376

2368

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

2377

2369

if (str &&

2382

2374

}

2383

2375

2384

2376

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

2385

if (!tables) /* no tables */

2377

if (!tables) /* no tables */

2386

2378

{

2387

2379

return;

2388

2380

}

2389

mysql_data_seek(tables,0);

2381

drizzle_data_seek(tables,0);

2390

2382

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

2391

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

2383

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

2392

2384

{

2393

mysql_free_result(tables);

2385

drizzle_free_result(tables);

2394

2386

return;

2395

2387

}

2396

2388

i=0;

2397

while ((table_row=mysql_fetch_row(tables)))

2389

while ((table_row=drizzle_fetch_row(tables)))

2398

2390

{

2399

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

2391

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

2400

2392

{

2401

num_fields=mysql_num_fields(fields);

2393

num_fields=drizzle_num_fields(fields);

2402

2394

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

2403

2395

sizeof(char *) *

2404

2396

(num_fields*2+1))))

2405

2397

{

2406

mysql_free_result(fields);

2398

drizzle_free_result(fields);

2407

2399

break;

2408

2400

}

2409

2401

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

2410

2402

j=0;

2411

while ((sql_field=mysql_fetch_field(fields)))

2403

while ((sql_field=drizzle_fetch_field(fields)))

2412

2404

{

2413

2405

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

2414

2406

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

2420

2412

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

2421

2413

j++;

2422

2414

}

2423

mysql_free_result(fields);

2415

drizzle_free_result(fields);

2424

2416

}

2425

2417

else

2426

2418

field_names[i]= 0;

2427

2419

2428

2420

i++;

2429

2421

}

2430

mysql_free_result(tables);

2431

field_names[i]=0; // End pointer

2422

drizzle_free_result(tables);

2423

field_names[i]=0; // End pointer

2432

2424

return;

2433

2425

}

2434

2426

2465

2457

if (opt_reconnect)

2466

2458

{

2467

2459

put_info("No connection. Trying to reconnect...",INFO_INFO,0,0);

2468

(void) com_connect((GString *) 0, 0);

2460

(void) com_connect((DYNAMIC_STRING *) 0, 0);

2469

2461

if (opt_rehash)

2470

2462

com_rehash(NULL, NULL);

2471

2463

}

2477

2469

2478

2470

static void get_current_db(void)

2479

2471

{

2480

MYSQL_RES *res;

2472

DRIZZLE_RES *res;

2481

2473

2482

2474

my_free(current_db, MYF(MY_ALLOW_ZERO_PTR));

2483

2475

current_db= NULL;

2484

2476

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

2485

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

2486

(res= mysql_use_result(&mysql)))

2477

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

2478

(res= drizzle_use_result(&drizzle)))

2487

2479

{

2488

MYSQL_ROW row= mysql_fetch_row(res);

2480

DRIZZLE_ROW row= drizzle_fetch_row(res);

2489

2481

if (row[0])

2490

current_db= g_strdup(row[0]);

2491

mysql_free_result(res);

2482

current_db= strdup(row[0]);

2483

drizzle_free_result(res);

2492

2484

}

2493

2485

}

2494

2486

2496

2488

The different commands

2497

2489

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

2498

2490

2499

int mysql_real_query_for_lazy(const char *buf, int length)

2491

int drizzle_real_query_for_lazy(const char *buf, int length)

2500

2492

{

2501

2493

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

2502

2494

{

2503

2495

int error;

2504

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

2496

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

2505

2497

return 0;

2506

error= put_error(&mysql);

2507

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

2498

error= put_error(&drizzle);

2499

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

2508

2500

!opt_reconnect)

2509

2501

return error;

2510

2502

if (reconnect())

2512

2504

}

2513

2505

}

2514

2506

2515

int mysql_store_result_for_lazy(MYSQL_RES **result)

2507

int drizzle_store_result_for_lazy(DRIZZLE_RES **result)

2516

2508

{

2517

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

2509

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

2518

2510

return 0;

2519

2511

2520

if (mysql_error(&mysql)[0])

2521

return put_error(&mysql);

2512

if (drizzle_error(&drizzle)[0])

2513

return put_error(&drizzle);

2522

2514

return 0;

2523

2515

}

2524

2516

2525

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

2517

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

2526

2518

{

2527

2519

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

2528

2520

if (*last_char != ccat)

2534

2526

}

2535

2527

2536

2528

2537

static int com_server_help(GString *buffer,

2529

static int com_server_help(DYNAMIC_STRING *buffer,

2538

2530

char *line __attribute__((unused)),

2539

2531

char *help_arg)

2540

2532

{

2541

MYSQL_ROW cur;

2533

DRIZZLE_ROW cur;

2542

2534

const char *server_cmd= buffer->str;

2543

2535

char cmd_buf[100];

2544

MYSQL_RES *result;

2536

DRIZZLE_RES *result;

2545

2537

int error;

2546

2538

2547

2539

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

2560

2552

if (!connected && reconnect())

2561

2553

return 1;

2562

2554

2563

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

2564

(error= mysql_store_result_for_lazy(&result)))

2555

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

2556

(error= drizzle_store_result_for_lazy(&result)))

2565

2557

return error;

2566

2558

2567

2559

if (result)

2568

2560

{

2569

unsigned int num_fields= mysql_num_fields(result);

2570

uint64_t num_rows= mysql_num_rows(result);

2571

mysql_fetch_fields(result);

2561

unsigned int num_fields= drizzle_num_fields(result);

2562

uint64_t num_rows= drizzle_num_rows(result);

2563

drizzle_fetch_fields(result);

2572

2564

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

2573

2565

{

2574

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

2566

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

2575

2567

{

2576

2568

error= -1;

2577

2569

goto err;

2599

2591

num_name= 0;

2600

2592

num_cat= 1;

2601

2593

}

2602

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

2594

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

2603

2595

{

2604

2596

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

2605

2597

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

2608

2600

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

2609

2601

}

2610

2602

2611

while ((cur= mysql_fetch_row(result)))

2603

while ((cur= drizzle_fetch_row(result)))

2612

2604

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

2613

2605

tee_fprintf(PAGER, "\n");

2614

2606

end_pager();

2621

2613

}

2622

2614

2623

2615

err:

2624

mysql_free_result(result);

2616

drizzle_free_result(result);

2625

2617

return error;

2626

2618

}

2627

2619

2628

2620

static int

2629

com_help(GString *buffer __attribute__((unused)),

2621

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

2630

2622

char *line __attribute__((unused)))

2631

2623

{

2632

2624

2651

2643

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

2652

2644

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

2653

2645

}

2654

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

2646

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

2655

2647

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

2656

2648

return 0;

2657

2649

}

2658

2650

2659

2651

2660

2652

static int

2661

com_clear(GString *buffer,char *line __attribute__((unused)))

2653

com_clear(DYNAMIC_STRING *buffer,char *line __attribute__((unused)))

2662

2654

{

2663

2655

if (status.add_to_history)

2664

2656

fix_history(buffer);

2665

g_string_truncate(buffer, 0);

2657

dynstr_set(buffer, NULL);

2666

2658

return 0;

2667

2659

}

2668

2660

2669

2661

static int

2670

com_charset(GString *buffer __attribute__((unused)), char *line)

2662

com_charset(DYNAMIC_STRING *buffer __attribute__((unused)), char *line)

2671

2663

{

2672

2664

char buff[256], *param;

2673

2665

CHARSET_INFO * new_cs;

2682

2674

if (new_cs)

2683

2675

{

2684

2676

charset_info= new_cs;

2685

mysql_set_character_set(&mysql, charset_info->csname);

2677

drizzle_set_character_set(&drizzle, charset_info->csname);

2686

2678

default_charset= (char *)charset_info->csname;

2687

2679

default_charset_used= 1;

2688

2680

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

2698

2690

1 if fatal error

2699

2691

2700

2692

static int

2701

com_go(GString *buffer,

2693

com_go(DYNAMIC_STRING *buffer,

2702

2694

char *line __attribute__((unused)))

2703

2695

{

2704

2696

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

2705

2697

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

2706

MYSQL_RES *result;

2698

DRIZZLE_RES *result;

2707

2699

ulong timer, warnings= 0;

2708

2700

uint error= 0;

2709

2701

int err= 0;

2713

2705

/* Remove garbage for nicer messages */

2714

2706

remove_cntrl(buffer);

2715

2707

2716

if (buffer->len == 0)

2708

if (buffer->length == 0)

2717

2709

{

2718

2710

// Ignore empty quries

2719

2711

if (status.batch)

2724

2716

if (!connected && reconnect())

2725

2717

{

2726

2718

// Remove query on error

2727

g_string_truncate(buffer, 0);

2719

dynstr_set(buffer, NULL);

2728

2720

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

2729

2721

}

2730

2722

if (verbose)

2731

2723

(void) com_print(buffer, 0);

2732

2724

2733

2725

if (skip_updates &&

2734

((buffer->len < 4)

2735

|| g_string_equal(g_string_new_len(buffer->str,4),

2736

g_string_new("SET "))))

2726

((buffer->length < 4) || !strncmp(buffer->str, "SET ", 4)))

2737

2727

{

2738

2728

(void) put_info("Ignoring query to other database",INFO_INFO,0,0);

2739

2729

return 0;

2741

2731

2742

2732

timer=start_timer();

2743

2733

executing_query= 1;

2744

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

2734

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

2745

2735

2746

2736

if (status.add_to_history)

2747

2737

{

2748

g_string_append(buffer, vertical ? "\\G" : delimiter);

2738

dynstr_append(buffer, vertical ? "\\G" : delimiter);

2749

2739

/* Append final command onto history */

2750

2740

fix_history(buffer);

2751

2741

}

2752

2742

2753

g_string_truncate(buffer, 0);

2743

dynstr_set(buffer, NULL);

2754

2744

2755

2745

if (error)

2756

2746

goto end;

2761

2751

2762

2752

if (quick)

2763

2753

{

2764

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

2754

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

2765

2755

{

2766

error= put_error(&mysql);

2756

error= put_error(&drizzle);

2767

2757

goto end;

2768

2758

}

2769

2759

}

2770

2760

else

2771

2761

{

2772

error= mysql_store_result_for_lazy(&result);

2762

error= drizzle_store_result_for_lazy(&result);

2773

2763

if (error)

2774

2764

goto end;

2775

2765

}

2776

2766

2777

2767

if (verbose >= 3 || !opt_silent)

2778

mysql_end_timer(timer,time_buff);

2768

drizzle_end_timer(timer,time_buff);

2779

2769

else

2780

2770

time_buff[0]= '\0';

2781

2771

2782

2772

/* Every branch must truncate buff . */

2783

2773

if (result)

2784

2774

{

2785

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

2775

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

2786

2776

{

2787

2777

strmov(buff, "Empty set");

2788

2778

if (opt_xml)

2811

2801

else

2812

2802

print_table_data(result);

2813

2803

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

2814

(long) mysql_num_rows(result),

2815

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

2804

(long) drizzle_num_rows(result),

2805

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

2816

2806

end_pager();

2817

if (mysql_errno(&mysql))

2818

error= put_error(&mysql);

2807

if (drizzle_errno(&drizzle))

2808

error= put_error(&drizzle);

2819

2809

}

2820

2810

}

2821

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

2811

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

2822

2812

strmov(buff,"Query OK");

2823

2813

else

2824

2814

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

2825

(long) mysql_affected_rows(&mysql),

2826

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

2815

(long) drizzle_affected_rows(&drizzle),

2816

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

2827

2817

2828

2818

pos=strend(buff);

2829

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

2819

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

2830

2820

{

2831

2821

*pos++= ',';

2832

2822

*pos++= ' ';

2837

2827

}

2838

2828

strmov(pos, time_buff);

2839

2829

put_info(buff,INFO_RESULT,0,0);

2840

if (mysql_info(&mysql))

2841

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

2842

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

2830

if (drizzle_info(&drizzle))

2831

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

2832

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

2843

2833

2844

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

2845

error= put_error(&mysql);

2834

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

2835

error= put_error(&drizzle);

2846

2836

else if (unbuffered)

2847

2837

fflush(stdout);

2848

mysql_free_result(result);

2849

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

2838

drizzle_free_result(result);

2839

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

2850

2840

if (err >= 1)

2851

error= put_error(&mysql);

2841

error= put_error(&drizzle);

2852

2842

2853

2843

end:

2854

2844

2857

2847

print_warnings();

2858

2848

2859

2849

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

2860

(mysql.server_status & SERVER_STATUS_DB_DROPPED))

2850

(drizzle.server_status & SERVER_STATUS_DB_DROPPED))

2861

2851

get_current_db();

2862

2852

2863

2853

executing_query= 0;

2864

return error; /* New command follows */

2854

return error; /* New command follows */

2865

2855

}

2866

2856

2867

2857

2914

2904

2915

2905

2916

2906

static int

2917

com_ego(GString *buffer,char *line)

2907

com_ego(DYNAMIC_STRING *buffer,char *line)

2918

2908

{

2919

2909

int result;

2920

2910

bool oldvertical=vertical;

2928

2918

static const char *fieldtype2str(enum enum_field_types type)

2929

2919

{

2930

2920

switch (type) {

2931

case MYSQL_TYPE_BLOB: return "BLOB";

2932

case MYSQL_TYPE_NEWDATE: return "DATE";

2933

case MYSQL_TYPE_DATETIME: return "DATETIME";

2934

case MYSQL_TYPE_NEWDECIMAL: return "DECIMAL";

2935

case MYSQL_TYPE_DOUBLE: return "DOUBLE";

2936

case MYSQL_TYPE_ENUM: return "ENUM";

2937

case MYSQL_TYPE_LONG: return "LONG";

2938

case MYSQL_TYPE_LONGLONG: return "LONGLONG";

2939

case MYSQL_TYPE_NULL: return "NULL";

2940

case MYSQL_TYPE_SET: return "SET";

2941

case MYSQL_TYPE_SHORT: return "SHORT";

2942

case MYSQL_TYPE_STRING: return "STRING";

2943

case MYSQL_TYPE_TIME: return "TIME";

2944

case MYSQL_TYPE_TIMESTAMP: return "TIMESTAMP";

2945

case MYSQL_TYPE_TINY: return "TINY";

2946

case MYSQL_TYPE_VAR_STRING: return "VAR_STRING";

2947

case MYSQL_TYPE_YEAR: return "YEAR";

2921

case DRIZZLE_TYPE_BLOB: return "BLOB";

2922

case DRIZZLE_TYPE_NEWDATE: return "DATE";

2923

case DRIZZLE_TYPE_DATETIME: return "DATETIME";

2924

case DRIZZLE_TYPE_NEWDECIMAL: return "DECIMAL";

2925

case DRIZZLE_TYPE_DOUBLE: return "DOUBLE";

2926

case DRIZZLE_TYPE_ENUM: return "ENUM";

2927

case DRIZZLE_TYPE_LONG: return "LONG";

2928

case DRIZZLE_TYPE_LONGLONG: return "LONGLONG";

2929

case DRIZZLE_TYPE_NULL: return "NULL";

2930

case DRIZZLE_TYPE_SET: return "SET";

2931

case DRIZZLE_TYPE_SHORT: return "SHORT";

2932

case DRIZZLE_TYPE_STRING: return "STRING";

2933

case DRIZZLE_TYPE_TIME: return "TIME";

2934

case DRIZZLE_TYPE_TIMESTAMP: return "TIMESTAMP";

2935

case DRIZZLE_TYPE_TINY: return "TINY";

2936

case DRIZZLE_TYPE_VAR_STRING: return "VAR_STRING";

2948

2937

default: return "?-unknown-?";

2949

2938

}

2950

2939

}

2961

2950

ff2s_check_flag(MULTIPLE_KEY);

2962

2951

ff2s_check_flag(BLOB);

2963

2952

ff2s_check_flag(UNSIGNED);

2964

ff2s_check_flag(ZEROFILL);

2965

2953

ff2s_check_flag(BINARY);

2966

2954

ff2s_check_flag(ENUM);

2967

2955

ff2s_check_flag(AUTO_INCREMENT);

2981

2969

}

2982

2970

2983

2971

static void

2984

print_field_types(MYSQL_RES *result)

2972

print_field_types(DRIZZLE_RES *result)

2985

2973

{

2986

MYSQL_FIELD *field;

2974

DRIZZLE_FIELD *field;

2987

2975

uint i=0;

2988

2976

2989

while ((field = mysql_fetch_field(result)))

2977

while ((field = drizzle_fetch_field(result)))

2990

2978

{

2991

2979

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

2992

2980

"Catalog: `%s`\n"

3011

2999

3012

3000

3013

3001

static void

3014

print_table_data(MYSQL_RES *result)

3002

print_table_data(DRIZZLE_RES *result)

3015

3003

{

3016

GString *separator = g_string_sized_new(256);

3017

MYSQL_ROW cur;

3018

MYSQL_FIELD *field;

3004

DRIZZLE_ROW cur;

3005

DRIZZLE_FIELD *field;

3019

3006

bool *num_flag;

3007

DYNAMIC_STRING *separator=

3008

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

3009

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

3020

3010

3021

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

3011

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

3022

3012

MYF(MY_WME));

3023

3013

if (column_types_flag)

3024

3014

{

3025

3015

print_field_types(result);

3026

if (!mysql_num_rows(result))

3016

if (!drizzle_num_rows(result))

3027

3017

return;

3028

mysql_field_seek(result,0);

3018

drizzle_field_seek(result,0);

3029

3019

}

3030

separator = g_string_append_c(separator, '+');

3031

while ((field = mysql_fetch_field(result)))

3020

dynstr_append(separator, "+");

3021

while ((field = drizzle_fetch_field(result)))

3032

3022

{

3033

3023

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

3034

3024

if (quick)

3041

3031

field->max_length=length;

3042

3032

uint x;

3043

3033

for (x=0; x< (length+2); x++)

3044

g_string_append_c(separator, '-');

3045

g_string_append_c(separator, '+');

3034

dynstr_append(separator, "-");

3035

dynstr_append(separator, "+");

3046

3036

}

3047

// End marker for \0

3048

// TODO: Huh? Do we need this with GString?

3049

g_string_append_c(separator, '\0');

3050

3037

3051

3038

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

3052

3039

if (column_names)

3053

3040

{

3054

mysql_field_seek(result,0);

3041

drizzle_field_seek(result,0);

3055

3042

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

3056

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

3043

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

3057

3044

{

3058

3045

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

3059

3046

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

3069

3056

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

3070

3057

}

3071

3058

3072

while ((cur= mysql_fetch_row(result)))

3059

while ((cur= drizzle_fetch_row(result)))

3073

3060

{

3074

3061

if (interrupted_query)

3075

3062

break;

3076

uint32_t *lengths= mysql_fetch_lengths(result);

3063

uint32_t *lengths= drizzle_fetch_lengths(result);

3077

3064

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

3078

mysql_field_seek(result, 0);

3079

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

3065

drizzle_field_seek(result, 0);

3066

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

3080

3067

{

3081

3068

const char *buffer;

3082

3069

uint data_length;

3095

3082

data_length= (uint) lengths[off];

3096

3083

}

3097

3084

3098

field= mysql_fetch_field(result);

3085

field= drizzle_fetch_field(result);

3099

3086

field_max_length= field->max_length;

3100

3087

3101

3088

3143

3130

3144

3131

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

3145

3132

3146

static int get_field_disp_length(MYSQL_FIELD *field)

3133

static int get_field_disp_length(DRIZZLE_FIELD *field)

3147

3134

{

3148

3135

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

3149

3136

3153

3140

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

3154

3141

3155

3142

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

3156

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

3143

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

3157

3144

3158

3145

return length;

3159

3146

}

3166

3153

3167

3154

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

3168

3155

3169

static int get_result_width(MYSQL_RES *result)

3156

static int get_result_width(DRIZZLE_RES *result)

3170

3157

{

3171

3158

unsigned int len= 0;

3172

MYSQL_FIELD *field;

3173

MYSQL_FIELD_OFFSET offset;

3159

DRIZZLE_FIELD *field;

3160

DRIZZLE_FIELD_OFFSET offset;

3174

3161

3175

offset= mysql_field_tell(result);

3162

offset= drizzle_field_tell(result);

3176

3163

assert(offset == 0);

3177

3164

3178

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

3165

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

3179

3166

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

3180

3167

3181

(void) mysql_field_seek(result, offset);

3168

(void) drizzle_field_seek(result, offset);

3182

3169

3183

3170

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

3184

3171

}

3214

3201

3215

3202

3216

3203

static void

3217

print_table_data_html(MYSQL_RES *result)

3204

print_table_data_html(DRIZZLE_RES *result)

3218

3205

{

3219

MYSQL_ROW cur;

3220

MYSQL_FIELD *field;

3206

DRIZZLE_ROW cur;

3207

DRIZZLE_FIELD *field;

3221

3208

3222

mysql_field_seek(result,0);

3209

drizzle_field_seek(result,0);

3223

3210

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

3224

3211

if (column_names)

3225

3212

{

3226

while((field = mysql_fetch_field(result)))

3213

while((field = drizzle_fetch_field(result)))

3227

3214

{

3228

3215

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

3229

3216

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

3231

3218

}

3232

3219

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

3233

3220

}

3234

while ((cur = mysql_fetch_row(result)))

3221

while ((cur = drizzle_fetch_row(result)))

3235

3222

{

3236

3223

if (interrupted_query)

3237

3224

break;

3238

uint32_t *lengths=mysql_fetch_lengths(result);

3225

uint32_t *lengths=drizzle_fetch_lengths(result);

3239

3226

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

3240

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

3227

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

3241

3228

{

3242

3229

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

3243

3230

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

3250

3237

3251

3238

3252

3239

static void

3253

print_table_data_xml(MYSQL_RES *result)

3240

print_table_data_xml(DRIZZLE_RES *result)

3254

3241

{

3255

MYSQL_ROW cur;

3256

MYSQL_FIELD *fields;

3242

DRIZZLE_ROW cur;

3243

DRIZZLE_FIELD *fields;

3257

3244

3258

mysql_field_seek(result,0);

3245

drizzle_field_seek(result,0);

3259

3246

3260

3247

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

3261

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

3248

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

3262

3249

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

3263

3250

PAGER);

3264

3251

3265

fields = mysql_fetch_fields(result);

3266

while ((cur = mysql_fetch_row(result)))

3252

fields = drizzle_fetch_fields(result);

3253

while ((cur = drizzle_fetch_row(result)))

3267

3254

{

3268

3255

if (interrupted_query)

3269

3256

break;

3270

uint32_t *lengths=mysql_fetch_lengths(result);

3257

uint32_t *lengths=drizzle_fetch_lengths(result);

3271

3258

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

3272

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

3259

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

3273

3260

{

3274

3261

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

3275

3262

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

3289

3276

3290

3277

3291

3278

static void

3292

print_table_data_vertically(MYSQL_RES *result)

3279

print_table_data_vertically(DRIZZLE_RES *result)

3293

3280

{

3294

MYSQL_ROW cur;

3295

uint max_length=0;

3296

MYSQL_FIELD *field;

3281

DRIZZLE_ROW cur;

3282

uint max_length=0;

3283

DRIZZLE_FIELD *field;

3297

3284

3298

while ((field = mysql_fetch_field(result)))

3285

while ((field = drizzle_fetch_field(result)))

3299

3286

{

3300

3287

uint length= field->name_length;

3301

3288

if (length > max_length)

3303

3290

field->max_length=length;

3304

3291

}

3305

3292

3306

mysql_field_seek(result,0);

3307

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

3293

drizzle_field_seek(result,0);

3294

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

3308

3295

{

3309

3296

if (interrupted_query)

3310

3297

break;

3311

mysql_field_seek(result,0);

3298

drizzle_field_seek(result,0);

3312

3299

tee_fprintf(PAGER,

3313

3300

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

3314

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

3301

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

3315

3302

{

3316

field= mysql_fetch_field(result);

3303

field= drizzle_fetch_field(result);

3317

3304

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

3318

3305

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

3319

3306

}

3326

3313

static void print_warnings()

3327

3314

{

3328

3315

const char *query;

3329

MYSQL_RES *result;

3330

MYSQL_ROW cur;

3316

DRIZZLE_RES *result;

3317

DRIZZLE_ROW cur;

3331

3318

uint64_t num_rows;

3332

3319

3333

3320

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

3334

uint error= mysql_errno(&mysql);

3321

uint error= drizzle_errno(&drizzle);

3335

3322

3336

3323

/* Get the warnings */

3337

3324

query= "show warnings";

3338

mysql_real_query_for_lazy(query, strlen(query));

3339

mysql_store_result_for_lazy(&result);

3325

drizzle_real_query_for_lazy(query, strlen(query));

3326

drizzle_store_result_for_lazy(&result);

3340

3327

3341

3328

/* Bail out when no warnings */

3342

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

3329

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

3343

3330

goto end;

3344

3331

3345

cur= mysql_fetch_row(result);

3332

cur= drizzle_fetch_row(result);

3346

3333

3347

3334

3348

3335

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

3358

3345

3359

3346

{

3360

3347

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

3361

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

3348

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

3362

3349

end_pager();

3363

3350

3364

3351

end:

3365

mysql_free_result(result);

3352

drizzle_free_result(result);

3366

3353

}

3367

3354

3368

3355

3432

3419

3433

3420

3434

3421

static void

3435

print_tab_data(MYSQL_RES *result)

3422

print_tab_data(DRIZZLE_RES *result)

3436

3423

{

3437

MYSQL_ROW cur;

3438

MYSQL_FIELD *field;

3439

uint32_t *lengths;

3424

DRIZZLE_ROW cur;

3425

DRIZZLE_FIELD *field;

3426

uint32_t *lengths;

3440

3427

3441

3428

if (opt_silent < 2 && column_names)

3442

3429

{

3443

3430

int first=0;

3444

while ((field = mysql_fetch_field(result)))

3431

while ((field = drizzle_fetch_field(result)))

3445

3432

{

3446

3433

if (first++)

3447

3434

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

3449

3436

}

3450

3437

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

3451

3438

}

3452

while ((cur = mysql_fetch_row(result)))

3439

while ((cur = drizzle_fetch_row(result)))

3453

3440

{

3454

lengths= mysql_fetch_lengths(result);

3441

lengths= drizzle_fetch_lengths(result);

3455

3442

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

3456

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

3443

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

3457

3444

{

3458

3445

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

3459

3446

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

3463

3450

}

3464

3451

3465

3452

static int

3466

com_tee(GString *buffer __attribute__((__unused__)), char *line )

3453

com_tee(DYNAMIC_STRING *buffer __attribute__((unused)), char *line )

3467

3454

{

3468

3455

char file_name[FN_REFLEN], *end, *param;

3469

3456

3484

3471

return 0;

3485

3472

}

3486

3473

else

3487

param = outfile; //resume using the old outfile

3474

param = outfile; //resume using the old outfile

3488

3475

}

3489

3476

3490

3477

/* eliminate the spaces before the parameters */

3507

3494

3508

3495

3509

3496

static int

3510

com_notee(GString *buffer __attribute__((unused)),

3497

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

3511

3498

char *line __attribute__((unused)))

3512

3499

{

3513

3500

if (opt_outfile)

3521

3508

3522

3509

3523

3510

static int

3524

com_pager(GString *buffer __attribute__((__unused__)),

3511

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

3525

3512

char *line __attribute__((unused)))

3526

3513

{

3527

3514

char pager_name[FN_REFLEN], *end, *param;

3565

3552

3566

3553

3567

3554

static int

3568

com_nopager(GString *buffer __attribute__((unused)),

3555

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

3569

3556

char *line __attribute__((unused)))

3570

3557

{

3571

3558

strmov(pager, "stdout");

3578

3565

/* If arg is given, exit without errors. This happens on command 'quit' */

3579

3566

3580

3567

static int

3581

com_quit(GString *buffer __attribute__((unused)),

3568

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

3582

3569

char *line __attribute__((unused)))

3583

3570

{

3584

3571

/* let the screen auto close on a normal shutdown */

3587

3574

}

3588

3575

3589

3576

static int

3590

com_rehash(GString *buffer __attribute__((unused)),

3577

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

3591

3578

char *line __attribute__((unused)))

3592

3579

{

3593

3580

build_completion_hash(1, 0);

3597

3584

3598

3585

3599

3586

static int

3600

com_print(GString *buffer,char *line __attribute__((unused)))

3587

com_print(DYNAMIC_STRING *buffer,char *line __attribute__((unused)))

3601

3588

{

3602

3589

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

3603

3590

(void) tee_fputs(buffer->str, stdout);

3604

if ( (buffer->len == 0)

3605

|| (buffer->str)[(buffer->len)-1] != '\n')

3591

if ( (buffer->length == 0)

3592

|| (buffer->str)[(buffer->length)-1] != '\n')

3606

3593

tee_putc('\n', stdout);

3607

3594

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

3608

3595

/* If empty buffer */

3611

3598

3612

3599

/* ARGSUSED */

3613

3600

static int

3614

com_connect(GString *buffer, char *line)

3601

com_connect(DYNAMIC_STRING *buffer, char *line)

3615

3602

{

3616

3603

char *tmp, buff[256];

3617

3604

bool save_rehash= opt_rehash;

3618

3605

int error;

3619

3606

3620

bzero(buff, sizeof(buff));

3607

memset(buff, 0, sizeof(buff));

3621

3608

if (buffer)

3622

3609

{

3623

3610

3632

3619

if (tmp && *tmp)

3633

3620

{

3634

3621

my_free(current_db, MYF(MY_ALLOW_ZERO_PTR));

3635

current_db= g_strdup(tmp);

3622

current_db= strdup(tmp);

3636

3623

tmp= get_arg(buff, 1);

3637

3624

if (tmp)

3638

3625

{

3639

3626

my_free(current_host,MYF(MY_ALLOW_ZERO_PTR));

3640

current_host=g_strdup(tmp);

3627

current_host=strdup(tmp);

3641

3628

}

3642

3629

}

3643

3630

else

3647

3634

}

3648

3635

// command used

3649

3636

assert(buffer!=NULL);

3650

g_string_truncate(buffer, 0);

3637

dynstr_set(buffer, NULL);

3651

3638

}

3652

3639

else

3653

3640

opt_rehash= 0;

3656

3643

3657

3644

if (connected)

3658

3645

{

3659

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

3646

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

3660

3647

put_info(buff,INFO_INFO,0,0);

3661

3648

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

3662

3649

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

3666

3653

}

3667

3654

3668

3655

3669

static int com_source(GString *buffer __attribute__((__unused__)), char *line)

3656

static int com_source(DYNAMIC_STRING *buffer __attribute__((unused)), char *line)

3670

3657

{

3671

3658

char source_name[FN_REFLEN], *end, *param;

3672

3659

LINE_BUFFER *line_buff;

3677

3664

/* Skip space from file name */

3678

3665

while (my_isspace(charset_info,*line))

3679

3666

line++;

3680

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

3667

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

3681

3668

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

3682

3669

INFO_ERROR, 0,0);

3683

3670

while (my_isspace(charset_info,*param))

3704

3691

3705

3692

/* Save old status */

3706

3693

old_status=status;

3707

bfill((char*) &status,sizeof(status),(char) 0);

3694

memset((char*) &status, 0, sizeof(status));

3708

3695

3709

3696

// Run in batch mode

3710

3697

status.batch=old_status.batch;

3712

3699

status.file_name=source_name;

3713

3700

// Empty command buffer

3714

3701

assert(glob_buffer!=NULL);

3715

g_string_truncate(glob_buffer, 0);

3702

dynstr_set(glob_buffer, NULL);

3716

3703

error= read_and_execute(false);

3717

3704

// Continue as before

3718

3705

status=old_status;

3724

3711

3725

3712

/* ARGSUSED */

3726

3713

static int

3727

com_delimiter(GString *buffer __attribute__((unused)), char *line)

3714

com_delimiter(DYNAMIC_STRING *buffer __attribute__((unused)), char *line)

3728

3715

{

3729

3716

char buff[256], *tmp;

3730

3717

3754

3741

3755

3742

/* ARGSUSED */

3756

3743

static int

3757

com_use(GString *buffer __attribute__((unused)), char *line)

3744

com_use(DYNAMIC_STRING *buffer __attribute__((unused)), char *line)

3758

3745

{

3759

3746

char *tmp, buff[FN_REFLEN + 1];

3760

3747

int select_db;

3761

3748

3762

bzero(buff, sizeof(buff));

3749

memset(buff, 0, sizeof(buff));

3763

3750

strmake(buff, line, sizeof(buff) - 1);

3764

3751

tmp= get_arg(buff, 0);

3765

3752

if (!tmp || !*tmp)

3779

3766

if (one_database)

3780

3767

{

3781

3768

skip_updates= 1;

3782

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

3769

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

3783

3770

}

3784

3771

else

3785

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

3772

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

3786

3773

}

3787

3774

else

3788

3775

{

3789

3776

3790

3777

USE to the current db specified.

3791

We do need to send mysql_select_db() to make server

3778

We do need to send drizzle_select_db() to make server

3792

3779

update database level privileges, which might

3793

3780

change since last USE (see bug#10979).

3794

3781

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

3795

3782

3796

3783

skip_updates= 0;

3797

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

3784

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

3798

3785

}

3799

3786

3800

3787

if (select_db)

3805

3792

3806

3793

if (!connected && reconnect())

3807

3794

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

3808

if (mysql_select_db(&mysql,tmp))

3795

if (drizzle_select_db(&drizzle,tmp))

3809

3796

{

3810

if (mysql_errno(&mysql) != CR_SERVER_GONE_ERROR)

3811

return put_error(&mysql);

3797

if (drizzle_errno(&drizzle) != CR_SERVER_GONE_ERROR)

3798

return put_error(&drizzle);

3812

3799

3813

3800

if (reconnect())

3814

3801

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

3815

if (mysql_select_db(&mysql,tmp))

3816

return put_error(&mysql);

3802

if (drizzle_select_db(&drizzle,tmp))

3803

return put_error(&drizzle);

3817

3804

}

3818

3805

my_free(current_db,MYF(MY_ALLOW_ZERO_PTR));

3819

current_db=g_strdup(tmp);

3806

current_db= strdup(tmp);

3820

3807

if (select_db > 1)

3821

3808

build_completion_hash(opt_rehash, 1);

3822

3809

}

3826

3813

}

3827

3814

3828

3815

static int

3829

com_warnings(GString *buffer __attribute__((unused)),

3816

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

3830

3817

char *line __attribute__((unused)))

3831

3818

{

3832

3819

show_warnings = 1;

3835

3822

}

3836

3823

3837

3824

static int

3838

com_nowarnings(GString *buffer __attribute__((unused)),

3825

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

3839

3826

char *line __attribute__((unused)))

3840

3827

{

3841

3828

show_warnings = 0;

3906

3893

3907

3894

3908

3895

static int

3909

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

3896

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

3910

3897

uint silent)

3911

3898

{

3912

3899

if (connected)

3913

3900

{

3914

3901

connected= 0;

3915

mysql_close(&mysql);

3902

drizzle_close(&drizzle);

3916

3903

}

3917

mysql_init(&mysql);

3904

drizzle_create(&drizzle);

3918

3905

if (opt_connect_timeout)

3919

3906

{

3920

3907

uint timeout=opt_connect_timeout;

3921

mysql_options(&mysql,MYSQL_OPT_CONNECT_TIMEOUT,

3908

drizzle_options(&drizzle,DRIZZLE_OPT_CONNECT_TIMEOUT,

3922

3909

(char*) &timeout);

3923

3910

}

3924

3911

if (opt_compress)

3925

mysql_options(&mysql,MYSQL_OPT_COMPRESS,NullS);

3912

drizzle_options(&drizzle,DRIZZLE_OPT_COMPRESS,NullS);

3926

3913

if (opt_secure_auth)

3927

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

3914

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

3928

3915

if (using_opt_local_infile)

3929

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

3916

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

3930

3917

if (opt_protocol)

3931

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

3918

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

3932

3919

if (safe_updates)

3933

3920

{

3934

3921

char init_command[100];

3935

3922

sprintf(init_command,

3936

"SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=%"PRIu32

3923

"SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=%"PRIu32

3937

3924

",SQL_MAX_JOIN_SIZE=%"PRIu32,

3938

select_limit, max_join_size);

3939

mysql_options(&mysql, MYSQL_INIT_COMMAND, init_command);

3925

select_limit, max_join_size);

3926

drizzle_options(&drizzle, DRIZZLE_INIT_COMMAND, init_command);

3940

3927

}

3941

3928

if (default_charset_used)

3942

mysql_options(&mysql, MYSQL_SET_CHARSET_NAME, default_charset);

3943

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

3944

database, opt_mysql_port, opt_mysql_unix_port,

3929

drizzle_options(&drizzle, DRIZZLE_SET_CHARSET_NAME, default_charset);

3930

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

3931

database, opt_drizzle_port, opt_drizzle_unix_port,

3945

3932

connect_flag | CLIENT_MULTI_STATEMENTS))

3946

3933

{

3947

3934

if (!silent ||

3948

(mysql_errno(&mysql) != CR_CONN_HOST_ERROR &&

3949

mysql_errno(&mysql) != CR_CONNECTION_ERROR))

3935

(drizzle_errno(&drizzle) != CR_CONN_HOST_ERROR &&

3936

drizzle_errno(&drizzle) != CR_CONNECTION_ERROR))

3950

3937

{

3951

(void) put_error(&mysql);

3938

(void) put_error(&drizzle);

3952

3939

(void) fflush(stdout);

3953

return ignore_errors ? -1 : 1; // Abort

3940

return ignore_errors ? -1 : 1; // Abort

3954

3941

}

3955

return -1; // Retryable

3942

return -1; // Retryable

3956

3943

}

3957

3944

connected=1;

3958

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

3945

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

3959

3946

build_completion_hash(opt_rehash, 1);

3960

3947

return 0;

3961

3948

}

3962

3949

3963

3950

3964

3951

static int

3965

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

3966

{

3967

bool message=0;

3968

uint count=0;

3969

int error;

3970

for (;;)

3971

{

3972

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

3973

{

3974

if (count)

3975

{

3976

tee_fputs("\n", stderr);

3977

(void) fflush(stderr);

3978

}

3979

return error;

3980

}

3981

if (!wait_flag)

3982

return ignore_errors ? -1 : 1;

3983

if (!message && !silent)

3984

{

3985

message=1;

3986

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

3987

}

3988

(void) sleep(wait_time);

3989

if (!silent)

3990

{

3991

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

3992

count++;

3993

}

3994

}

3995

}

3996

3997

3998

3999

static int

4000

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

3952

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

4001

3953

char *line __attribute__((unused)))

4002

3954

{

4003

3955

const char *status_str;

4004

3956

char buff[40];

4005

3957

uint64_t id;

4006

MYSQL_RES *result;

3958

DRIZZLE_RES *result;

4007

3959

4008

3960

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

4009

usage(1); /* Print version */

3961

usage(1); /* Print version */

4010

3962

if (connected)

4011

3963

{

4012

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

3964

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

4013

3965

4014

3966

Don't remove "limit 1",

4015

3967

it is protection againts SQL_SELECT_LIMIT=0

4016

3968

4017

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

4018

(result=mysql_use_result(&mysql)))

3969

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

3970

(result=drizzle_use_result(&drizzle)))

4019

3971

{

4020

MYSQL_ROW cur=mysql_fetch_row(result);

3972

DRIZZLE_ROW cur=drizzle_fetch_row(result);

4021

3973

if (cur)

4022

3974

{

4023

3975

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

4024

3976

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

4025

3977

}

4026

mysql_free_result(result);

3978

drizzle_free_result(result);

4027

3979

}

4028

3980

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

4029

3981

}

4043

3995

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

4044

3996

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

4045

3997

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

4046

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

4047

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

4048

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

4049

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

3998

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

3999

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

4000

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

4001

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

4050

4002

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

4051

4003

4052

4004

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

4053

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

4054

(result=mysql_use_result(&mysql)))

4005

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

4006

(result=drizzle_use_result(&drizzle)))

4055

4007

{

4056

MYSQL_ROW cur=mysql_fetch_row(result);

4008

DRIZZLE_ROW cur=drizzle_fetch_row(result);

4057

4009

if (cur)

4058

4010

{

4059

4011

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

4061

4013

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

4062

4014

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

4063

4015

}

4064

mysql_free_result(result);

4016

drizzle_free_result(result);

4065

4017

}

4066

4018

else

4067

4019

{

4068

4020

/* Probably pre-4.1 server */

4069

4021

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

4070

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

4022

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

4071

4023

}

4072

4024

4073

#ifndef EMBEDDED_LIBRARY

4074

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

4075

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

4025

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

4026

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

4076

4027

else

4077

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

4078

if (mysql.net.compress)

4028

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

4029

if (drizzle.net.compress)

4079

4030

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

4080

#endif

4081

4031

4082

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

4032

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

4083

4033

{

4084

4034

ulong sec;

4085

4035

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

4088

4038

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

4089

4039

{

4090

4040

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

4091

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

4041

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

4092

4042

while (*status_str == ' ')

4093

4043

status_str++; /* to next info */

4094

4044

tee_putc('\n', stdout);

4112

4062

}

4113

4063

4114

4064

static const char *

4115

server_version_string(MYSQL *con)

4065

server_version_string(DRIZZLE *con)

4116

4066

{

4117

4067

static char buf[MAX_SERVER_VERSION_LENGTH] = "";

4118

4068

4120

4070

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

4121

4071

{

4122

4072

char *bufp = buf;

4123

MYSQL_RES *result;

4073

DRIZZLE_RES *result;

4124

4074

4125

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

4075

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

4126

4076

4127

4077

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

4128

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

4129

(result = mysql_use_result(con)))

4078

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

4079

(result = drizzle_use_result(con)))

4130

4080

{

4131

MYSQL_ROW cur = mysql_fetch_row(result);

4081

DRIZZLE_ROW cur = drizzle_fetch_row(result);

4132

4082

if (cur && cur[0])

4133

4083

{

4134

4084

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

4135

4085

}

4136

mysql_free_result(result);

4086

drizzle_free_result(result);

4137

4087

}

4138

4088

4139

4089

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

4217

4167

4218

4168

4219

4169

static int

4220

put_error(MYSQL *con)

4170

put_error(DRIZZLE *con)

4221

4171

{

4222

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

4223

mysql_sqlstate(con));

4172

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

4173

drizzle_sqlstate(con));

4224

4174

}

4225

4175

4226

4176

4227

static void remove_cntrl(GString *buffer)

4177

static void remove_cntrl(DYNAMIC_STRING *buffer)

4228

4178

{

4229

4179

char *start= buffer->str;

4230

char *end= start + (buffer->len);

4180

char *end= start + (buffer->length);

4231

4181

while (start < end && !my_isgraph(charset_info,end[-1]))

4232

4182

end--;

4233

4183

uint chars_to_truncate = end-start;

4234

if (buffer->len > chars_to_truncate)

4235

g_string_truncate(buffer, chars_to_truncate);

4184

if (buffer->length > chars_to_truncate)

4185

dynstr_trunc(buffer, chars_to_truncate);

4236

4186

}

4237

4187

4238

4188

4280

4230

}

4281

4231

4282

4232

#include <sys/times.h>

4283

#ifdef _SC_CLK_TCK // For mit-pthreads

4233

#ifdef _SC_CLK_TCK // For mit-pthreads

4284

4234

#undef CLOCKS_PER_SEC

4285

4235

#define CLOCKS_PER_SEC (sysconf(_SC_CLK_TCK))

4286

4236

#endif

4293

4243

4294

4244

4295

4245

/**

4296

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

4246

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

4247

duration of time.

4297

4248

4298

4249

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

4299

4250

4335

4286

}

4336

4287

4337

4288

4338

static void mysql_end_timer(ulong start_time,char *buff)

4289

static void drizzle_end_timer(ulong start_time,char *buff)

4339

4290

{

4340

4291

buff[0]=' ';

4341

4292

buff[1]='(';

4347

4298

{

4348

4299

// Erase the old prompt

4349

4300

assert(processed_prompt!=NULL);

4350

g_string_truncate(processed_prompt, 0);

4301

dynstr_set(processed_prompt, NULL);

4351

4302

4352

4303

// Get the date struct

4353

4304

time_t lclock = time(NULL);

4358

4309

{

4359

4310

if (*c != PROMPT_CHAR)

4360

4311

{

4361

g_string_append_c(processed_prompt, c[0]);

4312

dynstr_append_mem(processed_prompt, c, 1);

4362

4313

}

4363

4314

else

4364

4315

{

4375

4326

break;

4376

4327

case 'v':

4377

4328

if (connected)

4378

g_string_append(processed_prompt, mysql_get_server_info(&mysql));

4329

dynstr_append(processed_prompt, drizzle_get_server_info(&drizzle));

4379

4330

else

4380

g_string_append(processed_prompt, "not_connected");

4331

dynstr_append(processed_prompt, "not_connected");

4381

4332

break;

4382

4333

case 'd':

4383

g_string_append(processed_prompt, current_db ? current_db : "(none)");

4334

dynstr_append(processed_prompt, current_db ? current_db : "(none)");

4384

4335

break;

4385

4336

case 'h':

4386

4337

{

4387

4338

const char *prompt;

4388

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

4339

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

4389

4340

if (strstr(prompt, "Localhost"))

4390

g_string_append(processed_prompt, "localhost");

4341

dynstr_append(processed_prompt, "localhost");

4391

4342

else

4392

4343

{

4393

4344

const char *end=strcend(prompt,' ');

4394

g_string_append_len(processed_prompt, prompt, (gssize) (end-prompt));

4345

dynstr_append_mem(processed_prompt, prompt, (end-prompt));

4395

4346

}

4396

4347

break;

4397

4348

}

4399

4350

{

4400

4351

if (!connected)

4401

4352

{

4402

g_string_append(processed_prompt, "not_connected");

4353

dynstr_append(processed_prompt, "not_connected");

4403

4354

break;

4404

4355

}

4405

4356

4406

const char *host_info = mysql_get_host_info(&mysql);

4357

const char *host_info = drizzle_get_host_info(&drizzle);

4407

4358

if (strstr(host_info, "memory"))

4408

4359

{

4409

g_string_append(processed_prompt, mysql.host );

4360

dynstr_append(processed_prompt, drizzle.host);

4410

4361

}

4411

4362

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

4412

!mysql.unix_socket)

4413

add_int_to_prompt(mysql.port);

4363

!drizzle.unix_socket)

4364

add_int_to_prompt(drizzle.port);

4414

4365

else

4415

4366

{

4416

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

4417

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

4367

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

4368

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

4418

4369

}

4419

4370

}

4420

4371

break;

4421

4372

case 'U':

4422

4373

if (!full_username)

4423

4374

init_username();

4424

g_string_append(processed_prompt, full_username ? full_username :

4375

dynstr_append(processed_prompt, full_username ? full_username :

4425

4376

(current_user ? current_user : "(unknown)"));

4426

4377

break;

4427

4378

case 'u':

4428

4379

if (!full_username)

4429

4380

init_username();

4430

g_string_append(processed_prompt, part_username ? part_username :

4381

dynstr_append(processed_prompt, part_username ? part_username :

4431

4382

(current_user ? current_user : "(unknown)"));

4432

4383

break;

4433

4384

case PROMPT_CHAR:

4434

g_string_append_c(processed_prompt, PROMPT_CHAR);

4385

{

4386

char c= PROMPT_CHAR;

4387

dynstr_append_mem(processed_prompt, &c, 1);

4388

}

4435

4389

break;

4436

4390

case 'n':

4437

g_string_append_c(processed_prompt, '\n');

4391

{

4392

char c= '\n';

4393

dynstr_append_mem(processed_prompt, &c, 1);

4394

}

4438

4395

break;

4439

4396

case ' ':

4440

4397

case '_':

4441

g_string_append_c(processed_prompt, ' ');

4398

{

4399

char c= ' ';

4400

dynstr_append_mem(processed_prompt, &c, 1);

4401

}

4442

4402

break;

4443

4403

case 'R':

4444

4404

if (t->tm_hour < 10)

4445

g_string_append_c(processed_prompt, '0');

4405

add_int_to_prompt(0);

4446

4406

add_int_to_prompt(t->tm_hour);

4447

4407

break;

4448

4408

case 'r':

4450

4410

if (getHour == 0)

4451

4411

getHour=12;

4452

4412

if (getHour < 10)

4453

g_string_append_c(processed_prompt, '0');

4413

add_int_to_prompt(0);

4454

4414

add_int_to_prompt(getHour);

4455

4415

break;

4456

4416

case 'm':

4457

4417

if (t->tm_min < 10)

4458

g_string_append_c(processed_prompt, '0');

4418

add_int_to_prompt(0);

4459

4419

add_int_to_prompt(t->tm_min);

4460

4420

break;

4461

4421

case 'y':

4462

4422

getYear = t->tm_year % 100;

4463

4423

if (getYear < 10)

4464

g_string_append_c(processed_prompt, '0');

4424

add_int_to_prompt(0);

4465

4425

add_int_to_prompt(getYear);

4466

4426

break;

4467

4427

case 'Y':

4469

4429

break;

4470

4430

case 'D':

4471

4431

dateTime = ctime(&lclock);

4472

g_string_append(processed_prompt, strtok(dateTime,"\n"));

4432

dynstr_append(processed_prompt, strtok(dateTime,"\n"));

4473

4433

break;

4474

4434

case 's':

4475

4435

if (t->tm_sec < 10)

4476

g_string_append_c(processed_prompt, '0');

4436

add_int_to_prompt(0);

4477

4437

add_int_to_prompt(t->tm_sec);

4478

4438

break;

4479

4439

case 'w':

4480

g_string_append(processed_prompt, (day_names[t->tm_wday]));

4440

dynstr_append(processed_prompt, (day_names[t->tm_wday]));

4481

4441

break;

4482

4442

case 'P':

4483

g_string_append(processed_prompt, t->tm_hour < 12 ? "am" : "pm");

4443

dynstr_append(processed_prompt, t->tm_hour < 12 ? "am" : "pm");

4484

4444

break;

4485

4445

case 'o':

4486

4446

add_int_to_prompt(t->tm_mon+1);

4487

4447

break;

4488

4448

case 'O':

4489

g_string_append(processed_prompt, month_names[t->tm_mon]);

4449

dynstr_append(processed_prompt, month_names[t->tm_mon]);

4490

4450

break;

4491

4451

case '\'':

4492

g_string_append(processed_prompt, "'");

4452

dynstr_append(processed_prompt, "'");

4493

4453

break;

4494

4454

case '"':

4495

g_string_append_c(processed_prompt, '"');

4455

dynstr_append(processed_prompt, "\"");

4496

4456

break;

4497

4457

case 'S':

4498

g_string_append_c(processed_prompt, ';');

4458

dynstr_append(processed_prompt, ";");

4499

4459

break;

4500

4460

case 't':

4501

g_string_append_c(processed_prompt, '\t');

4461

dynstr_append(processed_prompt, "\t");

4502

4462

break;

4503

4463

case 'l':

4504

g_string_append(processed_prompt, delimiter_str);

4464

dynstr_append(processed_prompt, delimiter_str);

4505

4465

break;

4506

4466

default:

4507

g_string_append(processed_prompt, c);

4467

dynstr_append_mem(processed_prompt, c, 1);

4508

4468

}

4509

4469

}

4510

4470

}

4511

// TODO: Is this needed with GString?

4512

g_string_append_c(processed_prompt, '\0');

4513

4471

return processed_prompt->str;

4514

4472

}

4515

4473

4517

4475

static void add_int_to_prompt(int toadd)

4518

4476

{

4519

4477

char buffer[16];

4520

int10_to_str(toadd,buffer,10);

4521

g_string_append(processed_prompt, buffer);

4478

int10_to_str(toadd, buffer, 10);

4479

dynstr_append(processed_prompt, buffer);

4522

4480

}

4523

4481

4524

4482

static void init_username()

4526

4484

my_free(full_username,MYF(MY_ALLOW_ZERO_PTR));

4527

4485

my_free(part_username,MYF(MY_ALLOW_ZERO_PTR));

4528

4486

4529

MYSQL_RES *result;

4530

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

4531

(result=mysql_use_result(&mysql)))

4487

DRIZZLE_RES *result;

4488

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

4489

(result=drizzle_use_result(&drizzle)))

4532

4490

{

4533

MYSQL_ROW cur=mysql_fetch_row(result);

4534

full_username=g_strdup(cur[0]);

4535

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

4536

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

4491

DRIZZLE_ROW cur=drizzle_fetch_row(result);

4492

full_username= strdup(cur[0]);

4493

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

4494

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

4537

4495

}

4538

4496

}

4539

4497

4540

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

4498

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

4499

char *line)

4541

4500

{

4542

4501

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

4543

4502

prompt_counter = 0;

4544

4503

my_free(current_prompt,MYF(MY_ALLOW_ZERO_PTR));

4545

current_prompt=g_strdup(ptr ? ptr+1 : default_prompt->str);

4504

current_prompt= strdup(ptr ? ptr+1 : default_prompt);

4546

4505

if (!ptr)

4547

4506

tee_fprintf(stdout, "Returning to default PROMPT of %s\n",

4548

default_prompt->str);

4507

default_prompt);

4549

4508

else

4550

4509

tee_fprintf(stdout, "PROMPT set to '%s'\n", current_prompt);

4551

4510

return 0;

Older »