← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/libdrizzle.c

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/libdrizzle.c
1
 
/* Copyright (C) 2000-2004 MySQL AB
 
1
/* Copyright (C) 2000-2004 DRIZZLE AB
2
2
 
3
3
   This program is free software; you can redistribute it and/or modify
4
4
   it under the terms of the GNU General Public License as published by
17
17
   along with this program; if not, write to the Free Software
18
18
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
19
19
 
20
 
#include <my_global.h>
21
 
#include <my_sys.h>
22
 
#include <my_time.h>
23
 
#include <mysys_err.h>
24
 
#include <m_string.h>
25
 
#include <m_ctype.h>
 
20
#include <drizzled/global.h>
 
21
#include <mysys/my_sys.h>
 
22
#include "my_time.h"
 
23
#include <mysys/mysys_err.h>
 
24
#include <mystrings/m_string.h>
 
25
#include <mystrings/m_ctype.h>
26
26
#include "drizzle.h"
27
 
#include "drizzle_version.h"
28
 
#include "mysqld_error.h"
29
27
#include "errmsg.h"
30
 
#include <violite.h>
 
28
#include <vio/violite.h>
31
29
#include <sys/stat.h>
32
30
#include <signal.h>
33
31
#include <time.h>
34
 
#ifdef   HAVE_PWD_H
 
32
#ifdef   HAVE_PWD_H
35
33
#include <pwd.h>
36
34
#endif
37
35
 
52
50
#ifdef HAVE_SYS_UN_H
53
51
#include <sys/un.h>
54
52
#endif
55
 
#include <my_pthread.h>                         /* because of signal()  */
 
53
#include <mysys/my_pthread.h>        /* because of signal()  */
56
54
#ifndef INADDR_NONE
57
 
#define INADDR_NONE     -1
 
55
#define INADDR_NONE  -1
58
56
#endif
59
57
 
60
58
#include <sql_common.h>
63
61
#undef net_buffer_length
64
62
#undef max_allowed_packet
65
63
 
66
 
uint32_t                net_buffer_length= 8192;
67
 
uint32_t                max_allowed_packet= 1024L*1024L*1024L;
 
64
uint32_t     net_buffer_length= 8192;
 
65
uint32_t    max_allowed_packet= 1024L*1024L*1024L;
68
66
 
69
67
#include <errno.h>
70
68
#define SOCKET_ERROR -1
78
76
 
79
77
static void append_wild(char *to,char *end,const char *wild);
80
78
 
81
 
static my_bool mysql_client_init= 0;
82
 
static my_bool org_my_init_done= 0;
83
 
 
84
 
 
85
 
/*
86
 
  Initialize the MySQL client library
87
 
 
88
 
  SYNOPSIS
89
 
    mysql_server_init()
90
 
 
91
 
  NOTES
92
 
    Should be called before doing any other calls to the MySQL
93
 
    client library to initialize thread specific variables etc.
94
 
    It's called by mysql_init() to ensure that things will work for
95
 
    old not threaded applications that doesn't call mysql_server_init()
96
 
    directly.
97
 
 
98
 
  RETURN
99
 
    0  ok
100
 
    1  could not initialize environment (out of memory or thread keys)
101
 
*/
102
 
 
103
 
int STDCALL mysql_server_init(int argc __attribute__((unused)),
104
 
                              char **argv __attribute__((unused)),
105
 
                              char **groups __attribute__((unused)))
106
 
{
107
 
  int result= 0;
108
 
  if (!mysql_client_init)
109
 
  {
110
 
    mysql_client_init=1;
111
 
    org_my_init_done=my_init_done;
112
 
    if (my_init())                              /* Will init threads */
113
 
      return 1;
114
 
    init_client_errs();
115
 
    if (!mysql_port)
116
 
    {
117
 
      mysql_port = MYSQL_PORT;
118
 
      {
119
 
        struct servent *serv_ptr;
120
 
        char    *env;
121
 
 
122
 
        /*
123
 
          if builder specifically requested a default port, use that
124
 
          (even if it coincides with our factory default).
125
 
          only if they didn't do we check /etc/services (and, failing
126
 
          on that, fall back to the factory default of 4427).
127
 
          either default can be overridden by the environment variable
128
 
          MYSQL_TCP_PORT, which in turn can be overridden with command
129
 
          line options.
130
 
        */
131
 
 
132
 
#if MYSQL_PORT_DEFAULT == 0
133
 
        if ((serv_ptr = getservbyname("mysql", "tcp")))
134
 
          mysql_port = (uint) ntohs((ushort) serv_ptr->s_port);
135
 
#endif
136
 
        if ((env = getenv("MYSQL_TCP_PORT")))
137
 
          mysql_port =(uint) atoi(env);
138
 
      }
139
 
    }
140
 
    if (!mysql_unix_port)
141
 
    {
142
 
      char *env;
143
 
      mysql_unix_port = (char*) MYSQL_UNIX_ADDR;
144
 
      if ((env = getenv("MYSQL_UNIX_PORT")))
145
 
        mysql_unix_port = env;
146
 
    }
147
 
#if defined(SIGPIPE)
148
 
    (void) signal(SIGPIPE, SIG_IGN);
149
 
#endif
150
 
  }
151
 
  else
152
 
    result= (int)my_thread_init();         /* Init if new thread */
153
 
  return result;
154
 
}
155
 
 
156
 
 
157
 
/*
158
 
  Free all memory and resources used by the client library
159
 
 
160
 
  NOTES
161
 
    When calling this there should not be any other threads using
162
 
    the library.
163
 
 
164
 
    To make things simpler when used with windows dll's (which calls this
165
 
    function automaticly), it's safe to call this function multiple times.
166
 
*/
167
 
 
168
 
 
169
 
void STDCALL mysql_server_end()
170
 
{
171
 
  if (!mysql_client_init)
172
 
    return;
173
 
 
174
 
  finish_client_errs();
175
 
  vio_end();
176
 
 
177
 
  /* If library called my_init(), free memory allocated by it */
178
 
  if (!org_my_init_done)
179
 
  {
180
 
    my_end(0);
181
 
  }
182
 
  else
183
 
  {
184
 
    free_charsets();
185
 
    mysql_thread_end();
186
 
  }
187
 
 
188
 
  mysql_client_init= org_my_init_done= 0;
189
 
#ifdef EMBEDDED_SERVER
190
 
  if (stderror_file)
191
 
  {
192
 
    fclose(stderror_file);
193
 
    stderror_file= 0;
194
 
  }
195
 
#endif
196
 
}
197
 
 
198
 
static MYSQL_PARAMETERS mysql_internal_parameters=
 
79
 
 
80
static DRIZZLE_PARAMETERS drizzle_internal_parameters=
199
81
{&max_allowed_packet, &net_buffer_length, 0};
200
82
 
201
 
MYSQL_PARAMETERS *STDCALL mysql_get_parameters(void)
 
83
DRIZZLE_PARAMETERS *STDCALL drizzle_get_parameters(void)
202
84
{
203
 
  return &mysql_internal_parameters;
 
85
  return &drizzle_internal_parameters;
204
86
}
205
87
 
206
 
