~drizzle-trunk/drizzle/development : revision 893

186

static uint32_t opt_max_allowed_packet, opt_net_buffer_length,

187

opt_drizzle_port= 0;

188

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

189

static uint my_end_arg;

189

static uint32_t my_end_arg;

190

static char * opt_drizzle_unix_port= NULL;

191

static int connect_flag= CLIENT_INTERACTIVE;

192

static char *current_host, *current_db, *current_user= NULL,

209

static char pager[FN_REFLEN], outfile[FN_REFLEN];

210

static FILE *PAGER, *OUTFILE;

211

static MEM_ROOT hash_mem_root;

212

static uint prompt_counter;

212

static uint32_t prompt_counter;

213

static char delimiter[16]= DEFAULT_DELIMITER;

214

static uint delimiter_length= 1;

214

static uint32_t delimiter_length= 1;

215

unsigned short terminal_width= 80;

216

217

static const CHARSET_INFO *charset_info= &my_charset_utf8_general_ci;

243

244

static int read_and_execute(bool interactive);

245

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

246

uint silent);

246

uint32_t silent);

247

static const char *server_version_string(DRIZZLE *drizzle);

248

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

248

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

249

const char *sql_state);

250

static int put_error(DRIZZLE *drizzle);

251

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

1818

1819

static COMMANDS *find_command(const char *name,char cmd_char)

1820

{

1821

uint len;

1821

uint32_t len;

1822

const char *end;

1823

1824

if (!name)

1854

len=(uint) strlen(name);

1855

}

1856

1857

for (uint i= 0; commands[i].name; i++)

1857

for (uint32_t i= 0; commands[i].name; i++)

1858

{

1859

if (commands[i].func &&

1860

((name && !my_strnncoll(charset_info,(const unsigned char*)name,len, (const unsigned char*)commands[i].name,len) && !commands[i].name[len] && (!end || (end && commands[i].takes_params))) || (!name && commands[i].cmd_char == cmd_char)))

2124

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

2125

{

2126

*out++='\n';

2127

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

2127

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

2128

if ((!*ml_comment || preserve_comments))

2129

buffer->append(line, length);

2130

}

2254

char *ptr;

2255

static Bucket *b;

2256

static entry *e;

2257

static uint i;

2257

static uint32_t i;

2258

2259

if (!state)

2260

textlen=(uint) strlen(text);

2263

{ /* lookup in the hash */

2264

if (!state)

2265

{

2266

uint len;

2266

uint32_t len;

2267

2268

b = find_all_matches(&ht,text,(uint) strlen(text),&len);

2269

if (!b)

2516

2517

int drizzleclient_real_query_for_lazy(const char *buf, int length)

2518

{

2519

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

2519

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

2520

{

2521

int error;

2522

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

2588

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

2589

DRIZZLE_RES *result;

2590

uint32_t timer, warnings= 0;

2591

uint error= 0;

2591

uint32_t error= 0;

2592

int err= 0;

2593

2594

interrupted_query= 0;

2814

}

2815

}

2816

2817

static char *fieldflags2str(uint f) {

2817

static char *fieldflags2str(uint32_t f) {

2818

static char buf[1024];

2819

char *s=buf;

2820

*s=0;

2849

print_field_types(DRIZZLE_RES *result)

2850

{

2851

DRIZZLE_FIELD *field;

2852

uint i=0;

2852

uint32_t i=0;

2853

2854

while ((field = drizzleclient_fetch_field(result)))

2855

{

2937

{

2938

drizzleclient_field_seek(result,0);

2939

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

2940

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

2940

for (uint32_t off=0; (field = drizzleclient_fetch_field(result)) ; off++)

2941

{

2942

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

2943

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

2942

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

2943

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

2944

field->name,

2945

field->name + name_length);

2946

uint32_t display_length= field->max_length + name_length - numcells;

2961

uint32_t *lengths= drizzleclient_fetch_lengths(result);

2962

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

2963

drizzleclient_field_seek(result, 0);

2964

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

2964

for (uint32_t off= 0; off < drizzleclient_num_fields(result); off++)

2965

{

2966

const char *buffer;

2967

uint data_length;

2968

uint field_max_length;

2969

uint visible_length;

2970

uint extra_padding;

2967

uint32_t data_length;

2968

uint32_t field_max_length;

2969

uint32_t visible_length;

2970

uint32_t extra_padding;

2971

2972

if (cur[off] == NULL)

2973

{

3102

print_table_data_vertically(DRIZZLE_RES *result)

3103

{

3104

DRIZZLE_ROW cur;

3105

uint max_length=0;

3105

uint32_t max_length=0;

3106

DRIZZLE_FIELD *field;

3107

3108

while ((field = drizzleclient_fetch_field(result)))

3109

{

3110

uint length= field->name_length;

3110

uint32_t length= field->name_length;

3111

if (length > max_length)

3112

max_length= length;

3113

field->max_length=length;

3114

}

3115

3116

drizzleclient_field_seek(result,0);

3117

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

3117

for (uint32_t row_count=1; (cur= drizzleclient_fetch_row(result)); row_count++)

3118

{

3119

if (interrupted_query)

3120

break;

3121

drizzleclient_field_seek(result,0);

3122

tee_fprintf(PAGER,

3123

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

3124

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

3124

for (uint32_t off=0; off < drizzleclient_num_fields(result); off++)

3125

{

3126

field= drizzleclient_fetch_field(result);

3127

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

3141

uint64_t num_rows;

3142

3143

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

3144

uint error= drizzleclient_errno(&drizzle);

3144

uint32_t error= drizzleclient_errno(&drizzle);

3145

3146

/* Get the warnings */

3147

query= "show warnings";

3235

{

3236

lengths= drizzleclient_fetch_lengths(result);

3237

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

3238

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

3238

for (uint32_t off=1 ; off < drizzleclient_num_fields(result); off++)

3239

{

3240

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

3241

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

3688

3689

static int

3690

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

3691

uint silent)

3691

uint32_t silent)

3692

{

3693

if (connected)

3694

{

3698

drizzleclient_create(&drizzle);

3699

if (opt_connect_timeout)

3700

{

3701

uint timeout=opt_connect_timeout;

3701

uint32_t timeout=opt_connect_timeout;

3702

drizzleclient_options(&drizzle,DRIZZLE_OPT_CONNECT_TIMEOUT,

3703

(char*) &timeout);

3704

}

3863

}

3864

3865

static int

3866

put_info(const char *str,INFO_TYPE info_type, uint error, const char *sqlstate)

3866

put_info(const char *str,INFO_TYPE info_type, uint32_t error, const char *sqlstate)

3867

{

3868

FILE *file= (info_type == INFO_ERROR ? stderr : stdout);

3869

static int inited=0;

3948

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

3949

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

3950

end--;

3951

uint pos_to_truncate= (end-start);

3951

uint32_t pos_to_truncate= (end-start);

3952

if (buffer->length() > pos_to_truncate)

3953

buffer->erase(pos_to_truncate);

3954

}