← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/libdrizzle.c

code clean move Item_func_abs, Item_func_int_exp, Item_func_ln, Item_func_log to functions directory

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/libdrizzle.c
 
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; version 2 of the License.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
18
 */
 
19
 
 
20
#include "libdrizzle.h"
 
21
#include "libdrizzle_priv.h"
 
22
#include "errmsg.h"
 
23
#include <sys/stat.h>
 
24
#include <signal.h>
 
25
#include <time.h>
 
26
#ifdef   HAVE_PWD_H
 
27
#include <pwd.h>
 
28
#endif
 
29
 
 
30
#include <sys/socket.h>
 
31
#include <netinet/in.h>
 
32
#include <arpa/inet.h>
 
33
#include <netdb.h>
 
34
#ifdef HAVE_SELECT_H
 
35
#include <select.h>
 
36
#endif
 
37
#ifdef HAVE_SYS_SELECT_H
 
38
#include <sys/select.h>
 
39
#endif
 
40
 
 
41
#ifdef HAVE_POLL
 
42
#include <sys/poll.h>
 
43
#endif
 
44
#ifdef HAVE_SYS_UN_H
 
45
#include <sys/un.h>
 
46
#endif
 
47
#ifndef INADDR_NONE
 
48
#define INADDR_NONE  -1
 
49
#endif
 
50
 
 
51
#include <stdlib.h>
 
52
#include <string.h>
 
53
 
 
54
#include <sql_common.h>
 
55
#include <drizzled/version.h>
 
56
 
 
57
/* Borrowed from libicu header */
 
58
 
 
59
#define U8_IS_SINGLE(c) (((c)&0x80)==0)
 
60
#define U8_LENGTH(c) \
 
61
    ((uint32_t)(c)<=0x7f ? 1 : \
 
62
        ((uint32_t)(c)<=0x7ff ? 2 : \
 
63
            ((uint32_t)(c)<=0xd7ff ? 3 : \
 
64
                ((uint32_t)(c)<=0xdfff || (uint32_t)(c)>0x10ffff ? 0 : \
 
65
                    ((uint32_t)(c)<=0xffff ? 3 : 4)\
 
66
                ) \
 
67
            ) \
 
68
        ) \
 
69
    )
 
70
 
 
71
 
 
72
#undef net_buffer_length
 
73
#undef max_allowed_packet
 
74
 
 
75
uint32_t     net_buffer_length= 8192;
 
76
uint32_t    max_allowed_packet= 1024L*1024L*1024L;
 
77
 
 
78
unsigned int drizzle_port=0;
 
79
 
 
80
#include <errno.h>
 
81
#define SOCKET_ERROR -1
 
82
 
 
83
/*
 
84
  If allowed through some configuration, then this needs to
 
85
  be changed
 
86
*/
 
87
#define MAX_LONG_DATA_LENGTH 8192
 
88
#define unsigned_field(A) ((A)->flags & UNSIGNED_FLAG)
 
89
 
 
90
 
 
91
static DRIZZLE_PARAMETERS drizzle_internal_parameters=
 
92
{&max_allowed_packet, &net_buffer_length, 0};
 
93
 
 
94
const DRIZZLE_PARAMETERS * drizzle_get_parameters(void)
 
95
{
 
96
  return &drizzle_internal_parameters;
 
97
}
 
98
 
 
99
unsigned int drizzle_get_default_port(void)
 
100
{
 
101
  return drizzle_port;
 
102
}
 
103
 
 
104
void drizzle_set_default_port(unsigned int port)
 
105
{
 
106
  drizzle_port= port;
 
107
}
 
108
 
 
109
/*
 
110
  Expand wildcard to a sql string
 
111
*/
 
112
 
 
113
static void
 
114
append_wild(char *to, char *end, const char *wild)
 