my_bool STDCALL mysql_thread_init()
 
88
bool STDCALL drizzle_thread_init()
207
89
{
208
90
  return my_thread_init();
209
91
}
210
92
 
211
 
void STDCALL mysql_thread_end()
 
93
void STDCALL drizzle_thread_end()
212
94
{
213
95
  my_thread_end();
214
96
}
221
103
static void
222
104
append_wild(char *to, char *end, const char *wild)
223
105
{
224
 
  end-=5;                                       /* Some extra */
 
106
  end-=5;          /* Some extra */
225
107
  if (wild && wild[0])
226
108
  {
227
109
    to=strmov(to," like '");
228
110
    while (*wild && to < end)
229
111
    {
230
112
      if (*wild == '\\' || *wild == '\'')
231
 
        *to++='\\';
 
113
  *to++='\\';
232
114
      *to++= *wild++;
233
115
    }
234
 
    if (*wild)                                  /* Too small buffer */
235
 
      *to++='%';                                /* Nicer this way */
 
116
    if (*wild)          /* Too small buffer */
 
117
      *to++='%';        /* Nicer this way */
236
118
    to[0]='\'';
237
119
    to[1]=0;
238
120
  }
258
140
**************************************************************************/
259
141
 
260
142
#ifdef USE_OLD_FUNCTIONS
261
 
MYSQL * STDCALL
262
 
mysql_connect(MYSQL *mysql,const char *host,
263
 
              const char *user, const char *passwd)
 
143
DRIZZLE * STDCALL
 
144
drizzle_connect(DRIZZLE *drizzle,const char *host,
 
145
        const char *user, const char *passwd)
264
146
{
265
 
  MYSQL *res;
266
 
  mysql=mysql_init(mysql);                      /* Make it thread safe */
 
147
  DRIZZLE *res;
 
148
  drizzle=drizzle_init(drizzle);      /* Make it thread safe */
267
149
  {
268
 
    if (!(res=mysql_real_connect(mysql,host,user,passwd,NullS,0,NullS,0)))
 
150
    if (!(res=drizzle_connect(drizzle,host,user,passwd,NullS,0,NullS,0)))
269
151
    {
270
 
      if (mysql->free_me)
271
 
        my_free((uchar*) mysql,MYF(0));
 
152
      if (drizzle->free_me && drizzle)
 
153
        free((uchar*) drizzle);
272
154
    }
273
 
    mysql->reconnect= 1;
 
155
    drizzle->reconnect= 1;
274
156
    return(res);
275
157
  }
276
158
}
281
163
  Change user and database
282
164
**************************************************************************/
283
165
 
284
 
int cli_read_change_user_result(MYSQL *mysql, char *buff, const char *passwd)
 
166
int cli_read_change_user_result(DRIZZLE *drizzle, char *buff, const char *passwd)
285
167
{
286
168
  (void)buff;
287
169
  (void)passwd;
288
170
  ulong pkt_length;
289
171
 
290
 
  pkt_length= cli_safe_read(mysql);
 
172
  pkt_length= cli_safe_read(drizzle);
291
173
  
292
174
  if (pkt_length == packet_error)
293
175
    return 1;
295
177
  return 0;
296
178
}
297
179
 
298
 
my_bool STDCALL mysql_change_user(MYSQL *mysql, const char *user,
299
 
                                  const char *passwd, const char *db)
 
180
bool STDCALL drizzle_change_user(DRIZZLE *drizzle, const char *user,
 
181
          const char *passwd, const char *db)
300
182
{
301
183
  char buff[USERNAME_LENGTH+SCRAMBLED_PASSWORD_CHAR_LENGTH+NAME_LEN+2];
302
184
  char *end= buff;
303
185
  int rc;
304
 
  CHARSET_INFO *saved_cs= mysql->charset;
 
186
  CHARSET_INFO *saved_cs= drizzle->charset;
305
187
 
306
188
  /* Get the connection-default character set. */
307
189
 
308
 
  if (mysql_init_character_set(mysql))
 
190
  if (drizzle_init_character_set(drizzle))
309
191
  {
310
 
    mysql->charset= saved_cs;
 
192
    drizzle->charset= saved_cs;
311
193
    return(true);
312
194
  }
313
195
 
326
208
  {
327
209
    {
328
210
      *end++= SCRAMBLE_LENGTH;
329
 
      scramble(end, mysql->scramble, passwd);
 
211
      scramble(end, drizzle->scramble, passwd);
330
212
      end+= SCRAMBLE_LENGTH;
331
213
    }
332
214
  }
337
219
 
338
220
  /* Add character set number. */
339
221
 
340
 
  if (mysql->server_capabilities & CLIENT_SECURE_CONNECTION)
 
222
  if (drizzle->server_capabilities & CLIENT_SECURE_CONNECTION)
341
223
  {
342
 
    int2store(end, (ushort) mysql->charset->number);
 
224
    int2store(end, (ushort) drizzle->charset->number);
343
225
    end+= 2;
344
226
  }
345
227
 
346
228
  /* Write authentication package */
347
 
  (void)simple_command(mysql,COM_CHANGE_USER, (uchar*) buff, (ulong) (end-buff), 1);
 
229
  (void)simple_command(drizzle,COM_CHANGE_USER, (uchar*) buff, (ulong) (end-buff), 1);
348
230
 
349
 
  rc= (*mysql->methods->read_change_user_result)(mysql, buff, passwd);
 
231
  rc= (*drizzle->methods->read_change_user_result)(drizzle, buff, passwd);
350
232
 
351
233
  if (rc == 0)
352
234
  {
353
235
    /* Free old connect information */
354
 
    my_free(mysql->user,MYF(MY_ALLOW_ZERO_PTR));
355
 
    my_free(mysql->passwd,MYF(MY_ALLOW_ZERO_PTR));
356
 
    my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
 
236
    if(drizzle->user)
 
237
      free(drizzle->user);
 
238
    if(drizzle->passwd)
 
239
      free(drizzle->passwd);
 
240
    if(drizzle->db)
 
241
      free(drizzle->db);
357
242
 
358
243
    /* alloc new connect information */
359
 
    mysql->user=  my_strdup(user,MYF(MY_WME));
360
 
    mysql->passwd=my_strdup(passwd,MYF(MY_WME));
361
 
    mysql->db=    db ? my_strdup(db,MYF(MY_WME)) : 0;
 
244
    drizzle->user=  my_strdup(user,MYF(MY_WME));
 
245
    drizzle->passwd=my_strdup(passwd,MYF(MY_WME));
 
246
    drizzle->db=    db ? my_strdup(db,MYF(MY_WME)) : 0;
362
247
  }
363
248
  else
364
249
  {
365
 
    mysql->charset= saved_cs;
 
250
    drizzle->charset= saved_cs;
366
251
  }
367
252
 
368
253
  return(rc);
376
261
void read_user_name(char *name)
377
262
{
378
263
  if (geteuid() == 0)
379
 
    (void) strmov(name,"root");         /* allow use of surun */
 
264
    (void) strmov(name,"root");    /* allow use of surun */
380
265
  else
381
266
  {
382
267
#ifdef HAVE_GETPWUID
385
270
    if ((str=getlogin()) == NULL)
386
271
    {
387
272
      if ((skr=getpwuid(geteuid())) != NULL)
388
 
        str=skr->pw_name;
 
273
  str=skr->pw_name;
389
274
      else if (!(str=getenv("USER")) && !(str=getenv("LOGNAME")) &&
390
 
               !(str=getenv("LOGIN")))
391
 
        str="UNKNOWN_USER";
 
275
         !(str=getenv("LOGIN")))
 
276
  str="UNKNOWN_USER";
392
277
    }
393
278
    (void) strmake(name,str,USERNAME_LENGTH);
394
279
#elif HAVE_CUSERID
400
285
  return;
401
286
}
402
287
 
403
 
my_bool handle_local_infile(MYSQL *mysql, const char *net_filename)
 
288
bool handle_local_infile(DRIZZLE *drizzle, const char *net_filename)
404
289
{
405
 
  my_bool result= 1;
406
 
  uint packet_length=MY_ALIGN(mysql->net.max_packet-16,IO_SIZE);
407
 
  NET *net= &mysql->net;
 
290
  bool result= true;
 
291
  uint packet_length=MY_ALIGN(drizzle->net.max_packet-16,IO_SIZE);
 
292
  NET *net= &drizzle->net;
408
293
  int readcount;
409
294
  void *li_ptr;          /* pass state to local_infile functions */
410
 
  char *buf;            /* buffer to be filled by local_infile_read */
411
 
  struct st_mysql_options *options= &mysql->options;
 
295
  char *buf;    /* buffer to be filled by local_infile_read */
 
296
  struct st_drizzle_options *options= &drizzle->options;
412
297
 
413
298
  /* check that we've got valid callback functions */
414
299
  if (!(options->local_infile_init &&
415
 
        options->local_infile_read &&
416
 
        options->local_infile_end &&
417
 
        options->local_infile_error))
 
300
  options->local_infile_read &&
 
301
  options->local_infile_end &&
 
302
  options->local_infile_error))
418
303
  {
419
304
    /* if any of the functions is invalid, set the default */
420
 
    mysql_set_local_infile_default(mysql);
 
305
    drizzle_set_local_infile_default(drizzle);
421
306
  }
422
307
 
423
308
  /* copy filename into local memory and allocate read buffer */
424
 
  if (!(buf=my_malloc(packet_length, MYF(0))))
 
309
  if (!(buf=malloc(packet_length)))
425
310
  {
426
 
    set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
 
311
    set_drizzle_error(drizzle, CR_OUT_OF_MEMORY, unknown_sqlstate);
427
312
    return(1);
428
313
  }
429
314
 
443
328
 
444
329
  /* read blocks of data from local infile callback */
445
330
  while ((readcount =
446
 
          (*options->local_infile_read)(li_ptr, buf,
447
 
                                        packet_length)) > 0)
 
331
    (*options->local_infile_read)(li_ptr, buf,
 
332
          packet_length)) > 0)
