~drizzle-trunk/drizzle/development : revision 2463.1.4

282

typedef enum enum_info_type INFO_TYPE;

283

284

static drizzle_st *drizzle= NULL; /* The library handle */

285

static drizzle_con_st con; /* The connection */

285

static drizzle_con_st *con= NULL; /* The connection */

286

static bool ignore_errors= false, quick= false,

287

connected= false, opt_raw_data= false, unbuffered= false,

288

output_tables= false, opt_rehash= true, skip_updates= false,

1188

static bool server_shutdown(void)

1189

{

1190

drizzle_result_st result;

1191

drizzle_return_t ret;

1192

1191

1193

1192

if (verbose)

1194

1193

{

1195

1194

printf(_("shutting down drizzled"));

1196

1195

if (opt_drizzle_port > 0)

1196

{

1197

printf(_(" on port %d"), opt_drizzle_port);

1198

}

1198

1199

printf("... ");

1199

1200

}

1200

1201

if (drizzle_shutdown(&con, &result, DRIZZLE_SHUTDOWN_DEFAULT,

1202

&ret) == NULL || ret != DRIZZLE_RETURN_OK)

1202

drizzle_return_t ret;

1203

if (drizzle_shutdown(con, &result, DRIZZLE_SHUTDOWN_DEFAULT, &ret) == NULL or

1204

ret != DRIZZLE_RETURN_OK)

1203

1205

{

1204

1206

if (ret == DRIZZLE_RETURN_ERROR_CODE)

1205

1207

{

1206

fprintf(stderr, _("shutdown failed; error: '%s'"),

1207

drizzle_result_error(&result));

1208

fprintf(stderr, _("shutdown failed; error: '%s'"), drizzle_result_error(&result));

1208

1209

drizzle_result_free(&result);

1209

1210

}

1210

1211

else

1211

1212

{

1212

fprintf(stderr, _("shutdown failed; error: '%s'"),

1213

drizzle_con_error(&con));

1213

fprintf(stderr, _("shutdown failed; error: '%s'"), drizzle_con_error(con));

1214

}

1215

return false;

1216

}

1218

drizzle_result_free(&result);

1219

1220

if (verbose)

1221

{

1221

1222

printf(_("done\n"));

1223

}

1222

1224

1223

1225

return true;

1224

1226

}

1234

1236

printf("... ");

1235

1237

}

1236

1238

1237

if (drizzle_kill(&con, &result, query_id,

1239

if (drizzle_kill(con, &result, query_id,

1238

1240

&ret) == NULL || ret != DRIZZLE_RETURN_OK)

1239

1241

{

1240

1242

if (ret == DRIZZLE_RETURN_ERROR_CODE)

1245

1247

}

1246

1248

else

1247

1249

{

1248

fprintf(stderr, _("kill failed; error: '%s'"),

1249

drizzle_con_error(&con));

1250

fprintf(stderr, _("kill failed; error: '%s'"), drizzle_con_error(con));

1250

1251

}

1251

1252

return false;

1252

1253

}

1272

1273

drizzle_result_st result;

1273

1274

drizzle_return_t ret;

1274

1275

if (drizzle_ping(&con, &result, &ret) != NULL && ret == DRIZZLE_RETURN_OK)

1276

if (drizzle_ping(con, &result, &ret) != NULL && ret == DRIZZLE_RETURN_OK)

1276

1277

{

1277

1278

if (opt_silent < 2)

1278

1279

printf(_("drizzled is alive\n"));

1287

1288

}

1288

1289

else

1289

1290

{

1290

fprintf(stderr, _("drizzled won't answer to ping, error: '%s'"),

1291

drizzle_con_error(&con));

1291

fprintf(stderr, _("drizzled won't answer to ping, error: '%s'"), drizzle_con_error(con));

1292

}

1293

return false;

1294

}

1840

glob_buffer->reserve(512);

1841

1842