115
{
 
116
  end-=5;          /* Some extra */
 
117
  if (wild && wild[0])
 
118
  {
 
119
    to= strcpy(to," like '");
 
120
    to+= 7; /* strlen(" like '"); */
 
121
 
 
122
    while (*wild && to < end)
 
123
    {
 
124
      if (*wild == '\\' || *wild == '\'')
 
125
  *to++='\\';
 
126
      *to++= *wild++;
 
127
    }
 
128
    if (*wild)          /* Too small buffer */
 
129
      *to++='%';        /* Nicer this way */
 
130
    to[0]='\'';
 
131
    to[1]=0;
 
132
  }
 
133
}
 
134
 
 
135
/**************************************************************************
 
136
  Change user and database
 
137
**************************************************************************/
 
138
 
 
139
int cli_read_change_user_result(DRIZZLE *drizzle)
 
140
{
 
141
  uint32_t pkt_length;
 
142
 
 
143
  pkt_length= cli_safe_read(drizzle);
 
144
  
 
145
  if (pkt_length == packet_error)
 
146
    return 1;
 
147
 
 
148
  return 0;
 
149
}
 
150
 
 
151
bool drizzle_change_user(DRIZZLE *drizzle, const char *user,
 
152
                                 const char *passwd, const char *db)
 
153
{
 
154
  char buff[USERNAME_LENGTH+SCRAMBLED_PASSWORD_CHAR_LENGTH+NAME_LEN+2];
 
155
  char *end= buff;
 
156
  int rc;
 
157
 
 
158
  /* Use an empty string instead of NULL. */
 
159
 
 
160
  if (!user)
 
161
    user="";
 
162
  if (!passwd)
 
163
    passwd="";
 
164
 
 
165
  /* Store user into the buffer */
 
166
  end= strncpy(end, user, USERNAME_LENGTH) + USERNAME_LENGTH + 1;
 
167
 
 
168
  /* write scrambled password according to server capabilities */
 
169
  if (passwd[0])
 
170
  {
 
171
    {
 
172
      *end++= SCRAMBLE_LENGTH;
 
173
      end+= SCRAMBLE_LENGTH;
 
174
    }
 
175
  }
 
176
  else
 
177
    *end++= '\0';                               /* empty password */
 
178
  /* Add database if needed */
 
179
  end= strncpy(end, db ? db : "", NAME_LEN) + NAME_LEN + 1;
 
180
 
 
181
  /* Add character set number. */
 
182
  if (drizzle->server_capabilities & CLIENT_SECURE_CONNECTION)
 
183
  {
 
184
    int2store(end, (uint16_t) 45); // utf8mb4 number from mystrings/ctype-utf8.c
 
185
    end+= 2;
 
186
  }
 
187
 
 
188
  /* Write authentication package */
 
189
  (void)simple_command(drizzle,COM_CHANGE_USER, (unsigned char*) buff, (uint32_t) (end-buff), 1);
 
190
 
 
191
  rc= (*drizzle->methods->read_change_user_result)(drizzle);
 
192
 
 
193
  if (rc == 0)
 
194
  {
 
195
    /* Free old connect information */
 
196
    if(drizzle->user)
 
197
      free(drizzle->user);
 
198
    if(drizzle->passwd)
 
199
      free(drizzle->passwd);
 
200
    if(drizzle->db)
 
201
      free(drizzle->db);
 
202
 
 
203
    /* alloc new connect information */
 
204
    drizzle->user= strdup(user);
 
205
    drizzle->passwd= strdup(passwd);
 
206
    drizzle->db= db ? strdup(db) : 0;
 
207
  }
 
208
 
 
209
  return(rc);
 
210
}
 
211
 
 
212
#if defined(HAVE_GETPWUID) && defined(NO_GETPWUID_DECL)
 
213
struct passwd *getpwuid(uid_t);
 
214
char* getlogin(void);
 
215
#endif
 
216
 
 
217
/**************************************************************************
 
218
  Do a query. If query returned rows, free old rows.
 
219
  Read data by drizzle_store_result or by repeat call of drizzle_fetch_row
 
220
**************************************************************************/
 
221
 
 
222
int
 
223
drizzle_query(DRIZZLE *drizzle, const char *query)
 
