← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/mysqlimport.c

  • Committer: Mark Atwood
  • Date: 2008-07-12 07:25:25 UTC
  • mto: This revision was merged to the branch mainline in revision 139.
  • Revision ID: me@mark.atwood.name-20080712072525-s1dq9mtwo5td7af7
more hackery to get plugin UDFs working

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/mysqlimport.c
1
 
/* Copyright (C) 2008 Drizzle Open Source Development Team
 
1
/* Copyright (C) 2000-2006 MySQL 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
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/*
17
 
**     drizzleimport.c  - Imports all given files
18
 
**          into a table(s).
 
17
**         mysqlimport.c  - Imports all given files
 
18
**                          into a table(s).
19
19
**
20
 
**         *************************
21
 
**         *         *
22
 
**         * AUTHOR: Monty & Jani  *
23
 
**         * DATE:   June 24, 1997 *
24
 
**         *         *
25
 
**         *************************
 
20
**                         *************************
 
21
**                         *                       *
 
22
**                         * AUTHOR: Monty & Jani  *
 
23
**                         * DATE:   June 24, 1997 *
 
24
**                         *                       *
 
25
**                         *************************
26
26
*/
27
27
#define IMPORT_VERSION "3.7"
28
28
 
29
 
#include "config.h"
30
 
#include <string>
31
 
 
32
29
#include "client_priv.h"
33
 
#include <pthread.h>
 
30
#include "drizzle_version.h"
 
31
#ifdef HAVE_LIBPTHREAD
 
32
#include <my_pthread.h>
 
33
#endif
34
34
 
35
 
using namespace std;
36
35
 
37
36
/* Global Thread counter */
38
37
uint counter;
 
38
#ifdef HAVE_LIBPTHREAD
39
39
pthread_mutex_t counter_mutex;
40
40
pthread_cond_t count_threshhold;
 
41
#endif
41
42
 
42
 
static void db_error_with_table(DRIZZLE *drizzle, char *table);
43
 
static void db_error(DRIZZLE *drizzle);
 
43
static void db_error_with_table(MYSQL *mysql, char *table);
 
44
static void db_error(MYSQL *mysql);
44
45
static char *field_escape(char *to,const char *from,uint length);
45
46
static char *add_load_option(char *ptr,const char *object,
46
 
           const char *statement);
 
47
                             const char *statement);
47
48
 
48
 
static bool  verbose=0,lock_tables=0,ignore_errors=0,opt_delete=0,
49
 
  opt_replace=0,silent=0,ignore=0,opt_compress=0,
50
 
  opt_low_priority= 0, tty_password= 0;
51
 
static bool debug_info_flag= 0, debug_check_flag= 0;
 
49
static my_bool  verbose=0,lock_tables=0,ignore_errors=0,opt_delete=0,
 
50
                replace=0,silent=0,ignore=0,opt_compress=0,
 
51
                opt_low_priority= 0, tty_password= 0;
 
52
static my_bool debug_info_flag= 0, debug_check_flag= 0;
52
53
static uint opt_use_threads=0, opt_local_file=0, my_end_arg= 0;
53
 
static char  *opt_password=0, *current_user=0,
54
 
    *current_host=0, *current_db=0, *fields_terminated=0,
55
 
    *lines_terminated=0, *enclosed=0, *opt_enclosed=0,
56
 
    *escaped=0, *opt_columns=0,
57
 
    *default_charset= (char*) DRIZZLE_DEFAULT_CHARSET_NAME;
58
 
static uint     opt_drizzle_port= 0, opt_protocol= 0;
59
 
static char * opt_drizzle_unix_port=0;
60
 
static int64_t opt_ignore_lines= -1;
61
 
static const CHARSET_INFO *charset_info= &my_charset_utf8_general_ci;
 
54
static char     *opt_password=0, *current_user=0,
 
55
                *current_host=0, *current_db=0, *fields_terminated=0,
 
56
                *lines_terminated=0, *enclosed=0, *opt_enclosed=0,
 
57
                *escaped=0, *opt_columns=0, 
 
58
                *default_charset= (char*) MYSQL_DEFAULT_CHARSET_NAME;
 
59
static uint     opt_mysql_port= 0, opt_protocol= 0;
 
60
static char * opt_mysql_unix_port=0;
 
61
static longlong opt_ignore_lines= -1;
 
62
static CHARSET_INFO *charset_info= &my_charset_latin1;
 