448
333
  {
449
334
    if (my_net_write(net, (uchar*) buf, readcount))
450
335
    {
455
340
  /* Send empty packet to mark end of file */
456
341
  if (my_net_write(net, (const uchar*) "", 0) || net_flush(net))
457
342
  {
458
 
    set_mysql_error(mysql, CR_SERVER_LOST, unknown_sqlstate);
 
343
    set_drizzle_error(drizzle, CR_SERVER_LOST, unknown_sqlstate);
459
344
    goto err;
460
345
  }
461
346
 
468
353
    goto err;
469
354
  }
470
355
 
471
 
  result=0;                                     /* Ok */
 
356
  result=false;                                 /* Ok */
472
357
 
473
358
err:
474
359
  /* free up memory allocated with _init, usually */
475
360
  (*options->local_infile_end)(li_ptr);
476
 
  my_free(buf, MYF(0));
 
361
  if(buf)
 
362
    free(buf);
477
363
  return(result);
478
364
}
479
365
 
496
382
 
497
383
  SYNOPSIS
498
384
    default_local_infile_init()
499
 
    ptr                 Store pointer to internal data here
500
 
    filename            File name to open. This may be in unix format !
 
385
    ptr      Store pointer to internal data here
 
386
    filename    File name to open. This may be in unix format !
501
387
 
502
388
 
503
389
  NOTES
505
391
    guarantees that default_local_infile_end() is called.
506
392
 
507
393
  RETURN
508
 
    0   ok
509
 
    1   error
 
394
    0  ok
 
395
    1  error
510
396
*/
511
397
 
512
398
static int default_local_infile_init(void **ptr, const char *filename,
516
402
  char tmp_name[FN_REFLEN];
517
403
 
518
404
  if (!(*ptr= data= ((default_local_infile_data *)
519
 
                     my_malloc(sizeof(default_local_infile_data),  MYF(0)))))
 
405
                     malloc(sizeof(default_local_infile_data)))))
520
406
    return 1; /* out of memory */
521
407
 
522
408
  data->error_msg[0]= 0;
540
426
 
541
427
  SYNOPSIS
542
428
    default_local_infile_read()
543
 
    ptr                 Points to handle allocated by _init
544
 
    buf                 Read data here
545
 
    buf_len             Ammount of data to read
 
429
    ptr      Points to handle allocated by _init
 
430
    buf      Read data here
 
431
    buf_len    Ammount of data to read
546
432
 
547
433
  RETURN
548
 
    > 0         number of bytes read
549
 
    == 0        End of data
550
 
    < 0         Error
 
434
    > 0    number of bytes read
 
435
    == 0  End of data
 
436
    < 0    Error
551
437
*/
552
438
 
553
439
static int default_local_infile_read(void *ptr, char *buf, uint buf_len)
571
457
 
572
458
  SYNOPSIS
573
459
    default_local_infile_end()
574
 
    ptr                 Points to handle allocated by _init
575
 
                        May be NULL if _init failed!
 
460
    ptr      Points to handle allocated by _init
 
461
      May be NULL if _init failed!
576
462
 
577
463
  RETURN
578
464
*/
580
466
static void default_local_infile_end(void *ptr)
581
467
{
582
468
  default_local_infile_data *data= (default_local_infile_data *) ptr;
583
 
  if (data)                                     /* If not error on open */
 
469
  if (data)          /* If not error on open */
584
470
  {
585
471
    if (data->fd >= 0)
586
472
      my_close(data->fd, MYF(MY_WME));
587
 
    my_free(ptr, MYF(MY_WME));
 
473
    free(ptr);
588
474
  }
589
475
}
590
476
 
594
480
 
595
481
  SYNOPSIS
596
482
    default_local_infile_end()
597
 
    ptr                 Points to handle allocated by _init
598
 
                        May be NULL if _init failed!
599
 
    error_msg           Store error text here
600
 
    error_msg_len       Max lenght of error_msg
 
483
    ptr      Points to handle allocated by _init
 
484
      May be NULL if _init failed!
 
485
    error_msg    Store error text here
 
486
    error_msg_len  Max lenght of error_msg
601
487
 
602
488
  RETURN
603
489
    error message number