224
{
 
225
  return drizzle_real_query(drizzle,query, (uint32_t) strlen(query));
 
226
}
 
227
 
 
228
 
 
229
/**************************************************************************
 
230
  Return next field of the query results
 
231
**************************************************************************/
 
232
 
 
233
DRIZZLE_FIELD *
 
234
drizzle_fetch_field(DRIZZLE_RES *result)
 
235
{
 
236
  if (result->current_field >= result->field_count)
 
237
    return(NULL);
 
238
  return &result->fields[result->current_field++];
 
239
}
 
240
 
 
241
 
 
242
/**************************************************************************
 
243
  Move to a specific row and column
 
244
**************************************************************************/
 
245
 
 
246
void
 
247
drizzle_data_seek(DRIZZLE_RES *result, uint64_t row)
 
248
{
 
249
  DRIZZLE_ROWS  *tmp=0;
 
250
  if (result->data)
 
251
    for (tmp=result->data->data; row-- && tmp ; tmp = tmp->next) ;
 
252
  result->current_row=0;
 
253
  result->data_cursor = tmp;
 
254
}
 
255
 
 
256
 
 
257
/*************************************************************************
 
258
  put the row or field cursor one a position one got from DRIZZLE_ROW_tell()
 
259
  This doesn't restore any data. The next drizzle_fetch_row or
 
260
  drizzle_fetch_field will return the next row or field after the last used
 
261
*************************************************************************/
 
262
 
 
263
DRIZZLE_ROW_OFFSET
 
264
drizzle_row_seek(DRIZZLE_RES *result, DRIZZLE_ROW_OFFSET row)
 
265
{
 
266
  DRIZZLE_ROW_OFFSET return_value=result->data_cursor;
 
267
  result->current_row= 0;
 
268
  result->data_cursor= row;
 
269
  return return_value;
 
270
}
 
271
 
 
272
 
 
273
DRIZZLE_FIELD_OFFSET
 
274
drizzle_field_seek(DRIZZLE_RES *result, DRIZZLE_FIELD_OFFSET field_offset)
 
275
{
 
276
  DRIZZLE_FIELD_OFFSET return_value=result->current_field;
 
277
  result->current_field=field_offset;
 
278
  return return_value;
 
279
}
 
280
 
 
281
 
 
282
/*****************************************************************************
 
283
  List all tables in a database
 
284
  If wild is given then only the tables matching wild is returned
 
285
*****************************************************************************/
 
286
 
 
287
DRIZZLE_RES *
 
288
drizzle_list_tables(DRIZZLE *drizzle, const char *wild)
 
289
{
 
290
  char buff[255];
 
291
  char *ptr= strcpy(buff, "show tables");
 
292
  ptr+= 11; /* strlen("show tables"); */
 
293
 
 
294
  append_wild(ptr,buff+sizeof(buff),wild);
 
295
  if (drizzle_query(drizzle,buff))
 
296
    return(0);
 
297
  return (drizzle_store_result(drizzle));
 
298
}
 
299
 
 
300
 
 
301
DRIZZLE_FIELD *cli_list_fields(DRIZZLE *drizzle)
 
302
{
 
303
  DRIZZLE_DATA *query;
 
304
  if (!(query= cli_read_rows(drizzle,(DRIZZLE_FIELD*) 0, 8)))
 
305
    return NULL;
 
306
 
 
307
  drizzle->field_count= (uint32_t) query->rows;
 
308
  return unpack_fields(query, drizzle->field_count, 1);
 
309
}
 
310
 
 
311
 
 
312
/**************************************************************************
 
313
  List all fields in a table
 
314
  If wild is given then only the fields matching wild is returned
 
315
  Instead of this use query:
 
316
  show fields in 'table' like "wild"
 
317
**************************************************************************/
 
318
 
 
319
DRIZZLE_RES *
 
320
drizzle_list_fields(DRIZZLE *drizzle, const char *table, const char *wild)
 