63
 
 
64
#ifdef HAVE_SMEM
 
65
static char *shared_memory_base_name=0;
 
66
#endif
62
67
 
63
68
static struct my_option my_long_options[] =
64
69
{
115
120
  {"local", 'L', "Read all files through the client.", (char**) &opt_local_file,
116
121
   (char**) &opt_local_file, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
117
122
  {"lock-tables", 'l', "Lock all tables for write (this disables threads).",
118
 
    (char**) &lock_tables, (char**) &lock_tables, 0, GET_BOOL, NO_ARG,
 
123
    (char**) &lock_tables, (char**) &lock_tables, 0, GET_BOOL, NO_ARG, 
119
124
    0, 0, 0, 0, 0, 0},
120
125
  {"low-priority", OPT_LOW_PRIORITY,
121
126
   "Use LOW_PRIORITY when updating the table.", (char**) &opt_low_priority,
124
129
   "Password to use when connecting to server. If password is not given it's asked from the tty.",
125
130
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
126
131
  {"port", 'P', "Port number to use for connection or 0 for default to, in "
127
 
   "order of preference, my.cnf, $DRIZZLE_TCP_PORT, "
128
 
   "built-in default (" STRINGIFY_ARG(DRIZZLE_PORT) ").",
129
 
   (char**) &opt_drizzle_port,
130
 
   (char**) &opt_drizzle_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0,
 
132
   "order of preference, my.cnf, $MYSQL_TCP_PORT, "
 
133
#if MYSQL_PORT_DEFAULT == 0
 
134
   "/etc/services, "
 
135
#endif
 
136
   "built-in default (" STRINGIFY_ARG(MYSQL_PORT) ").",
 
137
   (char**) &opt_mysql_port,
 
138
   (char**) &opt_mysql_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0,
131
139
   0},
132
 
  {"protocol", OPT_DRIZZLE_PROTOCOL, "The protocol of connection (tcp,socket,pipe,memory).",
 
140
  {"protocol", OPT_MYSQL_PROTOCOL, "The protocol of connection (tcp,socket,pipe,memory).",
133
141
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
134
142
  {"replace", 'r', "If duplicate unique key was found, replace old row.",
135
 
   (char**) &opt_replace, (char**) &opt_replace, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
143
   (char**) &replace, (char**) &replace, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
144
#ifdef HAVE_SMEM
 
145
  {"shared-memory-base-name", OPT_SHARED_MEMORY_BASE_NAME,
 
146
   "Base name of shared memory.", (char**) &shared_memory_base_name, (char**) &shared_memory_base_name,
 
147
   0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
148
#endif
136
149
  {"silent", 's', "Be more silent.", (char**) &silent, (char**) &silent, 0,
137
150
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
138
151
  {"socket", 'S', "Socket file to use for connection.",
139
 
   (char**) &opt_drizzle_unix_port, (char**) &opt_drizzle_unix_port, 0, GET_STR,
 
152
   (char**) &opt_mysql_unix_port, (char**) &opt_mysql_unix_port, 0, GET_STR,
140
153
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
141
154
  {"use-threads", OPT_USE_THREADS,
142
155
   "Load files in parallel. The argument is the number "
143
156
   "of threads to use for loading data.",
144
 
   (char**) &opt_use_threads, (char**) &opt_use_threads, 0,
 
157
   (char**) &opt_use_threads, (char**) &opt_use_threads, 0, 
145
158
   GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
146
159
#ifndef DONT_ALLOW_USER_CHANGE
147
160
  {"user", 'u', "User for login if not current user.", (char**) &current_user,
155
168
};
156
169
 
157
170
 
158
 
static const char *load_default_groups[]= { "drizzleimport","client",0 };
 
171
static const char *load_default_groups[]= { "mysqlimport","client",0 };
 
172
 
 
173
#include <help_start.h>
159
174
 
160
175
static void print_version(void)
161
176
{
162
177
  printf("%s  Ver %s Distrib %s, for %s (%s)\n" ,my_progname,
163
 
    IMPORT_VERSION, drizzle_get_client_info(),SYSTEM_TYPE,MACHINE_TYPE);
 
178
          IMPORT_VERSION, MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
164
179
}
165
180
 
166
181
 
167
182
static void usage(void)
168
183
{
169
184
  print_version();
170
 
  puts("Copyright (C) 2008 Drizzle Open Source Development Team");
 
185
  puts("Copyright (C) 2000-2006 MySQL AB");
171
186
  puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,\nand you are welcome to modify and redistribute it under the GPL license\n");
172
187
  printf("\
173
188
Loads tables from text files in various formats.  The base name of the\n\
174
189
text file must be the name of the table that should be used.\n\
175
 
If one uses sockets to connect to the Drizzle server, the server will open and\n\
 
190
If one uses sockets to connect to the MySQL server, the server will open and\n\
176
191
read the text file directly. In other cases the client will open the text\n\
177
192
file. The SQL command 'LOAD DATA INFILE' is used to import the rows.\n");
178
193
 
182
197
  my_print_variables(my_long_options);
183
198
}
184
199
 
185
 
static bool
 
200
#include <help_end.h>
 
201
 
 
202
static my_bool
186
203
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
187
 
         char *argument)
 
204
               char *argument)
188
205
{
189
206
  switch(optid) {
190
207
  case 'p':
191
208
    if (argument)
192
209
    {
193
210
      char *start=argument;
194
 
      free(opt_password);
 
211
      my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));
195
212
      opt_password=my_strdup(argument,MYF(MY_FAE));
196
 
      while (*argument) *argument++= 'x';    /* Destroy argument */
 
213
      while (*argument) *argument++= 'x';               /* Destroy argument */
197
214
      if (*start)
198
 
  start[1]=0;        /* Cut length of argument */
 
215
        start[1]=0;                             /* Cut length of argument */
199
216
      tty_password= 0;
200
217
    }
201
218
    else
202
219
      tty_password= 1;
203
220
    break;
204
 
  case OPT_DRIZZLE_PROTOCOL:
 
221
  case OPT_MYSQL_PROTOCOL:
 
222
    opt_protocol= find_type_or_exit(argument, &sql_protocol_typelib,
 
223
                                    opt->name);
 
224
    break;
 
225
  case '#':
 
226
    DBUG_PUSH(argument ? argument : "d:t:o");
 
227
    debug_check_flag= 1;
205
228
    break;
206
229
  case 'V': print_version(); exit(0);
207
230
  case 'I':
229
252
    fprintf(stderr, "You can't use ..enclosed.. and ..optionally-enclosed.. at the same time.\n");
230
253
    return(1);
231
254
  }
232
 
  if (opt_replace && ignore)
 
255
  if (replace && ignore)
233
256
  {
234
257
    fprintf(stderr, "You can't use --ignore (-i) and --replace (-r) at the same time.\n");
235
258
    return(1);
236
259
  }
237
260
  if (strcmp(default_charset, charset_info->csname) &&
238
261
      !(charset_info= get_charset_by_csname(default_charset,
239
 
                MY_CS_PRIMARY, MYF(MY_WME))))
 
262
                                            MY_CS_PRIMARY, MYF(MY_WME))))
240
263
    exit(1);
241
264
  if (*argc < 2)
242
265
  {
246
269
  current_db= *((*argv)++);
247
270
  (*argc)--;
248
271
  if (tty_password)
249
 
    opt_password=get_tty_password(NULL);
 
272
    opt_password=get_tty_password(NullS);
250
273
  return(0);
251
274
}
252
275
 
253
276
 
254
277
 
255
 
static int write_to_table(char *filename, DRIZZLE *drizzle)
 
278
static int write_to_table(char *filename, MYSQL *mysql)
256
279
{
257
280
  char tablename[FN_REFLEN], hard_path[FN_REFLEN],
258
281
       sql_statement[FN_REFLEN*16+256], *end;
 
282
  DBUG_ENTER("write_to_table");
 
283
  DBUG_PRINT("enter",("filename: %s",filename));
259
284
 
260
285
  fn_format(tablename, filename, "", "", 1 | 2); /* removes path & ext. */
261
286
  if (!opt_local_file)
262
 
    my_stpcpy(hard_path,filename);
 
287
    strmov(hard_path,filename);
263
288
  else
264
289
    my_load_path(hard_path, filename, NULL); /* filename includes the path */
265
290
 
272
297
#else
273
298
    sprintf(sql_statement, "DELETE FROM %s", tablename);
274
299
#endif
275
 
    if (drizzle_query(drizzle, sql_statement))
 
300
    if (mysql_query(mysql, sql_statement))
276
301
    {
277
 
      db_error_with_table(drizzle, tablename);
278
 
      return(1);
 
302
      db_error_with_table(mysql, tablename);
 
303
      DBUG_RETURN(1);
279
304
    }
280
305
  }
281
306
  to_unix_path(hard_path);
283
308
  {
284
309
    if (opt_local_file)
285
310
      fprintf(stdout, "Loading data from LOCAL file: %s into %s\n",
286
 
        hard_path, tablename);
 
311
              hard_path, tablename);
287
312
    else
288
313
      fprintf(stdout, "Loading data from SERVER file: %s into %s\n",
289
 
        hard_path, tablename);
 
314
              hard_path, tablename);
290
315
  }
291
316
  sprintf(sql_statement, "LOAD DATA %s %s INFILE '%s'",
292
 
    opt_low_priority ? "LOW_PRIORITY" : "",
293
 
    opt_local_file ? "LOCAL" : "", hard_path);
294
 
  end= strchr(sql_statement, '\0');
295
 
  if (opt_replace)
296
 
    end= my_stpcpy(end, " REPLACE");
 
317
          opt_low_priority ? "LOW_PRIORITY" : "",
 
318
          opt_local_file ? "LOCAL" : "", hard_path);
 
319
  end= strend(sql_statement);
 
320
  if (replace)
 
321
    end= strmov(end, " REPLACE");
297
322
  if (ignore)
298
 
    end= my_stpcpy(end, " IGNORE");
299
 
  end= my_stpcpy(my_stpcpy(end, " INTO TABLE "), tablename);
 
323
    end= strmov(end, " IGNORE");
 
324
  end= strmov(strmov(end, " INTO TABLE "), tablename);
300
325
 
301
326
  if (fields_terminated || enclosed || opt_enclosed || escaped)
302
 
      end= my_stpcpy(end, " FIELDS");
 
327
      end= strmov(end, " FIELDS");
303
328
  end= add_load_option(end, fields_terminated, " TERMINATED BY");
304
329
  end= add_load_option(end, enclosed, " ENCLOSED BY");
305
330
  end= add_load_option(end, opt_enclosed,
306
 
           " OPTIONALLY ENCLOSED BY");
 
331
                       " OPTIONALLY ENCLOSED BY");
307
332
  end= add_load_option(end, escaped, " ESCAPED BY");
308
333
  end= add_load_option(end, lines_terminated, " LINES TERMINATED BY");
309
334
  if (opt_ignore_lines >= 0)
310
 
    end= my_stpcpy(int64_t10_to_str(opt_ignore_lines,
311
 
          my_stpcpy(end, " IGNORE "),10), " LINES");
 
335
    end= strmov(longlong10_to_str(opt_ignore_lines, 
 
336
                                  strmov(end, " IGNORE "),10), " LINES");
312
337
  if (opt_columns)
313
 
    end= my_stpcpy(my_stpcpy(my_stpcpy(end, " ("), opt_columns), ")");
 
338
    end= strmov(strmov(strmov(end, " ("), opt_columns), ")");
314
339
  *end= '\0';
315
340
 
316
 
  if (drizzle_query(drizzle, sql_statement))
 
341
  if (mysql_query(mysql, sql_statement))
317
342
  {
318
 
    db_error_with_table(drizzle, tablename);
319
 
    return(1);
 
343
    db_error_with_table(mysql, tablename);
 
344
    DBUG_RETURN(1);
320
345
  }
321
346
  if (!silent)
322
347
  {
323
 
    if (drizzle_info(drizzle)) /* If NULL-pointer, print nothing */
 
348
    if (mysql_info(mysql)) /* If NULL-pointer, print nothing */
324
349
    {
325
350
      fprintf(stdout, "%s.%s: %s\n", current_db, tablename,
326
 
        drizzle_info(drizzle));
 
351
              mysql_info(mysql));
327
352
    }
328
353
  }
