← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/mysqlimport.c

  • Committer: brian
  • Date: 2008-06-25 05:29:13 UTC
  • Revision ID: brian@localhost.localdomain-20080625052913-6upwo0jsrl4lnapl
clean slate

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/mysqlimport.c
1
 
/* 
2
 
  Copyright (C) 2010 Vijay Samuel
3
 
  Copyright (C) 2010 Brian Aker
4
 
  Copyright (C) 2000-2006 MySQL AB
5
 
  Copyright (C) 2008-2009 Sun Microsystems, Inc.
6
 
 
7
 
  This program is free software; you can redistribute it and/or modify
8
 
  it under the terms of the GNU General Public License as published by
9
 
  the Free Software Foundation; version 2 of the License.
10
 
 
11
 
  This program is distributed in the hope that it will be useful,
12
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
  GNU General Public License for more details.
15
 
 
16
 
  You should have received a copy of the GNU General Public License
17
 
  along with this program; if not, write to the Free Software
18
 
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
19
 
 
20
 
#define IMPORT_VERSION "4.0"
 
1
/* Copyright (C) 2000-2006 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
/*
 
17
**         mysqlimport.c  - Imports all given files
 
18
**                          into a table(s).
 
19
**
 
20
**                         *************************
 
21
**                         *                       *
 
22
**                         * AUTHOR: Monty & Jani  *
 
23
**                         * DATE:   June 24, 1997 *
 
24
**                         *                       *
 
25
**                         *************************
 
26
*/
 
27
#define IMPORT_VERSION "3.7"
21
28
 
22
29
#include "client_priv.h"
23
 
#include <string>
24
 
#include <sstream>
25
 
#include <iostream>
26
 
#include <fstream>
27
 
#include <boost/program_options.hpp>
28
 
#include <pthread.h>
29
 
 
30
 
/* Added this for string translation. */
31
 
#include <drizzled/gettext.h>
32
 
#include <drizzled/configmake.h>
33
 
 
34
 
namespace po= boost::program_options;
35
 
using namespace std;
36
 
using namespace drizzled;
37
 
 
38
 
extern "C" void * worker_thread(void *arg);
39
 
 
40
 
int exitcode= 0;
41
 
 
42
 
const char *program_name= "drizzleimport";
 
30
#include "mysql_version.h"
 
31
#ifdef HAVE_LIBPTHREAD
 
32
#include <my_pthread.h>
 
33
#endif
 
34
 
43
35
 
44
36
/* Global Thread counter */
45
 
uint32_t counter;
 
37
uint counter;
 
38
#ifdef HAVE_LIBPTHREAD
46
39
pthread_mutex_t counter_mutex;
47
40
pthread_cond_t count_threshhold;
 
41
#endif
48
42
 
49
 
static void db_error(drizzle_con_st *con, drizzle_result_st *result,
50
 
                     drizzle_return_t ret, char *table);
51
 
static char *field_escape(char *to,const char *from,uint32_t length);
 
43
static void db_error_with_table(MYSQL *mysql, char *table);
 
44
static void db_error(MYSQL *mysql);
 
45
static char *field_escape(char *to,const char *from,uint length);
52
46
static char *add_load_option(char *ptr,const char *object,
53
 
           const char *statement);
54
 
 
55
 
static bool verbose= false, ignore_errors= false,
56
 
            opt_delete= false, opt_replace= false, silent= false,
57
 
            ignore_unique= false, opt_low_priority= false,
58
 
            use_drizzle_protocol= false, opt_local_file;
59
 
 
60
 
static uint32_t opt_use_threads;
61
 
static uint32_t opt_drizzle_port= 0;
62
 
static int64_t opt_ignore_lines= -1;
63
 
 
64
 
std::string opt_columns,
65
 
  opt_enclosed,
66
 
  escaped,
67
 
  password,
68
 
  current_db,
69
 
  lines_terminated,
70
 
  current_user,
71
 
  opt_password,
72
 
  enclosed,  
73
 
  current_host,
74
 
  fields_terminated,
75
 
  opt_protocol;
76
 
 
77
 
 
78
 
static int get_options(void)
79
 
{
80
 
 
81
 
  if (! enclosed.empty() && ! opt_enclosed.empty())
 
47
                             const char *statement);
 
48
 
 
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;
 
53
static uint opt_use_threads=0, opt_local_file=0, my_end_arg= 0;
 
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
 
67
 
 
68
static struct my_option my_long_options[] =
 