321
{
 
322
  DRIZZLE_RES   *result;
 
323
  DRIZZLE_FIELD *fields;
 
324
  char buff[257], *end;
 
325
 
 
326
  end= strncpy(buff, table, 128) + 128;
 
327
  end= strncpy(end+1, wild ? wild : "", 128) + 128;
 
328
 
 
329
  free_old_query(drizzle);
 
330
  if (simple_command(drizzle, COM_FIELD_LIST, (unsigned char*) buff,
 
331
                     (uint32_t) (end-buff), 1) ||
 
332
      !(fields= (*drizzle->methods->list_fields)(drizzle)))
 
333
    return(NULL);
 
334
 
 
335
  if (!(result = (DRIZZLE_RES *) malloc(sizeof(DRIZZLE_RES))))
 
336
    return(NULL);
 
337
 
 
338
  memset(result, 0, sizeof(DRIZZLE_RES));
 
339
 
 
340
  result->methods= drizzle->methods;
 
341
  drizzle->fields=0;
 
342
  result->field_count = drizzle->field_count;
 
343
  result->fields= fields;
 
344
  result->eof=1;
 
345
  return(result);
 
346
}
 
347
 
 
348
/* List all running processes (threads) in server */
 
349
 
 
350
DRIZZLE_RES *
 
351
drizzle_list_processes(DRIZZLE *drizzle)
 
352
{
 
353
  DRIZZLE_DATA *fields;
 
354
  uint32_t field_count;
 
355
  unsigned char *pos;
 
356
 
 
357
  if (simple_command(drizzle,COM_PROCESS_INFO,0,0,0))
 
358
    return(0);
 
359
  free_old_query(drizzle);
 
360
  pos=(unsigned char*) drizzle->net.read_pos;
 
361
  field_count=(uint32_t) net_field_length(&pos);
 
362
  if (!(fields = (*drizzle->methods->read_rows)(drizzle,(DRIZZLE_FIELD*) 0, 7)))
 
363
    return(NULL);
 
364
  if (!(drizzle->fields=unpack_fields(fields, field_count, 0)))
 
365
    return(0);
 
366
  drizzle->status=DRIZZLE_STATUS_GET_RESULT;
 
367
  drizzle->field_count=field_count;
 
368
  return(drizzle_store_result(drizzle));
 
369
}
 
370
 
 
371
 
 
372
int
 
373
drizzle_shutdown(DRIZZLE *drizzle)
 
374
{
 
375
  return(simple_command(drizzle, COM_SHUTDOWN, 0, 0, 0));
 
376
}
 
377
 
 
378
 
 
379
int
 
380
drizzle_refresh(DRIZZLE *drizzle, uint32_t options)
 
381
{
 
382
  unsigned char bits[1];
 
383
  bits[0]= (unsigned char) options;
 
384
  return(simple_command(drizzle, COM_REFRESH, bits, 1, 0));
 
385
}
 
386
 
 
387
 
 
388
int32_t
 
389
drizzle_kill(DRIZZLE *drizzle, uint32_t pid)
 
390
{
 
391
  unsigned char buff[4];
 
392
  int4store(buff,pid);
 
393
  return(simple_command(drizzle,COM_PROCESS_KILL,buff,sizeof(buff),0));
 
394
}
 
395
 
 
396
 
 
397
int
 
398
drizzle_set_server_option(DRIZZLE *drizzle, enum enum_drizzle_set_option option)
 
399
{
 
400
  unsigned char buff[2];
 
401
  int2store(buff, (uint32_t) option);
 
402
  return(simple_command(drizzle, COM_SET_OPTION, buff, sizeof(buff), 0));
 
403
}
 
404
 
 
405
 
 
406
const char *cli_read_statistics(DRIZZLE *drizzle)
 
407
{
 
408
  drizzle->net.read_pos[drizzle->packet_length]=0;  /* End of stat string */
 
409
  if (!drizzle->net.read_pos[0])
 
410
  {
 
411
    drizzle_set_error(drizzle, CR_WRONG_HOST_INFO, sqlstate_get_unknown());
 
412
    return drizzle->net.last_error;
 
413
  }
 
414
  return (char*) drizzle->net.read_pos;
 
415
}
 