snprintf(&output_buff[0], output_buff.size(),

1843

_("Your Drizzle connection id is %u\nConnection protocol: %s\nServer version: %s\n"),

1844

drizzle_con_thread_id(&con),

1845

opt_protocol.c_str(),

1846

server_version_string(&con));

1843

_("Your Drizzle connection id is %u\nConnection protocol: %s\nServer version: %s\n"),

1844

drizzle_con_thread_id(con),

1845

opt_protocol.c_str(),

1846

server_version_string(con));

1847

put_info(&output_buff[0], INFO_INFO, 0, 0);

1848

1849

1898

1899

void drizzle_end(int sig)

1900

{

1901

drizzle_con_free(&con);

1901

drizzle_con_free(con);

1902

drizzle_free(drizzle);

1903

if (!status.getBatch() && !quick && histfile)

1904

{

1937

extern "C"

1938

void handle_sigint(int sig)

1939

{

1940

char kill_buffer[40];

1941

boost::scoped_ptr<drizzle_con_st> kill_drizzle(new drizzle_con_st);

1942

drizzle_result_st res;

1943

drizzle_return_t ret;

1944

1945

1940

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

1946

if (!executing_query || interrupted_query)

1947

{

1948

goto err;

1949

}

1950

1951

if (drizzle and drizzle_con_add_tcp(drizzle, kill_drizzle.get(), current_host.c_str(),

1952

opt_drizzle_port, current_user.c_str(), opt_password.c_str(), NULL,

1953

use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL) == NULL)

1954

{

1955

goto err;

1956

}

1957

1958

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

1959

sprintf(kill_buffer, "KILL /*!50000 QUERY */ %u",

1960

drizzle_con_thread_id(&con));

1961

1962

if (drizzle_query_str(kill_drizzle.get(), &res, kill_buffer, &ret) != NULL)

1963

drizzle_result_free(&res);

1964

1965

drizzle_con_free(kill_drizzle.get());

1966

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

1967

1968

interrupted_query= 1;

1969

1970

return;

1971

1972

err:

1941

if (executing_query == false or interrupted_query)

1942

{ }

1943

else if (drizzle)

1944

{

1945

drizzle_con_st *kill_drizzle_con;

1946

if ((kill_drizzle_con= drizzle_con_add_tcp(drizzle,

1947

current_host.c_str(), opt_drizzle_port,

1948

current_user.c_str(), opt_password.c_str(), NULL,

1949

use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL)))

1950

{

1951

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

1952

char kill_buffer[40];

1953

snprintf(kill_buffer, sizeof(kill_buffer), "KILL /*!50000 QUERY */ %u", drizzle_con_thread_id(kill_drizzle_con));

1954

1955

drizzle_return_t ret;

1956

drizzle_result_st res;

1957

if ((drizzle_query_str(kill_drizzle_con, &res, kill_buffer, &ret)))

1958

{

1959

drizzle_result_free(&res);

1960

}

1961

1962

drizzle_con_free(kill_drizzle_con);

1963

1964

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

1965

1966

interrupted_query= true;

1967

1968

return;

1969

}

1970

}

1971

1973

1972

drizzle_end(sig);

1974

1973

}

1975

1974

2206

2205

}

2207

2206

}

2208

2207

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

2209

!(*in_string && (drizzle_con_status(&con) & DRIZZLE_CON_STATUS_NO_BACKSLASH_ESCAPES)))

2208

!(*in_string && (drizzle_con_status(con) & DRIZZLE_CON_STATUS_NO_BACKSLASH_ESCAPES)))

2210

2209

