← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/libdrizzle.c

pandora-build v0.72 - Moved remaining hard-coded tests into pandora-build
macros.
Add PANDORA_DRIZZLE_BUILD to run the extra checks that drizzle needs that 
plugins would also need to run so we can just use that macro in generated
external plugin builds.
Added support to register_plugins for external plugin building.
Renamed register_plugins.py to pandora-plugin.

Show diffs side-by-side

added added

removed removed

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