416
 
 
417
 
 
418
int
 
419
drizzle_ping(DRIZZLE *drizzle)
 
420
{
 
421
  int res;
 
422
  res= simple_command(drizzle,COM_PING,0,0,0);
 
423
  if (res == CR_SERVER_LOST && drizzle->reconnect)
 
424
    res= simple_command(drizzle,COM_PING,0,0,0);
 
425
  return(res);
 
426
}
 
427
 
 
428
 
 
429
const char *
 
430
drizzle_get_server_info(const DRIZZLE *drizzle)
 
431
{
 
432
  return((char*) drizzle->server_version);
 
433
}
 
434
 
 
435
 
 
436
const char *
 
437
drizzle_get_host_info(const DRIZZLE *drizzle)
 
438
{
 
439
  return(drizzle->host_info);
 
440
}
 
441
 
 
442
 
 
443
uint32_t
 
444
drizzle_get_proto_info(const DRIZZLE *drizzle)
 
445
{
 
446
  return (drizzle->protocol_version);
 
447
}
 
448
 
 
449
const char *
 
450
drizzle_get_client_info(void)
 
451
{
 
452
  return (char*) DRIZZLE_SERVER_VERSION;
 
453
}
 
454
 
 
455
uint32_t drizzle_get_client_version(void)
 
456
{
 
457
  return DRIZZLE_VERSION_ID;
 
458
}
 
459
 
 
460
bool drizzle_eof(const DRIZZLE_RES *res)
 
461
{
 
462
  return res->eof;
 
463
}
 
464
 
 
465
const DRIZZLE_FIELD * drizzle_fetch_field_direct(const DRIZZLE_RES *res, unsigned int fieldnr)
 
466
{
 
467
  return &(res)->fields[fieldnr];
 
468
}
 
469
 
 
470
const DRIZZLE_FIELD * drizzle_fetch_fields(const DRIZZLE_RES *res)
 
471
{
 
472
  return res->fields;
 
473
}
 
474
 
 
475
DRIZZLE_ROW_OFFSET drizzle_row_tell(const DRIZZLE_RES *res)
 
476
{
 
477
  return res->data_cursor;
 
478
}
 
479
 
 
480
DRIZZLE_FIELD_OFFSET drizzle_field_tell(const DRIZZLE_RES *res)
 
481
{
 
482
  return res->current_field;
 
483
}
 
484
 
 
485
/* DRIZZLE */
 
486
 
 
487
unsigned int drizzle_field_count(const DRIZZLE *drizzle)
 
488
{
 
489
  return drizzle->field_count;
 
490
}
 
491
 
 
492
uint64_t drizzle_affected_rows(const DRIZZLE *drizzle)
 
493
{
 
494
  return drizzle->affected_rows;
 
495
}
 
496
 
 
497
uint64_t drizzle_insert_id(const DRIZZLE *drizzle)
 
498
{
 
499
  return drizzle->insert_id;
 
500
}
 
501
 
 
502
const char * drizzle_sqlstate(const DRIZZLE *drizzle)
 
503
{
 
504
  return drizzle ? drizzle->net.sqlstate : sqlstate_get_cant_connect();
 
505
}
 
506
 
 
507
uint32_t drizzle_warning_count(const DRIZZLE *drizzle)
 
508
{
 
509
  return drizzle->warning_count;
 
510
}
 
511
 
 
512
const char * drizzle_info(const DRIZZLE *drizzle)
 
513
{
 
514
  return drizzle->info;
 
515
}
 
516
 
 
517
uint32_t drizzle_thread_id(const DRIZZLE *drizzle)
 
518
{
 
519
  return drizzle->thread_id;
 
520
}
 
521
 
 
522
/****************************************************************************
 
523
  Some support functions
 
524
****************************************************************************/
 
525
 
 
526
/*
 
527
  Functions called my my_net_init() to set some application specific variables
 
528
*/
 