329
 
  return(0);
 
354
  DBUG_RETURN(0);
330
355
}
331
356
 
332
357
 
333
358
 
334
 
static void lock_table(DRIZZLE *drizzle, int tablecount, char **raw_tablename)
 
359
static void lock_table(MYSQL *mysql, int tablecount, char **raw_tablename)
335
360
{
336
 
  string query;
 
361
  DYNAMIC_STRING query;
337
362
  int i;
338
363
  char tablename[FN_REFLEN];
339
364
 
340
365
  if (verbose)
341
366
    fprintf(stdout, "Locking tables for write\n");
342
 
  query.append("LOCK TABLES ");
 
367
  init_dynamic_string(&query, "LOCK TABLES ", 256, 1024);
343
368
  for (i=0 ; i < tablecount ; i++)
344
369
  {
345
370
    fn_format(tablename, raw_tablename[i], "", "", 1 | 2);
346
 
    query.append(tablename);
347
 
    query.append(" WRITE,");
 
371
    dynstr_append(&query, tablename);
 
372
    dynstr_append(&query, " WRITE,");
348
373
  }
349
 
  if (drizzle_real_query(drizzle, query.c_str(), query.length()-1))
350
 
    db_error(drizzle); /* We shall countinue here, if --force was given */
 
374
  if (mysql_real_query(mysql, query.str, query.length-1))
 
375
    db_error(mysql); /* We shall countinue here, if --force was given */
351
376
}
352
377
 