{

2211

2210

// Found possbile one character command like \c

2212

2211

2622

2621

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

2623

2622

2624

2623

/* hash all database names */

2625

if (drizzle_query_str(&con, &databases, "select schema_name from information_schema.schemata", &ret) != NULL)

2624

if (drizzle_query_str(con, &databases, "select schema_name from information_schema.schemata", &ret) != NULL)

2626

2625

{

2627

2626

if (ret == DRIZZLE_RETURN_OK)

2628

2627

{

2648

2647

query.append(current_db);

2649

2648

query.append("' order by table_name");

2650

2649

2651

if (drizzle_query(&con, &fields, query.c_str(), query.length(),

2652

&ret) != NULL)

2650

if (drizzle_query(con, &fields, query.c_str(), query.length(), &ret) != NULL)

2653

2651

{

2654

2652

if (ret == DRIZZLE_RETURN_OK &&

2655

2653

drizzle_result_buffer(&fields) == DRIZZLE_RETURN_OK)

2714

2712

current_db.erase();

2715

2713

current_db= "";

2716

2714

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

2717

if (drizzle_query_str(&con, &res, "SELECT DATABASE()", &ret) != NULL)

2715

if (drizzle_query_str(con, &res, "SELECT DATABASE()", &ret) != NULL)

2718

2716

{

2719

2717

if (ret == DRIZZLE_RETURN_OK &&

2720

2718

drizzle_result_buffer(&res) == DRIZZLE_RETURN_OK)

2740

2738

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

2741

2739

{

2742

2740

int error;

2743

if (drizzle_query(&con,result,buf,length,&ret) != NULL &&

2741

if (drizzle_query(con, result, buf, length, &ret) != NULL and

2744

2742

ret == DRIZZLE_RETURN_OK)

2745

2743

{

2746

2744

return 0;

2747

2745

}

2748

error= put_error(&con, result);

2746

error= put_error(con, result);

2749

2747

2750

2748

if (ret == DRIZZLE_RETURN_ERROR_CODE)

2751

2749

{

2767

2765

int drizzleclient_store_result_for_lazy(drizzle_result_st *result)

2768

2766

{

2769

2767

if (drizzle_result_buffer(result) == DRIZZLE_RETURN_OK)

2768

{

2770

2769

return 0;

2770

}

2771

2772

if (drizzle_con_error(&con)[0])

2772

if (drizzle_con_error(con)[0])

2773

{

2774

int ret= put_error(&con, result);

2774

int ret= put_error(con, result);

2775

drizzle_result_free(result);

2776

return ret;

2777

}

2778

2779

return 0;

2779

2780

}

2780

2781

2838

2839

uint32_t error_code= 0;

2839

2840

int err= 0;

2840

2841

interrupted_query= 0;

2842

interrupted_query= false;

2842

2843

2844

/* Remove garbage for nicer messages */

2844

2845

remove_cntrl(buffer);

2868

2869

}

2869

2870

2871

timer=start_timer();

2871

executing_query= 1;

2872

executing_query= true;

2872

2873

error= drizzleclient_real_query_for_lazy(buffer->c_str(),buffer->length(),&result, &error_code);

2873

2874

2875

if (status.getAddToHistory())

2891

2892

{

2892

2893

if (drizzle_column_buffer(&result) != DRIZZLE_RETURN_OK)

2893

2894

{

2894

error= put_error(&con, &result);

2895

error= put_error(con, &result);

2895

2896

goto end;

2896

2897

}

2897

2898

}

2930

2931

(long) drizzle_result_row_count(&result));

2931

2932

end_pager();

2932

2933

if (drizzle_result_error_code(&result))

2933

error= put_error(&con, &result);

2934

error= put_error(con, &result);

2934

2935

}

2935

2936

}

2936

2937

else if (drizzle_result_affected_rows(&result) == ~(uint64_t) 0)

2965

2966

fflush(stdout);

2966

2967

drizzle_result_free(&result);

2967

2968

if (drizzle_con_status(&con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS)

2969

if (drizzle_con_status(con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS)

2969

2970

{

2970

if (drizzle_result_read(&con, &result, &ret) == NULL ||

2971

if (drizzle_result_read(con, &result, &ret) == NULL ||

2971

2972

ret != DRIZZLE_RETURN_OK)

2972

2973

{

2973

2974

if (ret == DRIZZLE_RETURN_ERROR_CODE)

2976

2977

drizzle_result_free(&result);

2977

2978

}

2978

2979

error= put_error(&con, NULL);

2980

error= put_error(con, NULL);

2980

2981

goto end;

2981

2982

}

2982

2983

}

2983

2984

} while (drizzle_con_status(&con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS);

2985

} while (drizzle_con_status(con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS);

2985

2986

if (err >= 1)

2986

error= put_error(&con, NULL);

2987

{

2988

error= put_error(con, NULL);

2989

}

2987

2990

2988

2991

end:

2989

2992

2991

2994

if (show_warnings == 1 && (warnings >= 1 || error))

2992

2995

print_warnings(error_code);

2993

2996

2994

if (!error && !status.getBatch() &&

2995

drizzle_con_status(&con) & DRIZZLE_CON_STATUS_DB_DROPPED)

2997

if (!error && !status.getBatch() and

2998

drizzle_con_status(con) & DRIZZLE_CON_STATUS_DB_DROPPED)

2996

2999

{

2997

3000

get_current_db();

2998

3001

}

2999

3002

3000

executing_query= 0;

3003

executing_query= false;

3001

3004

return error; /* New command follows */

3002

3005

}

3003

3006

3004

3007

3005

3008

static void init_pager()

3006

3009

{

3007

if (!opt_nopager)

3010

if (opt_nopager == false)

3008

3011

{

3009

3012

if (!(PAGER= popen(pager.c_str(), "w")))

3010

3013

{

3013

3016

}

3014

3017

}

3015

3018

else

3019

{

3016

3020

PAGER= stdout;

3021

}

3017

3022

}

3018

3023

3019

3024

static void end_pager()

3027

3032

{

3028

3033

FILE* new_outfile;

3029

3034

if (opt_outfile)

3035

{

3030

3036

end_tee();

3031

if (!(new_outfile= fopen(file_name, "a")))

3037

}

3038

3039

if ((new_outfile= fopen(file_name, "a")) == NULL)

3032

3040

{

3033

3041

tee_fprintf(stdout, _("Error logging to file '%s'\n"), file_name);

3034

3042

return;

3261

3269

cur= drizzle_row_buffer(result, &ret);

3262

3270

if (ret != DRIZZLE_RETURN_OK)

3263

3271

{

3264

(void)put_error(&con, result);

3272

(void)put_error(con, result);

3265

3273

break;

3266

3274

}

3267

3275

}

3467

3475

cur= drizzle_row_buffer(result, &ret);

3468

3476

if (ret != DRIZZLE_RETURN_OK)

3469

3477

{

3470

(void)put_error(&con, result);

3478

(void)put_error(con, result);

3471

3479

break;

3472

3480

}

3473

3481

}

3633

3641

cur= drizzle_row_buffer(result, &ret);

3634

3642

if (ret != DRIZZLE_RETURN_OK)

3635

3643

{

3636

(void)put_error(&con, result);

3644

(void)put_error(con, result);

3637

3645

break;

3638

3646

}

3639

3647

}

3877

3885

3878

3886

if (connected)

3879

3887

{

3880

sprintf(buff, _("Connection id: %u"), drizzle_con_thread_id(&con));

3888

sprintf(buff, _("Connection id: %u"), drizzle_con_thread_id(con));

3881

3889

put_info(buff,INFO_INFO,0,0);

3882

3890

sprintf(buff, _("Current schema: %.128s\n"),

3883

3891

!current_db.empty() ? current_db.c_str() : _("*** NONE ***"));

4028

4036

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

4029

4037

for (bool try_again= true; try_again; try_again= false)

4030

4038

{

4031

if (drizzle_select_db(&con,&result,tmp,&ret) == NULL ||

4039

if (drizzle_select_db(con, &result, tmp, &ret) == NULL ||

4032

4040

ret != DRIZZLE_RETURN_OK)

4033

4041

{

4034

4042

if (ret == DRIZZLE_RETURN_ERROR_CODE)

4035

4043

{

4036

int error= put_error(&con, &result);

4044

int error= put_error(con, &result);

4037

4045

drizzle_result_free(&result);

4038

4046

return error;

4039

4047

}

4040

4048

4041

4049

if (ret != DRIZZLE_RETURN_LOST_CONNECTION || !try_again)

4042

return put_error(&con, NULL);

4050

{

4051

return put_error(con, NULL);

4052

}

4043

4053

4044

4054

if (reconnect())

4055

{

4045

4056

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

4057

}

4046

4058

}

4047

4059

else

4048

4060

drizzle_result_free(&result);

4069

4081

printf("... ");

4070

4082

}

4071

4083

4072

if (drizzle_shutdown(&con, &result, DRIZZLE_SHUTDOWN_DEFAULT,

4084

if (drizzle_shutdown(con, &result, DRIZZLE_SHUTDOWN_DEFAULT,

4073

4085

&ret) == NULL || ret != DRIZZLE_RETURN_OK)

4074

4086

{

4075

4087

if (ret == DRIZZLE_RETURN_ERROR_CODE)

4076

4088

{

4077

fprintf(stderr, _("shutdown failed; error: '%s'"),

4078

drizzle_result_error(&result));

4089

fprintf(stderr, _("shutdown failed; error: '%s'"), drizzle_result_error(&result));

4079

4090

drizzle_result_free(&result);

4080

4091

}

4081

4092

else

4082

4093

{

4083

fprintf(stderr, _("shutdown failed; error: '%s'"),

4084

drizzle_con_error(&con));

4094

fprintf(stderr, _("shutdown failed; error: '%s'"), drizzle_con_error(con));

4085

4095

}

4086

4096

return false;

4087

4097

}

4179

4189

if (connected)

4180

4190

{

4181

4191

connected= 0;

4182

drizzle_con_free(&con);

4192

drizzle_con_free(con);

4183

4193

drizzle_free(drizzle);

4184

4194

}

4185

4195

4189

4199

return 1;

4190

4200

}

4191

4201

4192

if (drizzle_con_add_tcp(drizzle, &con, (char *)host.c_str(),

4193

opt_drizzle_port, (char *)user.c_str(),

4194

(char *)password.c_str(), (char *)database.c_str(),

4195

global_con_options) == NULL)

4202

if ((con= drizzle_con_add_tcp(drizzle, host.c_str(),

4203

opt_drizzle_port, user.c_str(),

4204

password.c_str(), database.c_str(),

4205

global_con_options)) == NULL)

4196

4206

{

4197

(void) put_error(&con, NULL);

4207

(void) put_error(con, NULL);

4198

4208

(void) fflush(stdout);

4199

4209

return 1;

4200

4210

}

4201

4211

4202

if ((ret= drizzle_con_connect(&con)) != DRIZZLE_RETURN_OK)

4212

if ((ret= drizzle_con_connect(con)) != DRIZZLE_RETURN_OK)

4203

4213

{

4204

4214

4205

4215

if (opt_silent < 2)

4206

4216

{

4207

(void) put_error(&con, NULL);

4217

(void) put_error(con, NULL);

4208

4218

(void) fflush(stdout);

4209

4219

return ignore_errors ? -1 : 1; // Abort

4210

4220

}

4212

4222

}

4213

4223

connected= 1;

4214

4224

4215

ServerDetect server_detect(&con);

4225

ServerDetect server_detect(con);

4216

4226

server_type= server_detect.getServerType();

4217

4227

4218

4228

build_completion_hash(opt_rehash, 1);

4238

4248

4239

4249

if (connected)

4240

4250

{

4241

tee_fprintf(stdout, _("\nConnection id:\t\t%lu\n"),drizzle_con_thread_id(&con));

4251

tee_fprintf(stdout, _("\nConnection id:\t\t%lu\n"),drizzle_con_thread_id(con));

4242

4252

/*

4243

4253

Don't remove "limit 1",

4244

4254

it is protection againts SQL_SELECT_LIMIT=0

4245

4255

*/

4246

if (drizzle_query_str(&con,&result,"select DATABASE(), USER() limit 1",

4256

if (drizzle_query_str(con, &result, "select DATABASE(), USER() limit 1",

4247

4257

&ret) != NULL && ret == DRIZZLE_RETURN_OK &&

4248

4258

drizzle_result_buffer(&result) == DRIZZLE_RETURN_OK)

4249

4259

{

4275

4285

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

4276

4286

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

4277

4287

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

4278

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

4288

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

4279

4289

tee_fprintf(stdout, _("Protocol:\t\t%s\n"), opt_protocol.c_str());

4280

tee_fprintf(stdout, _("Protocol version:\t%d\n"), drizzle_con_protocol_version(&con));

4281

tee_fprintf(stdout, _("Connection:\t\t%s\n"), drizzle_con_host(&con));

4290

tee_fprintf(stdout, _("Protocol version:\t%d\n"), drizzle_con_protocol_version(con));

4291

tee_fprintf(stdout, _("Connection:\t\t%s\n"), drizzle_con_host(con));

4282

4292

/* XXX need to save this from result

4283

4293

if ((id= drizzleclient_insert_id(&drizzle)))

4284

4294

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

4285

4295

*/

4286

4296

4287

if (drizzle_con_uds(&con))

4288

tee_fprintf(stdout, _("UNIX socket:\t\t%s\n"), drizzle_con_uds(&con));

4297

if (drizzle_con_uds(con))

4298

{

4299

tee_fprintf(stdout, _("UNIX socket:\t\t%s\n"), drizzle_con_uds(con));

4300

}

4289

4301

else

4290

tee_fprintf(stdout, _("TCP port:\t\t%d\n"), drizzle_con_port(&con));

4302

{

4303

tee_fprintf(stdout, _("TCP port:\t\t%d\n"), drizzle_con_port(con));

4304

}

4291

4305

4292

4306

if (safe_updates)

4293

4307

{

4426

4440

{

4427

4441

error= drizzle_result_error(res);

4428

4442

if (!strcmp(error, ""))

4443

{

4429

4444

error= drizzle_con_error(local_con);

4445

}

4430

4446

}

4431

4447

else

4448

{

4432

4449

error= drizzle_con_error(local_con);

4450

}

4433

4451

4434

4452

return put_info(error, INFO_ERROR,

4435

4453

res == NULL ? drizzle_con_error_code(local_con) :

4580

4598

break;

4581

4599

case 'v':

4582

4600

if (connected)

4583

processed_prompt->append(drizzle_con_server_version(&con));

4601

processed_prompt->append(drizzle_con_server_version(con));

4584

4602

else

4585

4603

processed_prompt->append("not_connected");

4586

4604

break;

4589

4607

break;

4590

4608

case 'h':

4591

4609

{

4592

const char *prompt= connected ? drizzle_con_host(&con) : "not_connected";

4610

const char *prompt= connected ? drizzle_con_host(con) : "not_connected";

4593

4611

if (strstr(prompt, "Localhost"))

4594

4612

processed_prompt->append("localhost");

4595

4613

else

4608

4626

break;

4609

4627

}

4610

4628

4611

if (drizzle_con_uds(&con))

4629

if (drizzle_con_uds(con))

4612

4630

{

4613

const char *pos=strrchr(drizzle_con_uds(&con),'/');

4614

processed_prompt->append(pos ? pos+1 : drizzle_con_uds(&con));

4631

const char *pos=strrchr(drizzle_con_uds(con),'/');

4632

processed_prompt->append(pos ? pos+1 : drizzle_con_uds(con));

4615

4633

}

4616

4634

else

4617

add_int_to_prompt(drizzle_con_port(&con));

4635

add_int_to_prompt(drizzle_con_port(con));

4618

4636

}

4619

4637

break;

4620

4638

case 'U':