529
 
 
530
void my_net_local_init(NET *net)
 
531
{
 
532
  net->max_packet=   (uint32_t) net_buffer_length;
 
533
  my_net_set_read_timeout(net, CLIENT_NET_READ_TIMEOUT);
 
534
  my_net_set_write_timeout(net, CLIENT_NET_WRITE_TIMEOUT);
 
535
  net->retry_count=  1;
 
536
  net->max_packet_size= (net_buffer_length > max_allowed_packet) ?
 
537
    net_buffer_length : max_allowed_packet;
 
538
}
 
539
 
 
540
/*
 
541
  This function is used to create HEX string that you
 
542
  can use in a SQL statement in of the either ways:
 
543
    INSERT INTO blob_column VALUES (0xAABBCC);  (any DRIZZLE version)
 
544
    INSERT INTO blob_column VALUES (X'AABBCC'); 
 
545
  
 
546
  The string in "from" is encoded to a HEX string.
 
547
  The result is placed in "to" and a terminating null byte is appended.
 
548
  
 
549
  The string pointed to by "from" must be "length" bytes long.
 
550
  You must allocate the "to" buffer to be at least length*2+1 bytes long.
 
551
  Each character needs two bytes, and you need room for the terminating
 
552
  null byte. When drizzle_hex_string() returns, the contents of "to" will
 
553
  be a null-terminated string. The return value is the length of the
 
554
  encoded string, not including the terminating null character.  The return value does not contain any leading 0x or a leading X' and
 
555
  trailing '. The caller must supply whichever of those is desired.
 
556
*/
 
557
 
 
558
uint32_t
 
559
drizzle_hex_string(char *to, const char *from, uint32_t length)
 
560
{
 
561
  char *to0= to;
 
562
  const char *end;
 
563
            
 
564
  for (end= from + length; from < end; from++)
 
565
  {
 
566
    *to++= _dig_vec_upper[((unsigned char) *from) >> 4];
 
567
    *to++= _dig_vec_upper[((unsigned char) *from) & 0x0F];
 
568
  }
 
569
  *to= '\0';
 
570
  return (uint32_t) (to-to0);
 
571
}
 
572
 
 
573
/*
 
574
  Add escape characters to a string (blob?) to make it suitable for a insert
 
575
  to should at least have place for length*2+1 chars
 
576
  Returns the length of the to string
 
577
*/
 
578
 
 
579
uint32_t
 
580
drizzle_escape_string(char *to,const char *from, uint32_t length)
 
581
{
 
582
  const char *to_start= to;
 
583
  const char *end, *to_end=to_start + 2*length;
 
584
  bool overflow= false;
 
585
  for (end= from + length; from < end; from++)
 
586
  {
 
587
    uint32_t tmp_length;
 
588
    char escape= 0;
 
589
    if (!U8_IS_SINGLE(*from))
 
590
    {
 
591
      tmp_length= U8_LENGTH(*from);
 
592
      if (to + tmp_length > to_end)
 
593
      {
 
594
        overflow= true;
 
595
        break;
 
596
      }
 
597
      while (tmp_length--)
 
598
        *to++= *from++;
 
599
      from--;
 
600
      continue;
 
601
    }
 
602
    switch (*from) {
 
603
    case 0:                             /* Must be escaped for 'mysql' */
 
604
      escape= '0';
 
605
      break;
 
606
    case '\n':                          /* Must be escaped for logs */
 
607
      escape= 'n';
 
608
      break;
 
609
    case '\r':
 
610
      escape= 'r';
 
611
      break;
 
612
    case '\\':
 
613
      escape= '\\';
 
614
      break;
 
615
    case '\'':
 
616
      escape= '\'';
 
617
      break;
 
618
    case '"':                           /* Better safe than sorry */
 
619
      escape= '"';
 
620
      break;
 
621
    case '\032':                        /* This gives problems on Win32 */
 
622
      escape= 'Z';
 
623
      break;
 
624
    }
 
625
    if (escape)
 
626
    {
 
627
      if (to + 2 > to_end)
 
628
      {
 
629
        overflow= true;
 
630
        break;
 
631
      }
 
632
      *to++= '\\';
 
633
      *to++= escape;
 
634
    }
 
635
    else
 
636
    {
 
637
      if (to + 1 > to_end)
 
638
      {
 
639
        overflow= true;
 
640
        break;
 
641
      }
 
642
      *to++= *from;
 
643
    }
 
644
  }
 
645
  *to= 0;
 
646
  return overflow ? (size_t) -1 : (size_t) (to - to_start);
 
647
}
 
