← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzleimport.cc

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:
client/drizzleimport.cc
26
26
*/
27
27
#define IMPORT_VERSION "3.7"
28
28
 
 
29
#include "client_priv.h"
29
30
#include <string>
30
31
 
31
 
#include "client_priv.h"
32
32
#include <pthread.h>
33
33
 
 
34
/* Added this for string translation. */
 
35
#include <drizzled/gettext.h>
 
36
 
34
37
using namespace std;
35
38
 
 
39
extern "C"
 
40
{
 
41
  bool get_one_option(int optid, const struct my_option *, char *argument);
 
42
  void * worker_thread(void *arg);
 
43
}
 
44
 
 
45
int exitcode= 0;
 
46
 
36
47
/* Global Thread counter */
37
 
uint counter;
 
48
uint32_t counter;
38
49
pthread_mutex_t counter_mutex;
39
50
pthread_cond_t count_threshhold;
40
51
 
41
 
static void db_error_with_table(DRIZZLE *drizzle, char *table);
42
 
static void db_error(DRIZZLE *drizzle);
43
 
static char *field_escape(char *to,const char *from,uint length);
 
52
static void db_error(drizzle_con_st *con, drizzle_result_st *result,
 
53
                     drizzle_return_t ret, char *table);
 
54
static char *field_escape(char *to,const char *from,uint32_t length);
44
55
static char *add_load_option(char *ptr,const char *object,
45
56
           const char *statement);
46
57
 
47
 
static bool  verbose=0,lock_tables=0,ignore_errors=0,opt_delete=0,
48
 
  opt_replace=0,silent=0,ignore=0,opt_compress=0,
49
 
  opt_low_priority= 0, tty_password= 0;
50
 
static bool debug_info_flag= 0, debug_check_flag= 0;
51
 
static uint opt_use_threads=0, opt_local_file=0, my_end_arg= 0;
52
 
static char  *opt_password=0, *current_user=0,
53
 
    *current_host=0, *current_db=0, *fields_terminated=0,
54
 
    *lines_terminated=0, *enclosed=0, *opt_enclosed=0,
55
 
    *escaped=0, *opt_columns=0,
56
 
    *default_charset= (char*) DRIZZLE_DEFAULT_CHARSET_NAME;
57
 
static uint     opt_drizzle_port= 0, opt_protocol= 0;
58
 
static char * opt_drizzle_unix_port=0;
 
58
static bool verbose= false, lock_tables= false, ignore_errors= false,
 
59
            opt_delete= false, opt_replace= false, silent= false,
 
60
            ignore_unique= false, opt_compress= false, opt_low_priority= false,
 
61
            tty_password= false;
 
62
static bool debug_info_flag= false, debug_check_flag= false;
 
63
static uint32_t opt_use_threads= 0, opt_local_file= 0, my_end_arg= 0;
 
64
static char  *opt_password= NULL, *current_user= NULL,
 
65
    *current_host= NULL, *current_db= NULL, *fields_terminated= NULL,
 
66
    *lines_terminated= NULL, *enclosed= NULL, *opt_enclosed= NULL,
 
67
    *escaped= NULL, *opt_columns= NULL;
 
68
static uint32_t opt_drizzle_port= 0;
 
69
static char * opt_drizzle_unix_port= 0;
59
70
static int64_t opt_ignore_lines= -1;
60
 
static const CHARSET_INFO *charset_info= &my_charset_latin1;
61
71
 