69
{
 
70
#ifdef __NETWARE__
 
71
  {"autoclose", OPT_AUTO_CLOSE, "Auto close the screen on exit for Netware.",
 
72
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
73
#endif
 
74
  {"character-sets-dir", OPT_CHARSETS_DIR,
 
75
   "Directory where character sets are.", (uchar**) &charsets_dir,
 
76
   (uchar**) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
77
  {"default-character-set", OPT_DEFAULT_CHARSET,
 
78
   "Set the default character set.", (uchar**) &default_charset,
 
79
   (uchar**) &default_charset, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
80
  {"columns", 'c',
 
81
   "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.",
 
82
   (uchar**) &opt_columns, (uchar**) &opt_columns, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,
 
83
   0, 0, 0},
 
84
  {"compress", 'C', "Use compression in server/client protocol.",
 
85
   (uchar**) &opt_compress, (uchar**) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
 
86
   0, 0, 0},
 
87
  {"debug",'#', "Output debug log. Often this is 'd:t:o,filename'.", 0, 0, 0,
 
88
   GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
89
  {"debug-check", OPT_DEBUG_CHECK, "Check memory and open file usage at exit.",
 
90
   (uchar**) &debug_check_flag, (uchar**) &debug_check_flag, 0,
 
91
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
92
  {"debug-info", OPT_DEBUG_INFO, "Print some debug info at exit.",
 
93
   (uchar**) &debug_info_flag, (uchar**) &debug_info_flag,
 
94
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
95
  {"delete", 'd', "First delete all rows from table.", (uchar**) &opt_delete,
 
96
   (uchar**) &opt_delete, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
97
  {"fields-terminated-by", OPT_FTB,
 
98
   "Fields in the textfile are terminated by ...", (uchar**) &fields_terminated,
 
99
   (uchar**) &fields_terminated, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
100
  {"fields-enclosed-by", OPT_ENC,
 
101
   "Fields in the importfile are enclosed by ...", (uchar**) &enclosed,
 
102
   (uchar**) &enclosed, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
103
  {"fields-optionally-enclosed-by", OPT_O_ENC,
 
104
   "Fields in the i.file are opt. enclosed by ...", (uchar**) &opt_enclosed,
 
105
   (uchar**) &opt_enclosed, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
106
  {"fields-escaped-by", OPT_ESC, "Fields in the i.file are escaped by ...",
 
107
   (uchar**) &escaped, (uchar**) &escaped, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0,
 
108
   0, 0},
 
109
  {"force", 'f', "Continue even if we get an sql-error.",
 
110
   (uchar**) &ignore_errors, (uchar**) &ignore_errors, 0, GET_BOOL, NO_ARG, 0, 0,
 
111
   0, 0, 0, 0},
 
112
  {"help", '?', "Displays this help and exits.", 0, 0, 0, GET_NO_ARG, NO_ARG,
 
113
   0, 0, 0, 0, 0, 0},
 
114
  {"host", 'h', "Connect to host.", (uchar**) &current_host,
 
115
   (uchar**) &current_host, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
116
  {"ignore", 'i', "If duplicate unique key was found, keep old row.",
 
117
   (uchar**) &ignore, (uchar**) &ignore, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
118
  {"ignore-lines", OPT_IGN_LINES, "Ignore first n lines of data infile.",
 
119
   (uchar**) &opt_ignore_lines, (uchar**) &opt_ignore_lines, 0, GET_LL,
 
120
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
121
  {"lines-terminated-by", OPT_LTB, "Lines in the i.file are terminated by ...",
 
122
   (uchar**) &lines_terminated, (uchar**) &lines_terminated, 0, GET_STR,
 
123
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
124
  {"local", 'L', "Read all files through the client.", (uchar**) &opt_local_file,
 
125
   (uchar**) &opt_local_file, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
126
  {"lock-tables", 'l', "Lock all tables for write (this disables threads).",
 
127
    (uchar**) &lock_tables, (uchar**) &lock_tables, 0, GET_BOOL, NO_ARG, 
 
128
    0, 0, 0, 0, 0, 0},
 
129
  {"low-priority", OPT_LOW_PRIORITY,
 
130
   "Use LOW_PRIORITY when updating the table.", (uchar**) &opt_low_priority,
 
131
   (uchar**) &opt_low_priority, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
132
  {"password", 'p',
 
133
   "Password to use when connecting to server. If password is not given it's asked from the tty.",
 
134
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
135
#ifdef __WIN__
 
136
  {"pipe", 'W', "Use named pipes to connect to server.", 0, 0, 0, GET_NO_ARG,
 
137
   NO_ARG, 0, 0, 0, 0, 0, 0},
 
138
#endif
 
139
  {"port", 'P', "Port number to use for connection or 0 for default to, in "
 
140
   "order of preference, my.cnf, $MYSQL_TCP_PORT, "
 
141
#if MYSQL_PORT_DEFAULT == 0
 
142
   "/etc/services, "
 
143
#endif
 
144
   "built-in default (" STRINGIFY_ARG(MYSQL_PORT) ").",
 
145
   (uchar**) &opt_mysql_port,
 
146
   (uchar**) &opt_mysql_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0,
 
147
   0},
 
148
  {"protocol", OPT_MYSQL_PROTOCOL, "The protocol of connection (tcp,socket,pipe,memory).",
 
149
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
150
  {"replace", 'r', "If duplicate unique key was found, replace old row.",
 
151
   (uchar**) &replace, (uchar**) &replace, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
152
#ifdef HAVE_SMEM
 
153
  {"shared-memory-base-name", OPT_SHARED_MEMORY_BASE_NAME,
 
154
   "Base name of shared memory.", (uchar**) &shared_memory_base_name, (uchar**) &shared_memory_base_name,
 
155
   0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
156
#endif
 
157
  {"silent", 's', "Be more silent.", (uchar**) &silent, (uchar**) &silent, 0,
 
158
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
159
  {"socket", 'S', "Socket file to use for connection.",
 
160
   (uchar**) &opt_mysql_unix_port, (uchar**) &opt_mysql_unix_port, 0, GET_STR,
 
161
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
162
  {"use-threads", OPT_USE_THREADS,
 
163
   "Load files in parallel. The argument is the number "
 
164
   "of threads to use for loading data.",
 
165
   (uchar**) &opt_use_threads, (uchar**) &opt_use_threads, 0, 
 
166
   GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
167
#ifndef DONT_ALLOW_USER_CHANGE
 
168
  {"user", 'u', "User for login if not current user.", (uchar**) &current_user,
 
169
   (uchar**) &current_user, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
170
#endif
 
171
  {"verbose", 'v', "Print info about the various stages.", (uchar**) &verbose,
 
172
   (uchar**) &verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
173
  {"version", 'V', "Output version information and exit.", 0, 0, 0, GET_NO_ARG,
 
174
   NO_ARG, 0, 0, 0, 0, 0, 0},
 
175
  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
 
176
};
 
177
 
 
178
 
 
179
static const char *load_default_groups[]= { "mysqlimport","client",0 };
 
180
 
 
181
#include <help_start.h>
 
182
 
 
183
static void print_version(void)
 
184
{
 
185
  printf("%s  Ver %s Distrib %s, for %s (%s)\n" ,my_progname,
 
186
          IMPORT_VERSION, MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
 
187
  NETWARE_SET_SCREEN_MODE(1);
 
188
}
 
189
 
 
190
 
 
191
static void usage(void)
 
192
{
 
193
  print_version();
 
194
  puts("Copyright (C) 2000-2006 MySQL AB");
 
195
  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");
 
196
  printf("\
 
197
Loads tables from text files in various formats.  The base name of the\n\
 
198
text file must be the name of the table that should be used.\n\
 
199
If one uses sockets to connect to the MySQL server, the server will open and\n\
 
200
read the text file directly. In other cases the client will open the text\n\
 
201
file. The SQL command 'LOAD DATA INFILE' is used to import the rows.\n");
 
202
 
 
203
  printf("\nUsage: %s [OPTIONS] database textfile...",my_progname);
 
204
  print_defaults("my",load_default_groups);
 
205
  my_print_help(my_long_options);
 
206
  my_print_variables(my_long_options);
 
207
}
 
208
 
 
209
#include <help_end.h>
 
210
 
 
211
static my_bool
 
212
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
 
213
               char *argument)
 
214
{
 
215
  switch(optid) {
 
216
#ifdef __NETWARE__
 
217
  case OPT_AUTO_CLOSE:
 
218
    setscreenmode(SCR_AUTOCLOSE_ON_EXIT);
 
219
    break;
 
220
#endif
 
221
  case 'p':
 
222
    if (argument)
 
223
    {
 
224
      char *start=argument;
 
225
      my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));
 
226
      opt_password=my_strdup(argument,MYF(MY_FAE));
 
227
      while (*argument) *argument++= 'x';               /* Destroy argument */
 
228
      if (*start)
 
229
        start[1]=0;                             /* Cut length of argument */
 
230
      tty_password= 0;
 
231
    }
 
232
    else
 
233
      tty_password= 1;
 
234
    break;
 
235
#ifdef __WIN__
 
236
  case 'W':
 
237
    opt_protocol = MYSQL_PROTOCOL_PIPE;
 
238
    opt_local_file=1;
 
239
    break;
 
240
#endif
 
241
  case OPT_MYSQL_PROTOCOL:
 
242
    opt_protocol= find_type_or_exit(argument, &sql_protocol_typelib,
 
243
                                    opt->name);
 
244
    break;
 
245
  case '#':
 
246
    DBUG_PUSH(argument ? argument : "d:t:o");
 
247
    debug_check_flag= 1;
 
248
    break;
 
249
  case 'V': print_version(); exit(0);
 
250
  case 'I':
 
251
  case '?':
 
252
    usage();
 
253
    exit(0);
 
254
  }
 
255
  return 0;
 
256
}
 
257
 
 
258
 
 
259
static int get_options(int *argc, char ***argv)
 
260
{
 
261
  int ho_error;
 
262
 
 
263
  if ((ho_error=handle_options(argc, argv, my_long_options, get_one_option)))
 
264
    exit(ho_error);
 
265
  if (debug_info_flag)
 
266
    my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;
 
267
  if (debug_check_flag)
 
268
    my_end_arg= MY_CHECK_ERROR;
 
269
 
 
270
  if (enclosed && opt_enclosed)
82
271
  {
83
272
    fprintf(stderr, "You can't use ..enclosed.. and ..optionally-enclosed.. at the same time.\n");
84
273
    return(1);
85
274
  }
86
 
  if (opt_replace && ignore_unique)
 
275
  if (replace && ignore)
87
276
  {
88
 
    fprintf(stderr, "You can't use --ignore_unique (-i) and --replace (-r) at the same time.\n");
 
277
    fprintf(stderr, "You can't use --ignore (-i) and --replace (-r) at the same time.\n");
89
278
    return(1);
90
279
  }
91
 
 
 
280
  if (strcmp(default_charset, charset_info->csname) &&
 
281
      !(charset_info= get_charset_by_csname(default_charset,
 
282
                                            MY_CS_PRIMARY, MYF(MY_WME))))
 
283
    exit(1);
 
284
  if (*argc < 2)
 
285
  {
 
286
    usage();
 
287
    return 1;
 
288
  }
 
289
  current_db= *((*argv)++);
 
290
  (*argc)--;
92
291
  if (tty_password)
93
 
    opt_password=client_get_tty_password(NULL);
 
292
    opt_password=get_tty_password(NullS);
94
293
  return(0);
95
294
}
96
295
 
97
296
 
98
297
 
99
 
static int write_to_table(char *filename, drizzle_con_st *con)
 
298
static int write_to_table(char *filename, MYSQL *mysql)
100
299
{
101
300
  char tablename[FN_REFLEN], hard_path[FN_REFLEN],
102
301
       sql_statement[FN_REFLEN*16+256], *end;
103
 
  drizzle_result_st result;
104
 
  drizzle_return_t ret;
 
302
  DBUG_ENTER("write_to_table");
 
303
  DBUG_PRINT("enter",("filename: %s",filename));
105
304
 
106
 
  internal::fn_format(tablename, filename, "", "", 1 | 2); /* removes path & ext. */
107
 
  if (not opt_local_file)
108
 
    strcpy(hard_path,filename);
 
305
  fn_format(tablename, filename, "", "", 1 | 2); /* removes path & ext. */
 
306
  if (!opt_local_file)
 
307
    strmov(hard_path,filename);
109
308
  else
110
 
    internal::my_load_path(hard_path, filename, NULL); /* filename includes the path */
 
309
    my_load_path(hard_path, filename, NULL); /* filename includes the path */
111
310
 
112
311
  if (opt_delete)
113
312
  {
114
313
    if (verbose)
115
314
      fprintf(stdout, "Deleting the old data from table %s\n", tablename);
116
315
#ifdef HAVE_SNPRINTF
117
 
    snprintf(sql_statement, sizeof(sql_statement), "DELETE FROM %s", tablename);
 
316
    snprintf(sql_statement, FN_REFLEN*16+256, "DELETE FROM %s", tablename);
118
317
#else
119
 
    snprintf(sql_statement, sizeof(sql_statement), "DELETE FROM %s", tablename);
 
318
    sprintf(sql_statement, "DELETE FROM %s", tablename);
120
319
#endif
121
 
    if (drizzle_query_str(con, &result, sql_statement, &ret) == NULL ||
122
 
        ret != DRIZZLE_RETURN_OK)
 
320
    if (mysql_query(mysql, sql_statement))
123
321
    {
124
 
      db_error(con, &result, ret, tablename);
125
 
      return(1);
 
322
      db_error_with_table(mysql, tablename);
 
323
      DBUG_RETURN(1);
126
324
    }
127
 
    drizzle_result_free(&result);
128
325
  }
 
326
  to_unix_path(hard_path);
129
327
  if (verbose)
130
328
  {
131
329
    if (opt_local_file)
132
330
      fprintf(stdout, "Loading data from LOCAL file: %s into %s\n",
133
 
        hard_path, tablename);
 
331
              hard_path, tablename);
134
332
    else
135
333
      fprintf(stdout, "Loading data from SERVER file: %s into %s\n",
136
 
        hard_path, tablename);
 
334
              hard_path, tablename);
137
335
  }
138
 
  snprintf(sql_statement, sizeof(sql_statement), "LOAD DATA %s %s INFILE '%s'",
139
 
    opt_low_priority ? "LOW_PRIORITY" : "",
140
 
    opt_local_file ? "LOCAL" : "", hard_path);
141
 
  end= strchr(sql_statement, '\0');
142
 
  if (opt_replace)
143
 
    end= strcpy(end, " REPLACE")+8;
144
 
  if (ignore_unique)
145
 
    end= strcpy(end, " IGNORE")+7;
146
 
 
147
 
  end+= sprintf(end, " INTO TABLE %s", tablename);
148
 
 
149
 
  if (! fields_terminated.empty() || ! enclosed.empty() || ! opt_enclosed.empty() || ! escaped.empty())
150
 
      end= strcpy(end, " FIELDS")+7;
151
 
  end= add_load_option(end, (char *)fields_terminated.c_str(), " TERMINATED BY");
152
 
  end= add_load_option(end, (char *)enclosed.c_str(), " ENCLOSED BY");
153
 
  end= add_load_option(end, (char *)opt_enclosed.c_str(),
154
 
           " OPTIONALLY ENCLOSED BY");
155
 
  end= add_load_option(end, (char *)escaped.c_str(), " ESCAPED BY");
156
 
  end= add_load_option(end, (char *)lines_terminated.c_str(), " LINES TERMINATED BY");
 
336
  sprintf(sql_statement, "LOAD DATA %s %s INFILE '%s'",
 
337
          opt_low_priority ? "LOW_PRIORITY" : "",
 
338
          opt_local_file ? "LOCAL" : "", hard_path);
 
339
  end= strend(sql_statement);
 
340
  if (replace)
 
341
    end= strmov(end, " REPLACE");
 
342
  if (ignore)
 
343
    end= strmov(end, " IGNORE");
 
344
  end= strmov(strmov(end, " INTO TABLE "), tablename);
 
345
 
 
346
  if (fields_terminated || enclosed || opt_enclosed || escaped)
 
347
      end= strmov(end, " FIELDS");
 
348
  end= add_load_option(end, fields_terminated, " TERMINATED BY");
 
349
  end= add_load_option(end, enclosed, " ENCLOSED BY");
 
350
  end= add_load_option(end, opt_enclosed,
 
351
                       " OPTIONALLY ENCLOSED BY");
 
352
  end= add_load_option(end, escaped, " ESCAPED BY");
 
353
  end= add_load_option(end, lines_terminated, " LINES TERMINATED BY");
157
354
  if (opt_ignore_lines >= 0)
158
 
  {
159
 
    end= strcpy(end, " IGNORE ")+8;
160
 
    ostringstream buffer;
161
 
    buffer << opt_ignore_lines;
162
 
    end= strcpy(end, buffer.str().c_str())+ buffer.str().size();
163
 
    end= strcpy(end, " LINES")+6;
164
 
  }
165
 
  if (! opt_columns.empty())
166
 
  {
167
 
    end= strcpy(end, " (")+2;
168
 
    end= strcpy(end, (char *)opt_columns.c_str()+opt_columns.length());
169
 
    end= strcpy(end, ")")+1;
170
 
  }
 
355
    end= strmov(longlong10_to_str(opt_ignore_lines, 
 
356
                                  strmov(end, " IGNORE "),10), " LINES");
 
357
  if (opt_columns)
 
358
    end= strmov(strmov(strmov(end, " ("), opt_columns), ")");
171
359
  *end= '\0';
172
360
 
173
 
  if (drizzle_query_str(con, &result, sql_statement, &ret) == NULL ||
174
 
      ret != DRIZZLE_RETURN_OK)
 
361
  if (mysql_query(mysql, sql_statement))
175
362
  {
176
 
    db_error(con, &result, ret, tablename);
177
 
    return(1);
 
363
    db_error_with_table(mysql, tablename);
 
364
    DBUG_RETURN(1);
178
365
  }
179
366
  if (!silent)
180
367
  {
181
 
    if (strcmp(drizzle_result_info(&result), ""))
 
368
    if (mysql_info(mysql)) /* If NULL-pointer, print nothing */
182
369
    {
183
 
      fprintf(stdout, "%s.%s: %s\n", current_db.c_str(), tablename,
184
 
        drizzle_result_info(&result));
 
370
      fprintf(stdout, "%s.%s: %s\n", current_db, tablename,
 
371
              mysql_info(mysql));
185
372
    }
186
373
  }
187
 
  drizzle_result_free(&result);
188
 
  return(0);
189
 
}
190
 
 
191
 
 
192
 
static drizzle_con_st *db_connect(const string host, const string database,
193
 
                                  const string user, const string passwd)
194
 
{
195
 
  drizzle_st *drizzle;
196
 
  drizzle_con_st *con;
197
 
  drizzle_return_t ret;
198
 
 
199
 
  if (verbose)
200
 
    fprintf(stdout, "Connecting to %s, using protocol %s...\n", ! host.empty() ? host.c_str() : "localhost", opt_protocol.c_str());
201
 
  if (!(drizzle= drizzle_create(NULL)))
202
 
    return 0;
203
 
  if (!(con= drizzle_con_add_tcp(drizzle,NULL,(char *)host.c_str(),opt_drizzle_port,(char *)user.c_str(),(char *)passwd.c_str(),
204
 
                                 (char *)database.c_str(), use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL)))
205
 
  {
206
 
    return 0;
207
 
  }
208
 
 
209
 
  if ((ret= drizzle_con_connect(con)) != DRIZZLE_RETURN_OK)
210
 
  {
211
 
    ignore_errors=0;    /* NO RETURN FROM db_error */
212
 
    db_error(con, NULL, ret, NULL);
213
 
  }
214
 
 
215
 
  if (verbose)
216
 
    fprintf(stdout, "Selecting database %s\n", database.c_str());
217
 
 
218
 
  return con;
219
 
}
220
 
 
221
 
 
222
 
 
223
 
static void db_disconnect(const string host, drizzle_con_st *con)
224
 
{
225
 
  if (verbose)
226
 
    fprintf(stdout, "Disconnecting from %s\n", ! host.empty() ? host.c_str() : "localhost");
227
 
  drizzle_free(drizzle_con_drizzle(con));
228
 
}
229
 
 
230
 
 
231
 
 
232
 
static void safe_exit(int error, drizzle_con_st *con)
 
374
  DBUG_RETURN(0);
 
375
}
 
376
 
 
377
 
 
378
 
 
379
static void lock_table(MYSQL *mysql, int tablecount, char **raw_tablename)
 
380
{
 
381
  DYNAMIC_STRING query;
 
382
  int i;
 
383
  char tablename[FN_REFLEN];
 
384
 
 
385
  if (verbose)
 
386
    fprintf(stdout, "Locking tables for write\n");
 
387
  init_dynamic_string(&query, "LOCK TABLES ", 256, 1024);
 
388
  for (i=0 ; i < tablecount ; i++)
 
389
  {
 
390
    fn_format(tablename, raw_tablename[i], "", "", 1 | 2);
 
391
    dynstr_append(&query, tablename);
 
392
    dynstr_append(&query, " WRITE,");
 
393
  }
 
394
  if (mysql_real_query(mysql, query.str, query.length-1))
 
395
    db_error(mysql); /* We shall countinue here, if --force was given */
 
396
}
 
397
 
 
398
 
 
399
 
 
400
 
 
401
static MYSQL *db_connect(char *host, char *database,
 
402
                         char *user, char *passwd)
 
403
{
 
404
  MYSQL *mysql;
 
405
  if (verbose)
 
406
    fprintf(stdout, "Connecting to %s\n", host ? host : "localhost");
 
407
  if (!(mysql= mysql_init(NULL)))
 
408
    return 0;
 
409
  if (opt_compress)
 
410
    mysql_options(mysql,MYSQL_OPT_COMPRESS,NullS);
 
411
  if (opt_local_file)
 
412
    mysql_options(mysql,MYSQL_OPT_LOCAL_INFILE,
 
413
                  (char*) &opt_local_file);
 
414
#ifdef HAVE_OPENSSL
 
415
  if (opt_use_ssl)
 
416
    mysql_ssl_set(mysql, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
 
417
                  opt_ssl_capath, opt_ssl_cipher);
 
418
  mysql_options(mysql,MYSQL_OPT_SSL_VERIFY_SERVER_CERT,
 
419
                (char*)&opt_ssl_verify_server_cert);
 
420
#endif
 
421
  if (opt_protocol)
 
422
    mysql_options(mysql,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);
 
423
#ifdef HAVE_SMEM
 
424
  if (shared_memory_base_name)
 
425
    mysql_options(mysql,MYSQL_SHARED_MEMORY_BASE_NAME,shared_memory_base_name);
 
426
#endif
 
427
  if (!(mysql_real_connect(mysql,host,user,passwd,
 
428
                           database,opt_mysql_port,opt_mysql_unix_port,
 
429
                           0)))
 
430
  {
 
431
    ignore_errors=0;      /* NO RETURN FROM db_error */
 
432
    db_error(mysql);
 
433
  }
 
434
  mysql->reconnect= 0;
 
435
  if (verbose)
 
436
    fprintf(stdout, "Selecting database %s\n", database);
 
437
  if (mysql_select_db(mysql, database))
 
438
  {
 
439
    ignore_errors=0;
 
440
    db_error(mysql);
 
441
  }
 
442
  return mysql;
 
443
}
 
444
 
 
445
 
 
446
 
 
447
static void db_disconnect(char *host, MYSQL *mysql)
 
448
{
 
449
  if (verbose)
 
450
    fprintf(stdout, "Disconnecting from %s\n", host ? host : "localhost");
 
451
  mysql_close(mysql);
 
452
}
 
453
 
 
454
 
 
455
 
 
456
static void safe_exit(int error, MYSQL *mysql)
233
457
{
234
458
  if (ignore_errors)
235
459
    return;
236
 
  if (con)
237
 
    drizzle_free(drizzle_con_drizzle(con));
 
460
  if (mysql)
 
461
    mysql_close(mysql);
238
462
  exit(error);
239
463
}
240
464
 
241
465
 
242
466
 
243
 
static void db_error(drizzle_con_st *con, drizzle_result_st *result,
244
 
                     drizzle_return_t ret, char *table)
245
 
{
246
 
  if (ret == DRIZZLE_RETURN_ERROR_CODE)
247
 
  {
248
 
    fprintf(stdout, "Error: %d, %s%s%s",
249
 
            drizzle_result_error_code(result),
250
 
            drizzle_result_error(result),
251
 
            table ? ", when using table: " : "", table ? table : "");
252
 
    drizzle_result_free(result);
253
 
  }
254
 
  else
255
 
  {
256
 
    fprintf(stdout, "Error: %d, %s%s%s", ret, drizzle_con_error(con),
257
 
            table ? ", when using table: " : "", table ? table : "");
258
 
  }
259
 
 
260
 
  safe_exit(1, con);
 
467
static void db_error_with_table(MYSQL *mysql, char *table)
 
468
{
 
469
  my_printf_error(0,"Error: %d, %s, when using table: %s",
 
470
                  MYF(0), mysql_errno(mysql), mysql_error(mysql), table);
 
471
  safe_exit(1, mysql);
 
472
}
 
473
 
 
474
 
 
475
 
 
476
static void db_error(MYSQL *mysql)
 
477
{
 
478
  my_printf_error(0,"Error: %d %s", MYF(0), mysql_errno(mysql), mysql_error(mysql));
 
479
  safe_exit(1, mysql);
261
480
}
262
481
 
263
482
 
264
483
static char *add_load_option(char *ptr, const char *object,
265
 
           const char *statement)
 
484
                             const char *statement)
266
485
{
267
486
  if (object)
268
487
  {
269
488
    /* Don't escape hex constants */
270
489
    if (object[0] == '0' && (object[1] == 'x' || object[1] == 'X'))
271
 
      ptr+= sprintf(ptr, " %s %s", statement, object);
 
490
      ptr= strxmov(ptr," ",statement," ",object,NullS);
272
491
    else
273
492
    {
274
493
      /* char constant; escape */
275
 
      ptr+= sprintf(ptr, " %s '", statement); 
276
 
      ptr= field_escape(ptr,object,(uint32_t) strlen(object));
 
494
      ptr= strxmov(ptr," ",statement," '",NullS);
 
495
      ptr= field_escape(ptr,object,(uint) strlen(object));
277
496
      *ptr++= '\'';
278
497
    }
279
498
  }
285
504
** "'", "\", "\\" (escaped backslash), "\t" (tab), "\n" (newline)
286
505
** This is done by doubleing ' and add a end -\ if needed to avoid
287
506
** syntax errors from the SQL parser.
288
 
*/
 
507
*/ 
289
508
 
290
 
static char *field_escape(char *to,const char *from,uint32_t length)
 
509
static char *field_escape(char *to,const char *from,uint length)
291
510
{
292
511
  const char *end;
293
 
  uint32_t end_backslashes=0;
 
512
  uint end_backslashes=0; 
294
513
 
295
514
  for (end= from+length; from != end; from++)
296
515
  {
297
516
    *to++= *from;
298
517
    if (*from == '\\')
299
518
      end_backslashes^=1;    /* find odd number of backslashes */
300
 
    else
 
519
    else 
301
520
    {
302
521
      if (*from == '\'' && !end_backslashes)
303
 
  *to++= *from;      /* We want a dublicate of "'" for DRIZZLE */
 
522
        *to++= *from;      /* We want a dublicate of "'" for MySQL */
304
523
      end_backslashes=0;
305
524
    }
306
525
  }
307
526
  /* Add missing backslashes if user has specified odd number of backs.*/
308
527
  if (end_backslashes)
309
 
    *to++= '\\';
 
528
    *to++= '\\';          
310
529
  return to;
311
530
}
312
531
 
313
 
void * worker_thread(void *arg)
 
532
int exitcode= 0;
 
533
 
 
534
#ifdef HAVE_LIBPTHREAD
 
535
pthread_handler_t worker_thread(void *arg)
314
536
{
315
537
  int error;
316
538
  char *raw_table_name= (char *)arg;
317
 
  drizzle_con_st *con;
318
 
 
319
 
  if (!(con= db_connect(current_host,current_db,current_user,opt_password)))
320
 
  {
321
 
    return 0;
 
539
  MYSQL *mysql= 0;
 
540
 
 
541
  if (mysql_thread_init())
 
542
    goto error;
 
543
  
 
544
  if (!(mysql= db_connect(current_host,current_db,current_user,opt_password)))
 
545
  {
 
546
    goto error;
 
547
  }
 
548
 
 
549
  if (mysql_query(mysql, "/*!40101 set @@character_set_database=binary */;"))
 
550
  {
 
551
    db_error(mysql); /* We shall countinue here, if --force was given */
 
552
    goto error;
322
553
  }
323
554
 
324
555
  /*
325
556
    We are not currently catching the error here.
326
557
  */
327
 
  if ((error= write_to_table(raw_table_name, con)))
328
 
  {
 
558
  if((error= write_to_table(raw_table_name, mysql)))
329
559
    if (exitcode == 0)
330
 
    {
331
560
      exitcode= error;
332
 
    }
333
 
  }
334
561
 
335
 
  if (con)
336
 
  {
337
 
    db_disconnect(current_host, con);
338
 
  }
 
562
error:
 
563
  if (mysql)
 
564
    db_disconnect(current_host, mysql);
339
565
 
340
566
  pthread_mutex_lock(&counter_mutex);
341
567
  counter--;
342
568
  pthread_cond_signal(&count_threshhold);
343
569
  pthread_mutex_unlock(&counter_mutex);
 
570
  my_thread_end();
344
571
 
345
572
  return 0;
346
573
}
 
574
#endif
347
575
 
348
576
 
349
577
int main(int argc, char **argv)
350
578
{
351
 
try
352
 
{
353
579
  int error=0;
354
 
 
355
 
  po::options_description commandline_options("Options used only in command line");
356
 
  commandline_options.add_options()
357
 
 
358
 
  ("debug,#", po::value<string>(),
359
 
  "Output debug log. Often this is 'd:t:o,filename'.")
360
 
  ("delete,d", po::value<bool>(&opt_delete)->default_value(false)->zero_tokens(),
361
 
  "First delete all rows from table.")
362
 
  ("help,?", "Displays this help and exits.")
363
 
  ("ignore,i", po::value<bool>(&ignore_unique)->default_value(false)->zero_tokens(),
364
 
  "If duplicate unique key was found, keep old row.")
365
 
  ("low-priority", po::value<bool>(&opt_low_priority)->default_value(false)->zero_tokens(),
366
 
  "Use LOW_PRIORITY when updating the table.")
367
 
  ("replace,r", po::value<bool>(&opt_replace)->default_value(false)->zero_tokens(),
368
 
  "If duplicate unique key was found, replace old row.")
369
 
  ("verbose,v", po::value<bool>(&verbose)->default_value(false)->zero_tokens(),
370
 
  "Print info about the various stages.")
371
 
  ("version,V", "Output version information and exit.")
372
 
  ;
373
 
 
374
 
  po::options_description import_options("Options specific to the drizzleimport");
375
 
  import_options.add_options()
376
 
  ("columns,C", po::value<string>(&opt_columns)->default_value(""),
377
 
  "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.")
378
 
  ("fields-terminated-by", po::value<string>(&fields_terminated)->default_value(""),
379
 
  "Fields in the textfile are terminated by ...")
380
 
  ("fields-enclosed-by", po::value<string>(&enclosed)->default_value(""),
381
 
  "Fields in the importfile are enclosed by ...")
382
 
  ("fields-optionally-enclosed-by", po::value<string>(&opt_enclosed)->default_value(""),
383
 
  "Fields in the i.file are opt. enclosed by ...")
384
 
  ("fields-escaped-by", po::value<string>(&escaped)->default_value(""),
385
 
  "Fields in the i.file are escaped by ...")
386
 
  ("force,f", po::value<bool>(&ignore_errors)->default_value(false)->zero_tokens(),
387
 
  "Continue even if we get an sql-error.")
388
 
  ("ignore-lines", po::value<int64_t>(&opt_ignore_lines)->default_value(0),
389
 
  "Ignore first n lines of data infile.")
390
 
  ("lines-terminated-by", po::value<string>(&lines_terminated)->default_value(""),
391
 
  "Lines in the i.file are terminated by ...")
392
 
  ("local,L", po::value<bool>(&opt_local_file)->default_value(false)->zero_tokens(),
393
 
  "Read all files through the client.")
394
 
  ("silent,s", po::value<bool>(&silent)->default_value(false)->zero_tokens(),
395
 
  "Be more silent.")
396
 
  ("use-threads", po::value<uint32_t>(&opt_use_threads)->default_value(4),
397
 
  "Load files in parallel. The argument is the number of threads to use for loading data (default is 4.")
398
 
  ;
399
 
 
400
 
  po::options_description client_options("Options specific to the client");
401
 
  client_options.add_options()
402
 
  ("host,h", po::value<string>(&current_host)->default_value("localhost"),
403
 
  "Connect to host.")
404
 
  ("password,P", po::value<string>(&password),
405
 
  "Password to use when connecting to server. If password is not given it's asked from the tty." )
406
 
  ("port,p", po::value<uint32_t>(&opt_drizzle_port)->default_value(0),
407
 
  "Port number to use for connection") 
408
 
  ("protocol", po::value<string>(&opt_protocol)->default_value("mysql"),
409
 
  "The protocol of connection (mysql or drizzle).")
410
 
  ("user,u", po::value<string>(&current_user)->default_value(""),
411
 
  "User for login if not current user.")
412
 
  ;
413
 
 
414
 
  po::options_description long_options("Allowed Options");
415
 
  long_options.add(commandline_options).add(import_options).add(client_options);
416
 
 
417
 
  std::string system_config_dir_import(SYSCONFDIR); 
418
 
  system_config_dir_import.append("/drizzle/drizzleimport.cnf");
419
 
 
420
 
  std::string system_config_dir_client(SYSCONFDIR); 
421
 
  system_config_dir_client.append("/drizzle/client.cnf");
422
 
  
423
 
  std::string user_config_dir((getenv("XDG_CONFIG_HOME")? getenv("XDG_CONFIG_HOME"):"~/.config"));
424
 
 
425
 
  if (user_config_dir.compare(0, 2, "~/") == 0)
426
 
  {
427
 
    char *homedir;
428
 
    homedir= getenv("HOME");
429
 
    if (homedir != NULL)
430
 
      user_config_dir.replace(0, 1, homedir);
431
 
  }
432
 
 
433
 
  po::variables_map vm;
434
 
 
435
 
  // Disable allow_guessing
436
 
  int style = po::command_line_style::default_style & ~po::command_line_style::allow_guessing;
437
 
 
438
 
  po::store(po::command_line_parser(argc, argv).options(long_options).
439
 
            style(style).extra_parser(parse_password_arg).run(), vm);
440
 
 
441
 
  std::string user_config_dir_import(user_config_dir);
442
 
  user_config_dir_import.append("/drizzle/drizzleimport.cnf"); 
443
 
 
444
 
  std::string user_config_dir_client(user_config_dir);
445
 
  user_config_dir_client.append("/drizzle/client.cnf");
446
 
 
447
 
  ifstream user_import_ifs(user_config_dir_import.c_str());
448
 
  po::store(parse_config_file(user_import_ifs, import_options), vm);
449
 
 
450
 
  ifstream user_client_ifs(user_config_dir_client.c_str());
451
 
  po::store(parse_config_file(user_client_ifs, client_options), vm);
452
 
 
453
 
  ifstream system_import_ifs(system_config_dir_import.c_str());
454
 
  store(parse_config_file(system_import_ifs, import_options), vm);
455
 
 
456
 
  ifstream system_client_ifs(system_config_dir_client.c_str());
457
 
  po::store(parse_config_file(system_client_ifs, client_options), vm);
458
 
 
459
 
  po::notify(vm);
460
 
  if (vm.count("protocol"))
461
 
  {
462
 
    std::transform(opt_protocol.begin(), opt_protocol.end(),
463
 
      opt_protocol.begin(), ::tolower);
464
 
 
465
 
    if (not opt_protocol.compare("mysql"))
466
 
      use_drizzle_protocol=false;
467
 
    else if (not opt_protocol.compare("drizzle"))
468
 
      use_drizzle_protocol=true;
469
 
    else
470
 
    {
471
 
      cout << _("Error: Unknown protocol") << " '" << opt_protocol << "'" << endl;
472
 
      exit(-1);
473
 
    }
474
 
  }
475
 
 
476
 
  if (vm.count("port"))
477
 
  {
478
 
    
479
 
    /* If the port number is > 65535 it is not a valid port
480
 
       This also helps with potential data loss casting unsigned long to a
481
 
       uint32_t. */
482
 
    if (opt_drizzle_port > 65535)
483
 
    {
484
 
      fprintf(stderr, _("Value supplied for port is not valid.\n"));
485
 
      exit(EXIT_ARGUMENT_INVALID);
486
 
    }
487
 
  }
488
 
 
489
 
  if( vm.count("password") )
490
 
  {
491
 
    if (!opt_password.empty())
492
 
      opt_password.erase();
493
 
    if (password == PASSWORD_SENTINEL)
494
 
    {
495
 
      opt_password= "";
496
 
    }
497
 
    else
498
 
    {
499
 
      opt_password= password;
500
 
      tty_password= false;
501
 
    }
502
 
  }
503
 
  else
504
 
  {
505
 
      tty_password= true;
506
 
  }
507
 
 
508
 
 
509
 
  if (vm.count("version"))
510
 
  {
511
 
    printf("%s  Ver %s Distrib %s, for %s-%s (%s)\n", program_name,
512
 
    IMPORT_VERSION, drizzle_version(),HOST_VENDOR,HOST_OS,HOST_CPU);
513
 
  }
514
 
  
515
 
  if (vm.count("help") || argc < 2)
516
 
  {
517
 
    printf("%s  Ver %s Distrib %s, for %s-%s (%s)\n", program_name,
518
 
    IMPORT_VERSION, drizzle_version(),HOST_VENDOR,HOST_OS,HOST_CPU);
519
 
    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");
520
 
    printf("\
521
 
    Loads tables from text files in various formats.  The base name of the\n\
522
 
    text file must be the name of the table that should be used.\n\
523
 
    If one uses sockets to connect to the Drizzle server, the server will open and\n\
524
 
    read the text file directly. In other cases the client will open the text\n\
525
 
    file. The SQL command 'LOAD DATA INFILE' is used to import the rows.\n");
526
 
 
527
 
    printf("\nUsage: %s [OPTIONS] database textfile...", program_name);
528
 
    cout<<long_options;
529
 
    exit(0);
530
 
  }
531
 
 
532
 
 
533
 
  if (get_options())
534
 
  {
 
580
  char **argv_to_free;
 
581
  MY_INIT(argv[0]);
 
582
 
 
583
  load_defaults("my",load_default_groups,&argc,&argv);
 
584
  /* argv is changed in the program */
 
585
  argv_to_free= argv;
 
586
  if (get_options(&argc, &argv))
 
587
  {
 
588
    free_defaults(argv_to_free);
535
589
    return(1);
536
590
  }
537
 
  
538
 
  current_db= (*argv)++;
539
 
  argc--;
540
591
 
541
 
  if (opt_use_threads)
 
592
#ifdef HAVE_LIBPTHREAD
 
593
  if (opt_use_threads && !lock_tables)
542
594
  {
543
595
    pthread_t mainthread;            /* Thread descriptor */
544
596
    pthread_attr_t attr;          /* Thread attributes */
546
598
    pthread_attr_setdetachstate(&attr,
547
599
                                PTHREAD_CREATE_DETACHED);
548
600
 
549
 
    pthread_mutex_init(&counter_mutex, NULL);
550
 
    pthread_cond_init(&count_threshhold, NULL);
 
601
    VOID(pthread_mutex_init(&counter_mutex, NULL));
 
602
    VOID(pthread_cond_init(&count_threshhold, NULL));
551
603
 
552
604
    for (counter= 0; *argv != NULL; argv++) /* Loop through tables */
553
605
    {
563
615
      counter++;
564
616
      pthread_mutex_unlock(&counter_mutex);
565
617
      /* now create the thread */
566
 
      if (pthread_create(&mainthread, &attr, worker_thread,
 
618
      if (pthread_create(&mainthread, &attr, worker_thread, 
567
619
                         (void *)*argv) != 0)
568
620
      {
569
621
        pthread_mutex_lock(&counter_mutex);
570
622
        counter--;
571
623
        pthread_mutex_unlock(&counter_mutex);
572
 
        fprintf(stderr,"%s: Could not create thread\n", program_name);
 
624
        fprintf(stderr,"%s: Could not create thread\n",
 
625
                my_progname);
573
626
      }
574
627
    }
575
628
 
585
638
      pthread_cond_timedwait(&count_threshhold, &counter_mutex, &abstime);
586
639
    }
587
640
    pthread_mutex_unlock(&counter_mutex);
588
 
    pthread_mutex_destroy(&counter_mutex);
589
 
    pthread_cond_destroy(&count_threshhold);
 
641
    VOID(pthread_mutex_destroy(&counter_mutex));
 
642
    VOID(pthread_cond_destroy(&count_threshhold));
590
643
    pthread_attr_destroy(&attr);
591
644
  }
592
645
  else
 
646
#endif
593
647
  {
594
 
    drizzle_con_st *con;
 
648
    MYSQL *mysql= 0;
 
649
    if (!(mysql= db_connect(current_host,current_db,current_user,opt_password)))
 
650
    {
 
651
      free_defaults(argv_to_free);
 
652
      return(1); /* purecov: deadcode */
 
653
    }
595
654
 
596
 
    if (!(con= db_connect(current_host,current_db,current_user,opt_password)))
 
655
    if (mysql_query(mysql, "/*!40101 set @@character_set_database=binary */;"))
597
656
    {
 
657
      db_error(mysql); /* We shall countinue here, if --force was given */
598
658
      return(1);
599
659
    }
600
660
 
 
661
    if (lock_tables)
 
662
      lock_table(mysql, argc, argv);
601
663
    for (; *argv != NULL; argv++)
602
 
      if ((error= write_to_table(*argv, con)))
 
664
      if ((error= write_to_table(*argv, mysql)))
603
665
        if (exitcode == 0)
604
666
          exitcode= error;
605
 
    db_disconnect(current_host, con);
606
 
  }
607
 
  opt_password.empty();
608
 
}
609
 
  catch(exception &err)
610
 
  {
611
 
    cerr<<err.what()<<endl;
612
 
  }
 
667
    db_disconnect(current_host, mysql);
 
668
  }
 
669
  my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));
 
670
#ifdef HAVE_SMEM
 
671
  my_free(shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
 
672
#endif
 
673
  free_defaults(argv_to_free);
 
674
  my_end(my_end_arg);
613
675
  return(exitcode);
614
676
}