648
 
 
649
int cli_unbuffered_fetch(DRIZZLE *drizzle, char **row)
 
650
{
 
651
  if (packet_error == cli_safe_read(drizzle))
 
652
    return 1;
 
653
 
 
654
  *row= ((drizzle->net.read_pos[0] == DRIZZLE_PROTOCOL_NO_MORE_DATA) ? NULL :
 
655
   (char*) (drizzle->net.read_pos+1));
 
656
  return 0;
 
657
}
 
658
 
 
659
/********************************************************************
 
660
 Transactional APIs
 
661
*********************************************************************/
 
662
 
 
663
/*
 
664
  Commit the current transaction
 
665
*/
 
666
 
 
667
bool drizzle_commit(DRIZZLE *drizzle)
 
668
{
 
669
  return((bool) drizzle_real_query(drizzle, "commit", 6));
 
670
}
 
671
 
 
672
/*
 
673
  Rollback the current transaction
 
674
*/
 
675
 
 
676
bool drizzle_rollback(DRIZZLE *drizzle)
 
677
{
 
678
  return((bool) drizzle_real_query(drizzle, "rollback", 8));
 
679
}
 
680
 
 
681
 
 
682
/*
 
683
  Set autocommit to either true or false
 
684
*/
 
685
 
 
686
bool drizzle_autocommit(DRIZZLE *drizzle, bool auto_mode)
 
687
{
 
688
  return((bool) drizzle_real_query(drizzle, auto_mode ?
 
689
                                         "set autocommit=1":"set autocommit=0",
 
690
                                         16));
 
691
}
 
692
 
 
693
 
 
694
/********************************************************************
 
695
 Multi query execution + SPs APIs
 
696
*********************************************************************/
 
697
 
 
698
/*
 
699
  Returns true/false to indicate whether any more query results exist
 
700
  to be read using drizzle_next_result()
 
701
*/
 
702
 
 
703
bool drizzle_more_results(const DRIZZLE *drizzle)
 
704
{
 
705
  return (drizzle->server_status & SERVER_MORE_RESULTS_EXISTS) ? true:false;
 
706
}
 
707
 
 
708
 
 
709
/*
 
710
  Reads and returns the next query results
 
711
*/
 
712
int drizzle_next_result(DRIZZLE *drizzle)
 
713
{
 
714
  if (drizzle->status != DRIZZLE_STATUS_READY)
 
715
  {
 
716
    drizzle_set_error(drizzle, CR_COMMANDS_OUT_OF_SYNC, sqlstate_get_unknown());
 
717
    return(1);
 
718
  }
 
719
 
 
720
  net_clear_error(&drizzle->net);
 
721
  drizzle->affected_rows= ~(uint64_t) 0;
 
722
 
 
723
  if (drizzle->server_status & SERVER_MORE_RESULTS_EXISTS)
 
724
    return((*drizzle->methods->next_result)(drizzle));
 
725
 
 
726
  return(-1);        /* No more results */
 
727
}
 
728
 
 
729
 
 
730
DRIZZLE_RES * drizzle_use_result(DRIZZLE *drizzle)
 
731
{
 
732
  return (*drizzle->methods->use_result)(drizzle);
 
733
}
 
734
 
 
735
bool drizzle_read_query_result(DRIZZLE *drizzle)
 
736
{
 
737
  return (*drizzle->methods->read_query_result)(drizzle);
 
738
}
 
739