607
493
default_local_infile_error(void *ptr, char *error_msg, uint error_msg_len)
608
494
{
609
495
  default_local_infile_data *data = (default_local_infile_data *) ptr;
610
 
  if (data)                                     /* If not error on open */
 
496
  if (data)          /* If not error on open */
611
497
  {
612
498
    strmake(error_msg, data->error_msg, error_msg_len);
613
499
    return data->error_num;
619
505
 
620
506
 
621
507
void
622
 
mysql_set_local_infile_handler(MYSQL *mysql,
 
508
drizzle_set_local_infile_handler(DRIZZLE *drizzle,
623
509
                               int (*local_infile_init)(void **, const char *,
624
510
                               void *),
625
511
                               int (*local_infile_read)(void *, char *, uint),
627
513
                               int (*local_infile_error)(void *, char *, uint),
628
514
                               void *userdata)
629
515
{
630
 
  mysql->options.local_infile_init=  local_infile_init;
631
 
  mysql->options.local_infile_read=  local_infile_read;
632
 
  mysql->options.local_infile_end=   local_infile_end;
633
 
  mysql->options.local_infile_error= local_infile_error;
634
 
  mysql->options.local_infile_userdata = userdata;
 
516
  drizzle->options.local_infile_init=  local_infile_init;
 
517
  drizzle->options.local_infile_read=  local_infile_read;
 
518
  drizzle->options.local_infile_end=   local_infile_end;
 
519
  drizzle->options.local_infile_error= local_infile_error;
 
520
  drizzle->options.local_infile_userdata = userdata;
635
521
}
636
522
 
637
523
 
638
 
void mysql_set_local_infile_default(MYSQL *mysql)
 
524
void drizzle_set_local_infile_default(DRIZZLE *drizzle)
639
525
{
640
 
  mysql->options.local_infile_init=  default_local_infile_init;
641
 
  mysql->options.local_infile_read=  default_local_infile_read;
642
 
  mysql->options.local_infile_end=   default_local_infile_end;
643
 
  mysql->options.local_infile_error= default_local_infile_error;
 
526
  drizzle->options.local_infile_init=  default_local_infile_init;
 
527
  drizzle->options.local_infile_read=  default_local_infile_read;
 
528
  drizzle->options.local_infile_end=   default_local_infile_end;
 
529
  drizzle->options.local_infile_error= default_local_infile_error;
644
530
}
645
531
 
646
532
 
647
533
/**************************************************************************
648
534
  Do a query. If query returned rows, free old rows.
649
 
  Read data by mysql_store_result or by repeat call of mysql_fetch_row
 
535
  Read data by drizzle_store_result or by repeat call of drizzle_fetch_row
650
536
**************************************************************************/
651
537
 
652
538
int STDCALL
653
 
mysql_query(MYSQL *mysql, const char *query)
 
539
drizzle_query(DRIZZLE *drizzle, const char *query)
654
540
{
655
 
  return mysql_real_query(mysql,query, (uint) strlen(query));
 
541
  return drizzle_real_query(drizzle,query, (uint) strlen(query));
656
542
}
657
543
 
658
544
 
660
546
  Return next field of the query results
661
547
**************************************************************************/
662
548
 
663
 
MYSQL_FIELD * STDCALL
664
 
mysql_fetch_field(MYSQL_RES *result)
 
549
DRIZZLE_FIELD * STDCALL
 
550
drizzle_fetch_field(DRIZZLE_RES *result)
665
551
{
666
552
  if (result->current_field >= result->field_count)
667
553
    return(NULL);
674
560
**************************************************************************/
675
561
 
676
562
void STDCALL
677
 
mysql_data_seek(MYSQL_RES *result, uint64_t row)
 
563
drizzle_data_seek(DRIZZLE_RES *result, uint64_t row)
678
564
{
679
 
  MYSQL_ROWS    *tmp=0;
 
565
  DRIZZLE_ROWS  *tmp=0;
680
566
  if (result->data)
681
567
    for (tmp=result->data->data; row-- && tmp ; tmp = tmp->next) ;
682
568
  result->current_row=0;
685
571
 
686
572
 
687
573
/*************************************************************************
688
 
  put the row or field cursor one a position one got from mysql_row_tell()
689
 
  This doesn't restore any data. The next mysql_fetch_row or
690
 
  mysql_fetch_field will return the next row or field after the last used
 
574
  put the row or field cursor one a position one got from DRIZZLE_ROW_tell()
 
575
  This doesn't restore any data. The next drizzle_fetch_row or
 
576
  drizzle_fetch_field will return the next row or field after the last used
691
577
*************************************************************************/
692
578
 
693
 
MYSQL_ROW_OFFSET STDCALL
694
 
mysql_row_seek(MYSQL_RES *result, MYSQL_ROW_OFFSET row)
 
579
DRIZZLE_ROW_OFFSET STDCALL
 
580
drizzle_row_seek(DRIZZLE_RES *result, DRIZZLE_ROW_OFFSET row)
695
581
{
696
 
  MYSQL_ROW_OFFSET return_value=result->data_cursor;
 
582
  DRIZZLE_ROW_OFFSET return_value=result->data_cursor;
697
583
  result->current_row= 0;
698
584
  result->data_cursor= row;
699
585
  return return_value;
700
586
}
701
587
 
702
588
 
703
 
MYSQL_FIELD_OFFSET STDCALL
704
 
mysql_field_seek(MYSQL_RES *result, MYSQL_FIELD_OFFSET field_offset)
 
589
DRIZZLE_FIELD_OFFSET STDCALL
 
590
drizzle_field_seek(DRIZZLE_RES *result, DRIZZLE_FIELD_OFFSET field_offset)
705
591
{
706
 
  MYSQL_FIELD_OFFSET return_value=result->current_field;
 
592
  DRIZZLE_FIELD_OFFSET return_value=result->current_field;
707
593
  result->current_field=field_offset;
708
594
  return return_value;
709
595
}
713
599
  List all databases
714
600
*****************************************************************************/
715
601
 
716
 
MYSQL_RES * STDCALL
717
 
mysql_list_dbs(MYSQL *mysql, const char *wild)
 
602
DRIZZLE_RES * STDCALL
 
603
drizzle_list_dbs(DRIZZLE *drizzle, const char *wild)
718
604
{
719
605
  char buff[255];
720
606
 
721
607
  append_wild(strmov(buff,"show databases"),buff+sizeof(buff),wild);
722
 
  if (mysql_query(mysql,buff))
 
608
  if (drizzle_query(drizzle,buff))
723
609
    return(0);
724
 
  return (mysql_store_result(mysql));
 
610
  return (drizzle_store_result(drizzle));
725
611
}
726
612
 
727
613
 
730
616
  If wild is given then only the tables matching wild is returned
731
617
*****************************************************************************/
732
618
 
733
 
MYSQL_RES * STDCALL
734
 
mysql_list_tables(MYSQL *mysql, const char *wild)
 
619
DRIZZLE_RES * STDCALL
 
620
drizzle_list_tables(DRIZZLE *drizzle, const char *wild)
735
621
{
736
622
  char buff[255];
737
623
 
738
624
  append_wild(strmov(buff,"show tables"),buff+sizeof(buff),wild);
739
 
  if (mysql_query(mysql,buff))
 
625
  if (drizzle_query(drizzle,buff))
740
626
    return(0);
741
 
  return (mysql_store_result(mysql));
 
627
  return (drizzle_store_result(drizzle));
742
628
}
743
629
 
744
630
 
745
 
MYSQL_FIELD *cli_list_fields(MYSQL *mysql)
 
631
DRIZZLE_FIELD *cli_list_fields(DRIZZLE *drizzle)
746
632
{
747
 
  MYSQL_DATA *query;
748
 
  if (!(query= cli_read_rows(mysql,(MYSQL_FIELD*) 0, 
749
 
                             protocol_41(mysql) ? 8 : 6)))
 
633
  DRIZZLE_DATA *query;
 
634
  if (!(query= cli_read_rows(drizzle,(DRIZZLE_FIELD*) 0, 
 
635
           protocol_41(drizzle) ? 8 : 6)))
750
636
    return NULL;
751
637
 
752
 
  mysql->field_count= (uint) query->rows;
753
 
  return unpack_fields(query,&mysql->field_alloc,
754
 
                       mysql->field_count, 1, mysql->server_capabilities);
 
638
  drizzle->field_count= (uint) query->rows;
 
639
  return unpack_fields(query,&drizzle->field_alloc,
 
640
           drizzle->field_count, 1, drizzle->server_capabilities);
755
641
}
756
642
 
757
643
 
762
648
  show fields in 'table' like "wild"
763
649
**************************************************************************/
764
650
 
765
 
MYSQL_RES * STDCALL
766
 
mysql_list_fields(MYSQL *mysql, const char *table, const char *wild)
 
651
DRIZZLE_RES * STDCALL
 
652
drizzle_list_fields(DRIZZLE *drizzle, const char *table, const char *wild)
767
653
{
768
 
  MYSQL_RES   *result;
769
 
  MYSQL_FIELD *fields;
770
 
  char       buff[257],*end;
 
654
  DRIZZLE_RES   *result;
 
655
  DRIZZLE_FIELD *fields;
 
656
  char       buff[257],*end;
771
657
 
772
658
  end=strmake(strmake(buff, table,128)+1,wild ? wild : "",128);
773
 
  free_old_query(mysql);
774
 
  if (simple_command(mysql, COM_FIELD_LIST, (uchar*) buff,
 
659
  free_old_query(drizzle);
 
660
  if (simple_command(drizzle, COM_FIELD_LIST, (uchar*) buff,
775
661
                     (ulong) (end-buff), 1) ||
776
 
      !(fields= (*mysql->methods->list_fields)(mysql)))
777
 
    return(NULL);
778
 
 
779
 
  if (!(result = (MYSQL_RES *) my_malloc(sizeof(MYSQL_RES),
780
 
                                         MYF(MY_WME | MY_ZEROFILL))))
781
 
    return(NULL);
782
 
 
783
 
  result->methods= mysql->methods;
784
 
  result->field_alloc=mysql->field_alloc;
785
 
  mysql->fields=0;
786
 
  result->field_count = mysql->field_count;
 
662
      !(fields= (*drizzle->methods->list_fields)(drizzle)))
 
663
    return(NULL);
 
664
 
 
665
  if (!(result = (DRIZZLE_RES *) malloc(sizeof(DRIZZLE_RES))))
 
666
    return(NULL);
 
667
 
 
668
  result->methods= drizzle->methods;
 
669
  result->field_alloc=drizzle->field_alloc;
 
670
  drizzle->fields=0;
 
671
  result->field_count = drizzle->field_count;
787
672
  result->fields= fields;
788
673
  result->eof=1;
789
674
  return(result);
791
676
 
792
677
/* List all running processes (threads) in server */
793
678
 
794
 
MYSQL_RES * STDCALL
795
 
mysql_list_processes(MYSQL *mysql)
 
679
DRIZZLE_RES * STDCALL
 
680
drizzle_list_processes(DRIZZLE *drizzle)
796
681
{
797
 
  MYSQL_DATA *fields;
 
682
  DRIZZLE_DATA *fields;
798
683
  uint field_count;
799
684
  uchar *pos;
800
685
 
801
 
  if (simple_command(mysql,COM_PROCESS_INFO,0,0,0))
 
686
  if (simple_command(drizzle,COM_PROCESS_INFO,0,0,0))
802
687
    return(0);
803
 
  free_old_query(mysql);
804
 
  pos=(uchar*) mysql->net.read_pos;
 
688
  free_old_query(drizzle);
 
689
  pos=(uchar*) drizzle->net.read_pos;
805
690
  field_count=(uint) net_field_length(&pos);
806
 
  if (!(fields = (*mysql->methods->read_rows)(mysql,(MYSQL_FIELD*) 0,
807
 
                                              protocol_41(mysql) ? 7 : 5)))
 
691
  if (!(fields = (*drizzle->methods->read_rows)(drizzle,(DRIZZLE_FIELD*) 0,
 
692
                protocol_41(drizzle) ? 7 : 5)))
808
693
    return(NULL);
809
 
  if (!(mysql->fields=unpack_fields(fields,&mysql->field_alloc,field_count,0,
810
 
                                    mysql->server_capabilities)))
 
694
  if (!(drizzle->fields=unpack_fields(fields,&drizzle->field_alloc,field_count,0,
 
695
            drizzle->server_capabilities)))
811
696
    return(0);
812
 
  mysql->status=MYSQL_STATUS_GET_RESULT;
813
 
  mysql->field_count=field_count;
814
 
  return(mysql_store_result(mysql));
 
697
  drizzle->status=DRIZZLE_STATUS_GET_RESULT;
 
698
  drizzle->field_count=field_count;
 
699
  return(drizzle_store_result(drizzle));
815
700
}
816
701
 
817
702
 
818
703
#ifdef USE_OLD_FUNCTIONS
819
704
int  STDCALL
820
 
mysql_create_db(MYSQL *mysql, const char *db)
 
705
drizzle_create_db(DRIZZLE *drizzle, const char *db)
821
706
{
822
 
  return(simple_command(mysql,COM_CREATE_DB,db, (ulong) strlen(db),0));
 
707
  return(simple_command(drizzle,COM_CREATE_DB,db, (ulong) strlen(db),0));
823
708
}
824
709
 
825
710
 
826
711
int  STDCALL
827
 
mysql_drop_db(MYSQL *mysql, const char *db)
 
712
drizzle_drop_db(DRIZZLE *drizzle, const char *db)
828
713
{
829
 
  return(simple_command(mysql,COM_DROP_DB,db,(ulong) strlen(db),0));
 
714
  return(simple_command(drizzle,COM_DROP_DB,db,(ulong) strlen(db),0));
830
715
}
831
716
#endif
832
717
 
833
718
 
834
719
int STDCALL
835
 
mysql_shutdown(MYSQL *mysql, enum mysql_enum_shutdown_level shutdown_level)
 
720
drizzle_shutdown(DRIZZLE *drizzle, enum drizzle_enum_shutdown_level shutdown_level)
836
721
{
837
722
  uchar level[1];
838
723
  level[0]= (uchar) shutdown_level;
839
 
  return(simple_command(mysql, COM_SHUTDOWN, level, 1, 0));
 
724
  return(simple_command(drizzle, COM_SHUTDOWN, level, 1, 0));
840
725
}
841
726
 
842
727
 
843
728
int STDCALL
844
 
mysql_refresh(MYSQL *mysql,uint options)
 
729
drizzle_refresh(DRIZZLE *drizzle,uint options)
845
730
{
846
731
  uchar bits[1];
847
732
  bits[0]= (uchar) options;
848
 
  return(simple_command(mysql, COM_REFRESH, bits, 1, 0));
 
733
  return(simple_command(drizzle, COM_REFRESH, bits, 1, 0));
849
734
}
850
735
 
851
736
 
852
737
int32_t STDCALL
853
 
mysql_kill(MYSQL *mysql, uint32_t pid)
 
738
drizzle_kill(DRIZZLE *drizzle, uint32_t pid)
854
739
{
855
740
  uchar buff[4];
856
741
  int4store(buff,pid);
857
 
  return(simple_command(mysql,COM_PROCESS_KILL,buff,sizeof(buff),0));
 
742
  return(simple_command(drizzle,COM_PROCESS_KILL,buff,sizeof(buff),0));
858
743
}
859
744
 
860
745
 
861
746
int STDCALL
862
 
mysql_set_server_option(MYSQL *mysql, enum enum_mysql_set_option option)
 
747
drizzle_set_server_option(DRIZZLE *drizzle, enum enum_drizzle_set_option option)
863
748
{
864
749
  uchar buff[2];
865
750
  int2store(buff, (uint) option);
866
 
  return(simple_command(mysql, COM_SET_OPTION, buff, sizeof(buff), 0));
 
751
  return(simple_command(drizzle, COM_SET_OPTION, buff, sizeof(buff), 0));
867
752
}
868
753
 
869
754
 
870
 
const char *cli_read_statistics(MYSQL *mysql)
 
755
const char *cli_read_statistics(DRIZZLE *drizzle)
871
756
{
872
 
  mysql->net.read_pos[mysql->packet_length]=0;  /* End of stat string */
873
 
  if (!mysql->net.read_pos[0])
 
757
  drizzle->net.read_pos[drizzle->packet_length]=0;  /* End of stat string */
 
758
  if (!drizzle->net.read_pos[0])
874
759
  {
875
 
    set_mysql_error(mysql, CR_WRONG_HOST_INFO, unknown_sqlstate);
876
 
    return mysql->net.last_error;
 
760
    set_drizzle_error(drizzle, CR_WRONG_HOST_INFO, unknown_sqlstate);
 
761
    return drizzle->net.last_error;
877
762
  }
878
 
  return (char*) mysql->net.read_pos;
 
763
  return (char*) drizzle->net.read_pos;
879
764
}
880
765
 
881
766
 
882
767
const char * STDCALL
883
 
mysql_stat(MYSQL *mysql)
 
768
drizzle_stat(DRIZZLE *drizzle)
884
769
{
885
 
  if (simple_command(mysql,COM_STATISTICS,0,0,0))
886
 
    return(mysql->net.last_error);
887
 
  return((*mysql->methods->read_statistics)(mysql));
 
770
  if (simple_command(drizzle,COM_STATISTICS,0,0,0))
 
771
    return(drizzle->net.last_error);
 
772
  return((*drizzle->methods->read_statistics)(drizzle));
888
773
}
889
774
 
890
775
 
891
776
int STDCALL
892
 
mysql_ping(MYSQL *mysql)
 
777
drizzle_ping(DRIZZLE *drizzle)
893
778
{
894
779
  int res;
895
 
  res= simple_command(mysql,COM_PING,0,0,0);
896
 
  if (res == CR_SERVER_LOST && mysql->reconnect)
897
 
    res= simple_command(mysql,COM_PING,0,0,0);
 
780
  res= simple_command(drizzle,COM_PING,0,0,0);
 
781
  if (res == CR_SERVER_LOST && drizzle->reconnect)
 
782
    res= simple_command(drizzle,COM_PING,0,0,0);
898
783
  return(res);
899
784
}
900
785
 
901
786
 
902
787
const char * STDCALL
903
 
mysql_get_server_info(MYSQL *mysql)
 
788
drizzle_get_server_info(DRIZZLE *drizzle)
904
789
{
905
 
  return((char*) mysql->server_version);
 
790
  return((char*) drizzle->server_version);
906
791
}
907
792
 
908
793
 
909
794
const char * STDCALL
910
 
mysql_get_host_info(MYSQL *mysql)
 
795
drizzle_get_host_info(DRIZZLE *drizzle)
911
796
{
912
 
  return(mysql->host_info);
 
797
  return(drizzle->host_info);
913
798
}
914
799
 
915
800
 
916
801
uint STDCALL
917
 
mysql_get_proto_info(MYSQL *mysql)
 
802
drizzle_get_proto_info(DRIZZLE *drizzle)
918
803
{
919
 
  return (mysql->protocol_version);
 
804
  return (drizzle->protocol_version);
920
805
}
921
806
 
922
807
const char * STDCALL
923
 
mysql_get_client_info(void)
 
808
drizzle_get_client_info(void)
924
809
{
925
810
  return (char*) MYSQL_SERVER_VERSION;
926
811
}
927
812
 
928
 
uint32_t STDCALL mysql_get_client_version(void)
 
813
uint32_t STDCALL drizzle_get_client_version(void)
929
814
{
930
815
  return MYSQL_VERSION_ID;
931
816
}
932
817
 
933
 
my_bool STDCALL mysql_eof(MYSQL_RES *res)
 
818
bool STDCALL drizzle_eof(DRIZZLE_RES *res)
934
819
{
935
820
  return res->eof;
936
821
}
937
822
 
938
 
MYSQL_FIELD * STDCALL mysql_fetch_field_direct(MYSQL_RES *res,uint fieldnr)
 
823
DRIZZLE_FIELD * STDCALL drizzle_fetch_field_direct(DRIZZLE_RES *res,uint fieldnr)
939
824
{
940
825
  return &(res)->fields[fieldnr];
941
826
}
942
827
 
943
 
MYSQL_FIELD * STDCALL mysql_fetch_fields(MYSQL_RES *res)
 
828
DRIZZLE_FIELD * STDCALL drizzle_fetch_fields(DRIZZLE_RES *res)
944
829
{
945
830
  return (res)->fields;
946
831
}
947
832
 
948
 
MYSQL_ROW_OFFSET STDCALL mysql_row_tell(MYSQL_RES *res)
 
833
DRIZZLE_ROW_OFFSET STDCALL DRIZZLE_ROW_tell(DRIZZLE_RES *res)
949
834
{
950
835
  return res->data_cursor;
951
836
}
952
837
 
953
 
MYSQL_FIELD_OFFSET STDCALL mysql_field_tell(MYSQL_RES *res)
 
838
DRIZZLE_FIELD_OFFSET STDCALL drizzle_field_tell(DRIZZLE_RES *res)
954
839
{
955
840
  return (res)->current_field;
956
841
}
957
842
 
958
 
/* MYSQL */
959
 
 
960
 
unsigned int STDCALL mysql_field_count(MYSQL *mysql)
961
 
{
962
 
  return mysql->field_count;
963
 
}
964
 
 
965
 
uint64_t STDCALL mysql_affected_rows(MYSQL *mysql)
966
 
{
967
 
  return mysql->affected_rows;
968
 
}
969
 
 
970
 
uint64_t STDCALL mysql_insert_id(MYSQL *mysql)
971
 
{
972
 
  return mysql->insert_id;
973
 
}
974
 
 
975
 
const char *STDCALL mysql_sqlstate(MYSQL *mysql)
976
 
{
977
 
  return mysql ? mysql->net.sqlstate : cant_connect_sqlstate;
978
 
}
979
 
 
980
 
uint32_t STDCALL mysql_warning_count(MYSQL *mysql)
981
 
{
982
 
  return mysql->warning_count;
983
 
}
984
 
 
985
 
const char *STDCALL mysql_info(MYSQL *mysql)
986
 
{
987
 
  return mysql->info;
988
 
}
989
 
 
990
 
uint32_t STDCALL mysql_thread_id(MYSQL *mysql)
991
 
{
992
 
  return (mysql)->thread_id;
993
 
}
994
 
 
995
 
const char * STDCALL mysql_character_set_name(MYSQL *mysql)
996
 
{
997
 
  return mysql->charset->csname;
998
 
}
999
 
 
1000
 
void STDCALL mysql_get_character_set_info(MYSQL *mysql, MY_CHARSET_INFO *csinfo)
1001
 
{
1002
 
  csinfo->number   = mysql->charset->number;
1003
 
  csinfo->state    = mysql->charset->state;
1004
 
  csinfo->csname   = mysql->charset->csname;
1005
 
  csinfo->name     = mysql->charset->name;
1006
 
  csinfo->comment  = mysql->charset->comment;
1007
 
  csinfo->mbminlen = mysql->charset->mbminlen;
1008
 
  csinfo->mbmaxlen = mysql->charset->mbmaxlen;
1009
 
 
1010
 
  if (mysql->options.charset_dir)
1011
 
    csinfo->dir = mysql->options.charset_dir;
 
843
/* DRIZZLE */
 
844
 
 
845
unsigned int STDCALL drizzle_field_count(DRIZZLE *drizzle)
 
846
{
 
847
  return drizzle->field_count;
 
848
}
 
849
 
 
850
uint64_t STDCALL drizzle_affected_rows(DRIZZLE *drizzle)
 
851
{
 
852
  return drizzle->affected_rows;
 
853
}
 
854
 
 
855
uint64_t STDCALL drizzle_insert_id(DRIZZLE *drizzle)
 
856
{
 
857
  return drizzle->insert_id;
 
858
}
 
859
 
 
860
const char *STDCALL drizzle_sqlstate(DRIZZLE *drizzle)
 
861
{
 
862
  return drizzle ? drizzle->net.sqlstate : cant_connect_sqlstate;
 
863
}
 
864
 
 
865
uint32_t STDCALL drizzle_warning_count(DRIZZLE *drizzle)
 
866
{
 
867
  return drizzle->warning_count;
 
868
}
 
869
 
 
870
const char *STDCALL drizzle_info(DRIZZLE *drizzle)
 
871
{
 
872
  return drizzle->info;
 
873
}
 
874
 
 
875
uint32_t STDCALL drizzle_thread_id(DRIZZLE *drizzle)
 
876
{
 
877
  return (drizzle)->thread_id;
 
878
}
 
879
 
 
880
const char * STDCALL drizzle_character_set_name(DRIZZLE *drizzle)
 
881
{
 
882
  return drizzle->charset->csname;
 
883
}
 
884
 
 
885
void STDCALL drizzle_get_character_set_info(DRIZZLE *drizzle, MY_CHARSET_INFO *csinfo)
 
886
{
 
887
  csinfo->number   = drizzle->charset->number;
 
888
  csinfo->state    = drizzle->charset->state;
 
889
  csinfo->csname   = drizzle->charset->csname;
 
890
  csinfo->name     = drizzle->charset->name;
 
891
  csinfo->comment  = drizzle->charset->comment;
 
892
  csinfo->mbminlen = drizzle->charset->mbminlen;
 
893
  csinfo->mbmaxlen = drizzle->charset->mbmaxlen;
 
894
 
 
895
  if (drizzle->options.charset_dir)
 
896
    csinfo->dir = drizzle->options.charset_dir;
1012
897
  else
1013
898
    csinfo->dir = charsets_dir;
1014
899
}
1015
900
 
1016
 
uint STDCALL mysql_thread_safe(void)
 
901
uint STDCALL drizzle_thread_safe(void)
1017
902
{
1018
903
  return 1;
1019
904
}
1020
905
 
1021
906
 
1022
 
my_bool STDCALL mysql_embedded(void)
 
907
bool STDCALL drizzle_embedded(void)
1023
908
{
1024
909
#ifdef EMBEDDED_LIBRARY
1025
 
  return 1;
 
910
  return true;
1026
911
#else
1027
 
  return 0;
 
912
  return false;
1028
913
#endif
1029
914
}
1030
915
 
1048
933
/*
1049
934
  This function is used to create HEX string that you
1050
935
  can use in a SQL statement in of the either ways:
1051
 
    INSERT INTO blob_column VALUES (0xAABBCC);  (any MySQL version)
 
936
    INSERT INTO blob_column VALUES (0xAABBCC);  (any DRIZZLE version)
1052
937
    INSERT INTO blob_column VALUES (X'AABBCC'); (4.1 and higher)
1053
938
  
1054
939
  The string in "from" is encoded to a HEX string.
1057
942
  The string pointed to by "from" must be "length" bytes long.
1058
943
  You must allocate the "to" buffer to be at least length*2+1 bytes long.
1059
944
  Each character needs two bytes, and you need room for the terminating
1060
 
  null byte. When mysql_hex_string() returns, the contents of "to" will
 
945
  null byte. When drizzle_hex_string() returns, the contents of "to" will
1061
946
  be a null-terminated string. The return value is the length of the
1062
947
  encoded string, not including the terminating null character.
1063
948
 
1066
951
*/
1067
952
 
1068
953
uint32_t STDCALL
1069
 
mysql_hex_string(char *to, const char *from, uint32_t length)
 
954
drizzle_hex_string(char *to, const char *from, uint32_t length)
1070
955
{
1071
956
  char *to0= to;
1072
957
  const char *end;
1087
972
*/
1088
973
 
1089
974
uint32_t STDCALL
1090
 
mysql_escape_string(char *to,const char *from, uint32_t length)
 
975
drizzle_escape_string(char *to,const char *from, uint32_t length)
1091
976
{
1092
977
  return escape_string_for_mysql(default_charset_info, to, 0, from, length);
1093
978
}
1094
979
 
1095
980
uint32_t STDCALL
1096
 
mysql_real_escape_string(MYSQL *mysql, char *to,const char *from,
1097
 
                         uint32_t length)
 
981
drizzle_real_escape_string(DRIZZLE *drizzle, char *to,const char *from,
 
982
       uint32_t length)
1098
983
{
1099
 
  if (mysql->server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES)
1100
 
    return escape_quotes_for_mysql(mysql->charset, to, 0, from, length);
1101
 
  return escape_string_for_mysql(mysql->charset, to, 0, from, length);
 
984
  if (drizzle->server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES)
 
985
    return escape_quotes_for_mysql(drizzle->charset, to, 0, from, length);
 
986
  return escape_string_for_mysql(drizzle->charset, to, 0, from, length);
1102
987
}
1103
988
 
1104
989
void STDCALL
1105
 
myodbc_remove_escape(MYSQL *mysql,char *name)
 
990
myodbc_remove_escape(DRIZZLE *drizzle,char *name)
1106
991
{
1107
992
  char *to;
1108
993
#ifdef USE_MB
1109
 
  my_bool use_mb_flag=use_mb(mysql->charset);
 
994
  bool use_mb_flag=use_mb(drizzle->charset);
1110
995
  char *end=NULL;
1111
996
  if (use_mb_flag)
1112
997
    for (end=name; *end ; end++) ;
1116
1001
  {
1117
1002
#ifdef USE_MB
1118
1003
    int l;
1119
 
    if (use_mb_flag && (l = my_ismbchar( mysql->charset, name , end ) ) )
 
1004
    if (use_mb_flag && (l = my_ismbchar( drizzle->charset, name , end ) ) )
1120
1005
    {
1121
1006
      while (l--)
1122
 
        *to++ = *name++;
 
1007
  *to++ = *name++;
1123
1008
      name--;
1124
1009
      continue;
1125
1010
    }
1131
1016
  *to=0;
1132
1017
}
1133
1018
 
1134
 
int cli_unbuffered_fetch(MYSQL *mysql, char **row)
 
1019
int cli_unbuffered_fetch(DRIZZLE *drizzle, char **row)
1135
1020
{
1136
 
  if (packet_error == cli_safe_read(mysql))
 
1021
  if (packet_error == cli_safe_read(drizzle))
1137
1022
    return 1;
1138
1023
 
1139
 
  *row= ((mysql->net.read_pos[0] == 254) ? NULL :
1140
 
         (char*) (mysql->net.read_pos+1));
 
1024
  *row= ((drizzle->net.read_pos[0] == 254) ? NULL :
 
1025
   (char*) (drizzle->net.read_pos+1));
1141
1026
  return 0;
1142
1027
}
1143
1028
 
1149
1034
  Commit the current transaction
1150
1035
*/
1151
1036
 
1152
 
my_bool STDCALL mysql_commit(MYSQL * mysql)
 
1037
bool STDCALL drizzle_commit(DRIZZLE *drizzle)
1153
1038
{
1154
 
  return((my_bool) mysql_real_query(mysql, "commit", 6));
 
1039
  return((bool) drizzle_real_query(drizzle, "commit", 6));
1155
1040
}
1156
1041
 
1157
1042
/*
1158
1043
  Rollback the current transaction
1159
1044
*/
1160
1045
 
1161
 
my_bool STDCALL mysql_rollback(MYSQL * mysql)
 
1046
bool STDCALL drizzle_rollback(DRIZZLE *drizzle)
1162
1047
{
1163
 
  return((my_bool) mysql_real_query(mysql, "rollback", 8));
 
1048
  return((bool) drizzle_real_query(drizzle, "rollback", 8));
1164
1049
}
1165
1050
 
1166
1051
 
1168
1053
  Set autocommit to either true or false
1169
1054
*/
1170
1055
 
1171
 
my_bool STDCALL mysql_autocommit(MYSQL * mysql, my_bool auto_mode)
 
1056
bool STDCALL drizzle_autocommit(DRIZZLE *drizzle, bool auto_mode)
1172
1057
{
1173
 
  return((my_bool) mysql_real_query(mysql, auto_mode ?
 
1058
  return((bool) drizzle_real_query(drizzle, auto_mode ?
1174
1059
                                         "set autocommit=1":"set autocommit=0",
1175
1060
                                         16));
1176
1061
}
1182
1067
 
1183
1068
/*
1184
1069
  Returns true/false to indicate whether any more query results exist
1185
 
  to be read using mysql_next_result()
 
1070
  to be read using drizzle_next_result()
1186
1071
*/
1187
1072
 
1188
 
my_bool STDCALL mysql_more_results(MYSQL *mysql)
 
1073
bool STDCALL drizzle_more_results(DRIZZLE *drizzle)
1189
1074
{
1190
 
  my_bool res;
 
1075
  bool res;
1191
1076
 
1192
 
  res= ((mysql->server_status & SERVER_MORE_RESULTS_EXISTS) ? 1: 0);
 
1077
  res= ((drizzle->server_status & SERVER_MORE_RESULTS_EXISTS) ? 1: 0);
1193
1078
  return(res);
1194
1079
}
1195
1080
 
1197
1082
/*
1198
1083
  Reads and returns the next query results
1199
1084
*/
1200
 
int STDCALL mysql_next_result(MYSQL *mysql)
 
1085
int STDCALL drizzle_next_result(DRIZZLE *drizzle)
1201
1086
{
1202
 
  if (mysql->status != MYSQL_STATUS_READY)
 
1087
  if (drizzle->status != DRIZZLE_STATUS_READY)
1203
1088
  {
1204
 
    set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
 
1089
    set_drizzle_error(drizzle, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
1205
1090
    return(1);
1206
1091
  }
1207
1092
 
1208
 
  net_clear_error(&mysql->net);
1209
 
  mysql->affected_rows= ~(uint64_t) 0;
1210
 
 
1211
 
  if (mysql->server_status & SERVER_MORE_RESULTS_EXISTS)
1212
 
    return((*mysql->methods->next_result)(mysql));
1213
 
 
1214
 
  return(-1);                           /* No more results */
1215
 
}
1216
 
 
1217
 
 
1218
 
MYSQL_RES * STDCALL mysql_use_result(MYSQL *mysql)
1219
 
{
1220
 
  return (*mysql->methods->use_result)(mysql);
1221
 
}
1222
 
 
1223
 
my_bool STDCALL mysql_read_query_result(MYSQL *mysql)
1224
 
{
1225
 
  return (*mysql->methods->read_query_result)(mysql);
 
1093
  net_clear_error(&drizzle->net);
 
1094
  drizzle->affected_rows= ~(uint64_t) 0;
 
1095
 
 
1096
  if (drizzle->server_status & SERVER_MORE_RESULTS_EXISTS)
 
1097
    return((*drizzle->methods->next_result)(drizzle));
 
1098
 
 
1099
  return(-1);        /* No more results */
 
1100
}
 
1101
 
 
1102
 
 
1103
DRIZZLE_RES * STDCALL drizzle_use_result(DRIZZLE *drizzle)
 
1104
{
 
1105
  return (*drizzle->methods->use_result)(drizzle);
 
1106
}
 
1107
 
 
1108
bool STDCALL drizzle_read_query_result(DRIZZLE *drizzle)
 
1109
{
 
1110
  return (*drizzle->methods->read_query_result)(drizzle);
1226
1111
}
1227
1112