62
72
static struct my_option my_long_options[] =
63
73
{
64
 
  {"character-sets-dir", OPT_CHARSETS_DIR,
65
 
   "Directory where character sets are.", (char**) &charsets_dir,
66
 
   (char**) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
67
 
  {"default-character-set", OPT_DEFAULT_CHARSET,
68
 
   "Set the default character set.", (char**) &default_charset,
69
 
   (char**) &default_charset, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
70
74
  {"columns", 'c',
71
75
   "Use only these columns to import the data to. Give the column names in a comma separated list. This is same as giving columns to LOAD DATA INFILE.",
72
76
   (char**) &opt_columns, (char**) &opt_columns, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,
104
108
  {"host", 'h', "Connect to host.", (char**) &current_host,
105
109
   (char**) &current_host, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
106
110
  {"ignore", 'i', "If duplicate unique key was found, keep old row.",
107
 
   (char**) &ignore, (char**) &ignore, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
111
   (char**) &ignore_unique, (char**) &ignore_unique, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
108
112
  {"ignore-lines", OPT_IGN_LINES, "Ignore first n lines of data infile.",
109
113
   (char**) &opt_ignore_lines, (char**) &opt_ignore_lines, 0, GET_LL,
110
114
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
119
123
  {"low-priority", OPT_LOW_PRIORITY,
120
124
   "Use LOW_PRIORITY when updating the table.", (char**) &opt_low_priority,
121
125
   (char**) &opt_low_priority, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
122
 
  {"password", 'p',
 
126
  {"password", 'P',
123
127
   "Password to use when connecting to server. If password is not given it's asked from the tty.",
124
128
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
125
 
  {"port", 'P', "Port number to use for connection or 0 for default to, in "
126
 
   "order of preference, my.cnf, $DRIZZLE_TCP_PORT, "
 
129
  {"port", 'p', "Port number to use for connection or 0 for default to, in "
 
130
   "order of preference, drizzle.cnf, $DRIZZLE_TCP_PORT, "
127
131
   "built-in default (" STRINGIFY_ARG(DRIZZLE_PORT) ").",
128
 
   (char**) &opt_drizzle_port,
129
 
   (char**) &opt_drizzle_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0,
130
 
   0},
 
132
   0, 0, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
131
133
  {"protocol", OPT_DRIZZLE_PROTOCOL, "The protocol of connection (tcp,socket,pipe,memory).",
132
134
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
133
135
  {"replace", 'r', "If duplicate unique key was found, replace old row.",
142
144
   "of threads to use for loading data.",
143
145
   (char**) &opt_use_threads, (char**) &opt_use_threads, 0,
144
146
   GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
145
 
#ifndef DONT_ALLOW_USER_CHANGE
146
147
  {"user", 'u', "User for login if not current user.", (char**) &current_user,
147
148
   (char**) &current_user, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
148
 
#endif
149
149
  {"verbose", 'v', "Print info about the various stages.", (char**) &verbose,
150
150
   (char**) &verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
151
151
  {"version", 'V', "Output version information and exit.", 0, 0, 0, GET_NO_ARG,
158
158
 
159
159
static void print_version(void)
160
160
{
161
 
  printf("%s  Ver %s Distrib %s, for %s (%s)\n" ,my_progname,
162
 
    IMPORT_VERSION, drizzle_get_client_info(),SYSTEM_TYPE,MACHINE_TYPE);
 
161
  printf("%s  Ver %s Distrib %s, for %s-%s (%s)\n" ,my_progname,
 
162
    IMPORT_VERSION, drizzle_version(),HOST_VENDOR,HOST_OS,HOST_CPU);
163
163
}
164
164
 
165
165
 
176
176
file. The SQL command 'LOAD DATA INFILE' is used to import the rows.\n");
177
177
 
178
178
  printf("\nUsage: %s [OPTIONS] database textfile...",my_progname);
179
 
  print_defaults("my",load_default_groups);
 
179
  print_defaults("drizzle",load_default_groups);
180
180
  my_print_help(my_long_options);
181
181
  my_print_variables(my_long_options);
182
182
}
183
183
 
184
 
static bool
185
 
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
186
 
         char *argument)
 
184
bool get_one_option(int optid, const struct my_option *, char *argument)
187
185
{
 
186
  char *endchar= NULL;
 
187
  uint64_t temp_drizzle_port= 0;
 
188
 
188
189
  switch(optid) {
189
190
  case 'p':
 
191
    temp_drizzle_port= (uint64_t) strtoul(argument, &endchar, 10);
 
192
    /* if there is an alpha character this is not a valid port */
 
193
    if (strlen(endchar) != 0)
 
194
    {
 
195
      fprintf(stderr, _("Non-integer value supplied for port.  If you are trying to enter a password please use --password instead.\n"));
 
196
      exit(1);
 
197
    }
 
198
    /* If the port number is > 65535 it is not a valid port
 
199
       This also helps with potential data loss casting unsigned long to a
 
200
       uint32_t. */
 
201
    if ((temp_drizzle_port == 0) || (temp_drizzle_port > 65535))
 
202
    {
 
203
      fprintf(stderr, _("Value supplied for port is not valid.\n"));
 
204
      exit(1);
 
205
    }
 
206
    else
 
207
    {
 
208
      opt_drizzle_port= (uint32_t) temp_drizzle_port;
 
209
    }
 
210
    break;
 
211
  case 'P':
190
212
    if (argument)
191
213
    {
192
214
      char *start=argument;
193
 
      my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));
194
 
      opt_password=my_strdup(argument,MYF(MY_FAE));
195
 
      while (*argument) *argument++= 'x';    /* Destroy argument */
 
215
      if (opt_password)
 
216
        free(opt_password);
 
217
      opt_password = strdup(argument);
 
218
      if (opt_password == NULL)
 
219
      {
 
220
        fprintf(stderr, "Memory allocation error while copying password. "
 
221
                        "Aborting.\n");
 
222
        exit(ENOMEM);
 
223
      }
 
224
      while (*argument)
 
225
      {
 
226
        /* Overwriting password with 'x' */
 
227
        *argument++= 'x';
 
228
      }
196
229
      if (*start)
197
 
  start[1]=0;        /* Cut length of argument */
 
230
      {
 
231
        /* Cut length of argument */
 
232
        start[1]= 0;
 
233
      }
198
234
      tty_password= 0;
199
235
    }
200
236
    else
201
237
      tty_password= 1;
202
238
    break;
203
239
  case OPT_DRIZZLE_PROTOCOL:
204
 
    opt_protocol= find_type_or_exit(argument, &sql_protocol_typelib,
205
 
                                    opt->name);
206
240
    break;
207
241
  case 'V': print_version(); exit(0);
208
242
  case 'I':
230
264
    fprintf(stderr, "You can't use ..enclosed.. and ..optionally-enclosed.. at the same time.\n");
231
265
    return(1);
232
266
  }
233
 
  if (opt_replace && ignore)
 
267
  if (opt_replace && ignore_unique)
234
268
  {
235
 
    fprintf(stderr, "You can't use --ignore (-i) and --replace (-r) at the same time.\n");
 
269
    fprintf(stderr, "You can't use --ignore_unique (-i) and --replace (-r) at the same time.\n");
236
270
    return(1);
237
271
  }
238
 
  if (strcmp(default_charset, charset_info->csname) &&
239
 
      !(charset_info= get_charset_by_csname(default_charset,
240
 
                MY_CS_PRIMARY, MYF(MY_WME))))
241
 
    exit(1);
242
272
  if (*argc < 2)
243
273
  {
244
274
    usage();
247
277
  current_db= *((*argv)++);
248
278
  (*argc)--;
249
279
  if (tty_password)
250
 
    opt_password=get_tty_password(NullS);
 
280
    opt_password=client_get_tty_password(NULL);
251
281
  return(0);
252
282
}
253
283
 
254
284
 
255
285
 
256
 
static int write_to_table(char *filename, DRIZZLE *drizzle)
 
286
static int write_to_table(char *filename, drizzle_con_st *con)
257
287
{
258
288
  char tablename[FN_REFLEN], hard_path[FN_REFLEN],
259
289
       sql_statement[FN_REFLEN*16+256], *end;
 
290
  drizzle_result_st result;
 
291
  drizzle_return_t ret;
260
292
 
261
293
  fn_format(tablename, filename, "", "", 1 | 2); /* removes path & ext. */
262
294
  if (!opt_local_file)
263
 
    stpcpy(hard_path,filename);
 
295
    strcpy(hard_path,filename);
264
296
  else
265
297
    my_load_path(hard_path, filename, NULL); /* filename includes the path */
266
298
 
273
305
#else
274
306
    sprintf(sql_statement, "DELETE FROM %s", tablename);
275
307
#endif
276
 
    if (drizzle_query(drizzle, sql_statement))
 
308
    if (drizzle_query_str(con, &result, sql_statement, &ret) == NULL ||
 
309
        ret != DRIZZLE_RETURN_OK)
277
310
    {
278
 
      db_error_with_table(drizzle, tablename);
 
311
      db_error(con, &result, ret, tablename);
279
312
      return(1);
280
313
    }
 
314
    drizzle_result_free(&result);
281
315
  }
282
 
  to_unix_path(hard_path);
283
316
  if (verbose)
284
317
  {
285
318
    if (opt_local_file)
292
325
  sprintf(sql_statement, "LOAD DATA %s %s INFILE '%s'",
293
326
    opt_low_priority ? "LOW_PRIORITY" : "",
294
327
    opt_local_file ? "LOCAL" : "", hard_path);
295
 
  end= strend(sql_statement);
 
328
  end= strchr(sql_statement, '\0');
296
329
  if (opt_replace)
297
 
    end= stpcpy(end, " REPLACE");
298
 
  if (ignore)
299
 
    end= stpcpy(end, " IGNORE");
300
 
  end= stpcpy(stpcpy(end, " INTO TABLE "), tablename);
 
330
    end= strcpy(end, " REPLACE")+8;
 
331
  if (ignore_unique)
 
332
    end= strcpy(end, " IGNORE")+7;
 
333
 
 
334
  end+= sprintf(end, " INTO TABLE %s", tablename);
301
335
 
302
336
  if (fields_terminated || enclosed || opt_enclosed || escaped)
303
 
      end= stpcpy(end, " FIELDS");
 
337
      end= strcpy(end, " FIELDS")+7;
304
338
  end= add_load_option(end, fields_terminated, " TERMINATED BY");
305
339
  end= add_load_option(end, enclosed, " ENCLOSED BY");
306
340
  end= add_load_option(end, opt_enclosed,
308
342
  end= add_load_option(end, escaped, " ESCAPED BY");
309
343
  end= add_load_option(end, lines_terminated, " LINES TERMINATED BY");
310
344
  if (opt_ignore_lines >= 0)
311
 
    end= stpcpy(int64_t10_to_str(opt_ignore_lines,
312
 
          stpcpy(end, " IGNORE "),10), " LINES");
 
345
  {
 
346
    end= strcpy(end, " IGNORE ")+8;
 
347
    ostringstream buffer;
 
348
    buffer << opt_ignore_lines;
 
349
    end= strcpy(end, buffer.str().c_str())+ buffer.str().size();
 
350
    end= strcpy(end, " LINES")+6;
 
351
  }
313
352
  if (opt_columns)
314
 
    end= stpcpy(stpcpy(stpcpy(end, " ("), opt_columns), ")");
 
353
  {
 
354
    end= strcpy(end, " (")+2;
 
355
    end= strcpy(end, opt_columns)+strlen(opt_columns);
 
356
    end= strcpy(end, ")")+1;
 
357
  }
315
358
  *end= '\0';
316
359
 
317
 
  if (drizzle_query(drizzle, sql_statement))
 
360
  if (drizzle_query_str(con, &result, sql_statement, &ret) == NULL ||
 
361
      ret != DRIZZLE_RETURN_OK)
318
362
  {
319
 
    db_error_with_table(drizzle, tablename);
 
363
    db_error(con, &result, ret, tablename);
320
364
    return(1);
321
365
  }
322
366
  if (!silent)
323
367
  {
324
 
    if (drizzle_info(drizzle)) /* If NULL-pointer, print nothing */
 
368
    if (strcmp(drizzle_result_info(&result), ""))
325
369
    {
326
370
      fprintf(stdout, "%s.%s: %s\n", current_db, tablename,
327
 
        drizzle_info(drizzle));
 
371
        drizzle_result_info(&result));
328
372
    }
329
373
  }
 
374
  drizzle_result_free(&result);
330
375
  return(0);
331
376
}
332
377
 
333
378
 
334
 
 
335
 
static void lock_table(DRIZZLE *drizzle, int tablecount, char **raw_tablename)
 
379
static void lock_table(drizzle_con_st *con, int tablecount, char **raw_tablename)
336
380
{
337
381
  string query;
338
382
  int i;
339
383
  char tablename[FN_REFLEN];
 
384
  drizzle_result_st result;
 
385
  drizzle_return_t ret;
340
386
 
341
387
  if (verbose)
342
388
    fprintf(stdout, "Locking tables for write\n");
347
393
    query.append(tablename);
348
394
    query.append(" WRITE,");
349
395
  }
350
 
  if (drizzle_real_query(drizzle, query.c_str(), query.length()-1))
351
 
    db_error(drizzle); /* We shall countinue here, if --force was given */
 
396
  if (drizzle_query(con, &result, query.c_str(), query.length()-1,
 
397
                    &ret) == NULL ||
 
398
      ret != DRIZZLE_RETURN_OK)
 
399
  {
 
400
    db_error(con, &result, ret, NULL);
 
401
    /* We shall countinue here, if --force was given */
 
402
    return;
 
403
  }
 
404
  drizzle_result_free(&result);
352
405
}
353
406
 
354
407
 
355
 
 
356
 
 
357
 
static DRIZZLE *db_connect(char *host, char *database,
358
 
                         char *user, char *passwd)
 
408
static drizzle_con_st *db_connect(char *host, char *database,
 
409
                                  char *user, char *passwd)
359
410
{
360
 
  DRIZZLE *drizzle;
 
411
  drizzle_st *drizzle;
 
412
  drizzle_con_st *con;
 
413
  drizzle_return_t ret;
 
414
 
361
415
  if (verbose)
362
416
    fprintf(stdout, "Connecting to %s\n", host ? host : "localhost");
363
417
  if (!(drizzle= drizzle_create(NULL)))
364
418
    return 0;
365
 
  if (opt_compress)
366
 
    drizzle_options(drizzle,DRIZZLE_OPT_COMPRESS,NullS);
367
 
  if (opt_local_file)
368
 
    drizzle_options(drizzle,DRIZZLE_OPT_LOCAL_INFILE,
369
 
      (char*) &opt_local_file);
370
 
  if (opt_protocol)
371
 
    drizzle_options(drizzle,DRIZZLE_OPT_PROTOCOL,(char*)&opt_protocol);
372
 
  if (!(drizzle_connect(drizzle,host,user,passwd,
373
 
                           database,opt_drizzle_port,opt_drizzle_unix_port,
374
 
                           0)))
 
419
  if (!(con= drizzle_con_add_tcp(drizzle,NULL,host,opt_drizzle_port,user,passwd,
 
420
                                 database, DRIZZLE_CON_NONE)))
 
421
  {
 
422
    return 0;
 
423
  }
 
424
 
 
425
  if ((ret= drizzle_con_connect(con)) != DRIZZLE_RETURN_OK)
375
426
  {
376
427
    ignore_errors=0;    /* NO RETURN FROM db_error */
377
 
    db_error(drizzle);
 
428
    db_error(con, NULL, ret, NULL);
378
429
  }
379
 
  drizzle->reconnect= 0;
 
430
 
380
431
  if (verbose)
381
432
    fprintf(stdout, "Selecting database %s\n", database);
382
 
  if (drizzle_select_db(drizzle, database))
383
 
  {
384
 
    ignore_errors=0;
385
 
    db_error(drizzle);
386
 
  }
387
 
  return drizzle;
 
433
 
 
434
  return con;
388
435
}
389
436
 
390
437
 
391
438
 
392
 
static void db_disconnect(char *host, DRIZZLE *drizzle)
 
439
static void db_disconnect(char *host, drizzle_con_st *con)
393
440
{
394
441
  if (verbose)
395
442
    fprintf(stdout, "Disconnecting from %s\n", host ? host : "localhost");
396
 
  drizzle_close(drizzle);
 
443
  drizzle_free(drizzle_con_drizzle(con));
397
444
}
398
445
 
399
446
 
400
447
 
401
 
static void safe_exit(int error, DRIZZLE *drizzle)
 
448
static void safe_exit(int error, drizzle_con_st *con)
402
449
{
403
450
  if (ignore_errors)
404
451
    return;
405
 
  if (drizzle)
406
 
    drizzle_close(drizzle);
 
452
  if (con)
 
453
    drizzle_free(drizzle_con_drizzle(con));
407
454
  exit(error);
408
455
}
409
456
 
410
457
 
411
458
 
412
 
static void db_error_with_table(DRIZZLE *drizzle, char *table)
413
 
{
414
 
  my_printf_error(0,"Error: %d, %s, when using table: %s",
415
 
      MYF(0), drizzle_errno(drizzle), drizzle_error(drizzle), table);
416
 
  safe_exit(1, drizzle);
417
 
}
418
 
 
419
 
 
420
 
 
421
 
static void db_error(DRIZZLE *drizzle)
422
 
{
423
 
  my_printf_error(0,"Error: %d %s", MYF(0), drizzle_errno(drizzle), drizzle_error(drizzle));
424
 
  safe_exit(1, drizzle);
 
459
static void db_error(drizzle_con_st *con, drizzle_result_st *result,
 
460
                     drizzle_return_t ret, char *table)
 
461
{
 
462
  if (ret == DRIZZLE_RETURN_ERROR_CODE)
 
463
  {
 
464
    my_printf_error(0,"Error: %d, %s%s%s", MYF(0),
 
465
                    drizzle_result_error_code(result),
 
466
                    drizzle_result_error(result),
 
467
                    table ? ", when using table: " : "", table ? table : "");
 
468
    drizzle_result_free(result);
 
469
  }
 
470
  else
 
471
  {
 
472
    my_printf_error(0,"Error: %d, %s%s%s", MYF(0), ret, drizzle_con_error(con),
 
473
                    table ? ", when using table: " : "", table ? table : "");
 
474
  }
 
475
 
 
476
  safe_exit(1, con);
425
477
}
426
478
 
427
479
 
432
484
  {
433
485
    /* Don't escape hex constants */
434
486
    if (object[0] == '0' && (object[1] == 'x' || object[1] == 'X'))
435
 
      ptr= strxmov(ptr," ",statement," ",object,NullS);
 
487
      ptr+= sprintf(ptr, " %s %s", statement, object);
436
488
    else
437
489
    {
438
490
      /* char constant; escape */
439
 
      ptr= strxmov(ptr," ",statement," '",NullS);
440
 
      ptr= field_escape(ptr,object,(uint) strlen(object));
 
491
      ptr+= sprintf(ptr, " %s '", statement); 
 
492
      ptr= field_escape(ptr,object,(uint32_t) strlen(object));
441
493
      *ptr++= '\'';
442
494
    }
443
495
  }
451
503
** syntax errors from the SQL parser.
452
504
*/
453
505
 
454
 
static char *field_escape(char *to,const char *from,uint length)
 
506
static char *field_escape(char *to,const char *from,uint32_t length)
455
507
{
456
508
  const char *end;
457
 
  uint end_backslashes=0;
 
509
  uint32_t end_backslashes=0;
458
510
 
459
511
  for (end= from+length; from != end; from++)
460
512
  {
470
522
  }
471
523
  /* Add missing backslashes if user has specified odd number of backs.*/
472
524
  if (end_backslashes)
473
 
    *to++= '\\';         
 
525
    *to++= '\\';
474
526
  return to;
475
527
}
476
528
 
477
 
int exitcode= 0;
478
 
 
479
 
static void * worker_thread(void *arg)
 
529
void * worker_thread(void *arg)
480
530
{
481
531
  int error;
482
532
  char *raw_table_name= (char *)arg;
483
 
  DRIZZLE *drizzle= 0;
 
533
  drizzle_con_st *con= NULL;
 
534
  drizzle_result_st result;
 
535
  drizzle_return_t ret;
484
536
 
485
 
  if (drizzle_thread_init())
486
 
    goto error;
487
 
 
488
 
  if (!(drizzle= db_connect(current_host,current_db,current_user,opt_password)))
 
537
  if (!(con= db_connect(current_host,current_db,current_user,opt_password)))
489
538
  {
490
539
    goto error;
491
540
  }
492
541
 
493
 
  if (drizzle_query(drizzle, "/*!40101 set @@character_set_database=binary */;"))
 
542
  if (drizzle_query_str(con, &result,
 
543
                        "/*!40101 set @@character_set_database=binary */;",
 
544
                        &ret) == NULL ||
 
545
      ret != DRIZZLE_RETURN_OK)
494
546
  {
495
 
    db_error(drizzle); /* We shall countinue here, if --force was given */
 
547
    db_error(con, &result, ret, NULL);
 
548
    /* We shall countinue here, if --force was given */
496
549
    goto error;
497
550
  }
498
551
 
499
552
  /*
500
553
    We are not currently catching the error here.
501
554
  */
502
 
  if((error= write_to_table(raw_table_name, drizzle)))
 
555
  if((error= write_to_table(raw_table_name, con)))
503
556
    if (exitcode == 0)
504
557
      exitcode= error;
505
558
 
506
559
error:
507
 
  if (drizzle)
508
 
    db_disconnect(current_host, drizzle);
 
560
  if (con)
 
561
    db_disconnect(current_host, con);
509
562
 
510
563
  pthread_mutex_lock(&counter_mutex);
511
564
  counter--;
523
576
  char **argv_to_free;
524
577
  MY_INIT(argv[0]);
525
578
 
526
 
  load_defaults("my",load_default_groups,&argc,&argv);
 
579
  load_defaults("drizzle",load_default_groups,&argc,&argv);
527
580
  /* argv is changed in the program */
528
581
  argv_to_free= argv;
529
582
  if (get_options(&argc, &argv))
541
594
    pthread_attr_setdetachstate(&attr,
542
595
                                PTHREAD_CREATE_DETACHED);
543
596
 
544
 
    VOID(pthread_mutex_init(&counter_mutex, NULL));
545
 
    VOID(pthread_cond_init(&count_threshhold, NULL));
 
597
    pthread_mutex_init(&counter_mutex, NULL);
 
598
    pthread_cond_init(&count_threshhold, NULL);
546
599
 
547
600
    for (counter= 0; *argv != NULL; argv++) /* Loop through tables */
548
601
    {
581
634
      pthread_cond_timedwait(&count_threshhold, &counter_mutex, &abstime);
582
635
    }
583
636
    pthread_mutex_unlock(&counter_mutex);
584
 
    VOID(pthread_mutex_destroy(&counter_mutex));
585
 
    VOID(pthread_cond_destroy(&count_threshhold));
 
637
    pthread_mutex_destroy(&counter_mutex);
 
638
    pthread_cond_destroy(&count_threshhold);
586
639
    pthread_attr_destroy(&attr);
587
640
  }
588
641
  else
589
642
#endif
590
643
  {
591
 
    DRIZZLE *drizzle= 0;
592
 
    if (!(drizzle= db_connect(current_host,current_db,current_user,opt_password)))
 
644
    drizzle_con_st *con= 0;
 
645
    drizzle_result_st result;
 
646
    drizzle_return_t ret;
 
647
    if (!(con= db_connect(current_host,current_db,current_user,opt_password)))
593
648
    {
594
649
      free_defaults(argv_to_free);
595
 
      return(1); /* purecov: deadcode */
 
650
      return(1);
596
651
    }
597
652
 
598
 
    if (drizzle_query(drizzle, "/*!40101 set @@character_set_database=binary */;"))
 
653
    if (drizzle_query_str(con, &result,
 
654
                          "/*!40101 set @@character_set_database=binary */;",
 
655
                          &ret) == NULL ||
 
656
        ret != DRIZZLE_RETURN_OK)
599
657
    {
600
 
      db_error(drizzle); /* We shall countinue here, if --force was given */
 
658
      db_error(con, &result, ret, NULL);
 
659
      /* We shall countinue here, if --force was given */
601
660
      return(1);
602
661
    }
603
662
 
 
663
    drizzle_result_free(&result);
 
664
 
604
665
    if (lock_tables)
605
 
      lock_table(drizzle, argc, argv);
 
666
      lock_table(con, argc, argv);
606
667
    for (; *argv != NULL; argv++)
607
 
      if ((error= write_to_table(*argv, drizzle)))
 
668
      if ((error= write_to_table(*argv, con)))
608
669
        if (exitcode == 0)
609
670
          exitcode= error;
610
 
    db_disconnect(current_host, drizzle);
 
671
    db_disconnect(current_host, con);
611
672
  }
612
 
  my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));
 
673
  free(opt_password);
613
674
  free_defaults(argv_to_free);
614
675
  my_end(my_end_arg);
615
676
  return(exitcode);