353
378
 
354
379
 
355
380
 
356
 
static DRIZZLE *db_connect(char *host, char *database,
 
381
static MYSQL *db_connect(char *host, char *database,
357
382
                         char *user, char *passwd)
358
383
{
359
 
  DRIZZLE *drizzle;
 
384
  MYSQL *mysql;
360
385
  if (verbose)
361
386
    fprintf(stdout, "Connecting to %s\n", host ? host : "localhost");
362
 
  if (!(drizzle= drizzle_create(NULL)))
 
387
  if (!(mysql= mysql_init(NULL)))
363
388
    return 0;
364
389
  if (opt_compress)
365
 
    drizzle_options(drizzle,DRIZZLE_OPT_COMPRESS,NULL);
 
390
    mysql_options(mysql,MYSQL_OPT_COMPRESS,NullS);
366
391
  if (opt_local_file)
367
 
    drizzle_options(drizzle,DRIZZLE_OPT_LOCAL_INFILE,
368
 
      (char*) &opt_local_file);
 
392
    mysql_options(mysql,MYSQL_OPT_LOCAL_INFILE,
 
393
                  (char*) &opt_local_file);
369
394
  if (opt_protocol)
370
 
    drizzle_options(drizzle,DRIZZLE_OPT_PROTOCOL,(char*)&opt_protocol);
371
 
  if (!(drizzle_connect(drizzle,host,user,passwd,
372
 
                           database,opt_drizzle_port,opt_drizzle_unix_port,
 
395
    mysql_options(mysql,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);
 
396
#ifdef HAVE_SMEM
 
397
  if (shared_memory_base_name)
 
398
    mysql_options(mysql,MYSQL_SHARED_MEMORY_BASE_NAME,shared_memory_base_name);
 
399
#endif
 
400
  if (!(mysql_real_connect(mysql,host,user,passwd,
 
401
                           database,opt_mysql_port,opt_mysql_unix_port,
373
402
                           0)))
374
403
  {
375
 
    ignore_errors=0;    /* NO RETURN FROM db_error */
376
 
    db_error(drizzle);
 
404
    ignore_errors=0;      /* NO RETURN FROM db_error */
 
405
    db_error(mysql);
377
406
  }
378
 
  drizzle->reconnect= 0;
 
407
  mysql->reconnect= 0;
379
408
  if (verbose)
380
409
    fprintf(stdout, "Selecting database %s\n", database);
381
 
  if (drizzle_select_db(drizzle, database))
 
410
  if (mysql_select_db(mysql, database))
382
411
  {
383
412
    ignore_errors=0;
384
 
    db_error(drizzle);
 
413
    db_error(mysql);
385
414
  }
386
 
  return drizzle;
 
415
  return mysql;
387
416
}
388
417
 
389
418
 
390
419
 
391
 
static void db_disconnect(char *host, DRIZZLE *drizzle)
 
420
static void db_disconnect(char *host, MYSQL *mysql)
392
421
{
393
422
  if (verbose)
394
423
    fprintf(stdout, "Disconnecting from %s\n", host ? host : "localhost");
395
 
  drizzle_close(drizzle);
 
424
  mysql_close(mysql);
396
425
}
397
426
 
398
427
 
399
428
 
400
 
static void safe_exit(int error, DRIZZLE *drizzle)
 
429
static void safe_exit(int error, MYSQL *mysql)
401
430
{
402
431
  if (ignore_errors)
403
432
    return;
404
 
  if (drizzle)
405
 
    drizzle_close(drizzle);
 
433
  if (mysql)
 
434
    mysql_close(mysql);
406
435
  exit(error);
407
436
}
408
437
 
409
438
 
410
439
 
411
 
static void db_error_with_table(DRIZZLE *drizzle, char *table)
 
440
static void db_error_with_table(MYSQL *mysql, char *table)
412
441
{
413
442
  my_printf_error(0,"Error: %d, %s, when using table: %s",
414
 
      MYF(0), drizzle_errno(drizzle), drizzle_error(drizzle), table);
415
 
  safe_exit(1, drizzle);
 
443
                  MYF(0), mysql_errno(mysql), mysql_error(mysql), table);
 
444
  safe_exit(1, mysql);
416
445
}
417
446
 
418
447
 
419
448
 
420
 
static void db_error(DRIZZLE *drizzle)
 
449
static void db_error(MYSQL *mysql)
421
450
{
422
 
  my_printf_error(0,"Error: %d %s", MYF(0), drizzle_errno(drizzle), drizzle_error(drizzle));
423
 
  safe_exit(1, drizzle);
 
451
  my_printf_error(0,"Error: %d %s", MYF(0), mysql_errno(mysql), mysql_error(mysql));
 
452
  safe_exit(1, mysql);
424
453
}
425
454
 
426
455
 
427
456
static char *add_load_option(char *ptr, const char *object,
428
 
           const char *statement)
 
457
                             const char *statement)
429
458
{
430
459
  if (object)
431
460
  {
432
461
    /* Don't escape hex constants */
433
462
    if (object[0] == '0' && (object[1] == 'x' || object[1] == 'X'))
434
 
      ptr= strxmov(ptr," ",statement," ",object,NULL);
 
463
      ptr= strxmov(ptr," ",statement," ",object,NullS);
435
464
    else
436
465
    {
437
466
      /* char constant; escape */
438
 
      ptr= strxmov(ptr," ",statement," '",NULL);
 
467
      ptr= strxmov(ptr," ",statement," '",NullS);
439
468
      ptr= field_escape(ptr,object,(uint) strlen(object));
440
469
      *ptr++= '\'';
441
470
    }
448
477
** "'", "\", "\\" (escaped backslash), "\t" (tab), "\n" (newline)
449
478
** This is done by doubleing ' and add a end -\ if needed to avoid
450
479
** syntax errors from the SQL parser.
451
 
*/
 
480
*/ 
452
481
 
453
482
static char *field_escape(char *to,const char *from,uint length)
454
483
{
455
484
  const char *end;
456
 
  uint end_backslashes=0;
 
485
  uint end_backslashes=0; 
457
486
 
458
487
  for (end= from+length; from != end; from++)
459
488
  {
460
489
    *to++= *from;
461
490
    if (*from == '\\')
462
491
      end_backslashes^=1;    /* find odd number of backslashes */
463
 
    else
 
492
    else 
464
493
    {
465
494
      if (*from == '\'' && !end_backslashes)
466
 
  *to++= *from;      /* We want a dublicate of "'" for DRIZZLE */
 
495
        *to++= *from;      /* We want a dublicate of "'" for MySQL */
467
496
      end_backslashes=0;
468
497
    }
469
498
  }
470
499
  /* Add missing backslashes if user has specified odd number of backs.*/
471
500
  if (end_backslashes)
472
 
    *to++= '\\';         
 
501
    *to++= '\\';          
473
502
  return to;
474
503
}
475
504
 
476
505
int exitcode= 0;
477
506
 
478
 
static void * worker_thread(void *arg)
 
507
#ifdef HAVE_LIBPTHREAD
 
508
static pthread_handler_t worker_thread(void *arg)
479
509
{
480
510
  int error;
481
511
  char *raw_table_name= (char *)arg;
482
 
  DRIZZLE *drizzle= 0;
 
512
  MYSQL *mysql= 0;
483
513
 
484
 
  if (!(drizzle= db_connect(current_host,current_db,current_user,opt_password)))
 
514
  if (mysql_thread_init())
 
515
    goto error;
 
516
  
 
517
  if (!(mysql= db_connect(current_host,current_db,current_user,opt_password)))
485
518
  {
486
519
    goto error;
487
520
  }
488
521
 
489
 
  if (drizzle_query(drizzle, "/*!40101 set @@character_set_database=binary */;"))
 
522
  if (mysql_query(mysql, "/*!40101 set @@character_set_database=binary */;"))
490
523
  {
491
 
    db_error(drizzle); /* We shall countinue here, if --force was given */
 
524
    db_error(mysql); /* We shall countinue here, if --force was given */
492
525
    goto error;
493
526
  }
494
527
 
495
528
  /*
496
529
    We are not currently catching the error here.
497
530
  */
498
 
  if((error= write_to_table(raw_table_name, drizzle)))
 
531
  if((error= write_to_table(raw_table_name, mysql)))
499
532
    if (exitcode == 0)
500
533
      exitcode= error;
501
534
 
502
535
error:
503
 
  if (drizzle)
504
 
    db_disconnect(current_host, drizzle);
 
536
  if (mysql)
 
537
    db_disconnect(current_host, mysql);
505
538
 
506
539
  pthread_mutex_lock(&counter_mutex);
507
540
  counter--;
511
544
 
512
545
  return 0;
513
546
}
 
547
#endif
514
548
 
515
549
 
516
550
int main(int argc, char **argv)
537
571
    pthread_attr_setdetachstate(&attr,
538
572
                                PTHREAD_CREATE_DETACHED);
539
573
 
540
 
    pthread_mutex_init(&counter_mutex, NULL);
541
 
    pthread_cond_init(&count_threshhold, NULL);
 
574
    VOID(pthread_mutex_init(&counter_mutex, NULL));
 
575
    VOID(pthread_cond_init(&count_threshhold, NULL));
542
576
 
543
577
    for (counter= 0; *argv != NULL; argv++) /* Loop through tables */
544
578
    {
554
588
      counter++;
555
589
      pthread_mutex_unlock(&counter_mutex);
556
590
      /* now create the thread */
557
 
      if (pthread_create(&mainthread, &attr, worker_thread,
 
591
      if (pthread_create(&mainthread, &attr, worker_thread, 
558
592
                         (void *)*argv) != 0)
559
593
      {
560
594
        pthread_mutex_lock(&counter_mutex);
577
611
      pthread_cond_timedwait(&count_threshhold, &counter_mutex, &abstime);
578
612
    }
579
613
    pthread_mutex_unlock(&counter_mutex);
580
 
    pthread_mutex_destroy(&counter_mutex);
581
 
    pthread_cond_destroy(&count_threshhold);
 
614
    VOID(pthread_mutex_destroy(&counter_mutex));
 
615
    VOID(pthread_cond_destroy(&count_threshhold));
582
616
    pthread_attr_destroy(&attr);
583
617
  }
584
618
  else
585
619
#endif
586
620
  {
587
 
    DRIZZLE *drizzle= 0;
588
 
    if (!(drizzle= db_connect(current_host,current_db,current_user,opt_password)))
 
621
    MYSQL *mysql= 0;
 
622
    if (!(mysql= db_connect(current_host,current_db,current_user,opt_password)))
589
623
    {
590
624
      free_defaults(argv_to_free);
591
625
      return(1); /* purecov: deadcode */
592
626
    }
593
627
 
594
 
    if (drizzle_query(drizzle, "/*!40101 set @@character_set_database=binary */;"))
 
628
    if (mysql_query(mysql, "/*!40101 set @@character_set_database=binary */;"))
595
629
    {
596
 
      db_error(drizzle); /* We shall countinue here, if --force was given */
 
630
      db_error(mysql); /* We shall countinue here, if --force was given */
597
631
      return(1);
598
632
    }
599
633
 
600
634
    if (lock_tables)
601
 
      lock_table(drizzle, argc, argv);
 
635
      lock_table(mysql, argc, argv);
602
636
    for (; *argv != NULL; argv++)
603
 
      if ((error= write_to_table(*argv, drizzle)))
 
637
      if ((error= write_to_table(*argv, mysql)))
604
638
        if (exitcode == 0)
605
639
          exitcode= error;
606
 
    db_disconnect(current_host, drizzle);
 
640
    db_disconnect(current_host, mysql);
607
641
  }
608
 
  free(opt_password);
 
642
  my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));
 
643
#ifdef HAVE_SMEM
 
644
  my_free(shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
 
645
#endif
609
646
  free_defaults(argv_to_free);
610
647
  my_end(my_end_arg);
611
648
  return(exitcode);