← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzleimport.cc

  • Committer: Padraig O'Sullivan
  • Date: 2009-09-17 00:08:20 UTC
  • mto: (1126.9.3 captain-20090915-01)
  • mto: This revision was merged to the branch mainline in revision 1133.
  • Revision ID: osullivan.padraig@gmail.com-20090917000820-urd6p46qngi1okjp
Updated calls to some dtrace probes to cast the parameter to const char *
appropriately. Also, removed the additional variable in places that I was
using.

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/drizzleimport.cc
1
 
/* Copyright (C) 2000-2006 MySQL AB
2
 
   Copyright (C) 2008-2009 Sun Microsystems, Inc
 
1
/* Copyright (C) 2008 Drizzle Open Source Development Team
3
2
 
4
3
   This program is free software; you can redistribute it and/or modify
5
4
   it under the terms of the GNU General Public License as published by
29
28
 
30
29
#include "client_priv.h"
31
30
#include <string>
32
 
#include <sstream>
33
31
 
34
32
#include <pthread.h>
35
33
 
37
35
#include <drizzled/gettext.h>
38
36
 
39
37
using namespace std;
40
 
using namespace drizzled;
41
38
 
42
 
extern "C" void * worker_thread(void *arg);
 
39
extern "C"
 
40
{
 
41
  bool get_one_option(int optid, const struct my_option *, char *argument);
 
42
  void * worker_thread(void *arg);
 
43
}
43
44
 
44
45
int exitcode= 0;
45
46
 
56
57
 
57
58
static bool verbose= false, lock_tables= false, ignore_errors= false,
58
59
            opt_delete= false, opt_replace= false, silent= false,
59
 
            ignore_unique= false, opt_low_priority= false,
60
 
            tty_password= false, opt_mysql= false;
61
 
 
62
 
static uint32_t opt_use_threads= 0, opt_local_file= 0;
 
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;
63
64
static char  *opt_password= NULL, *current_user= NULL,
64
65
    *current_host= NULL, *current_db= NULL, *fields_terminated= NULL,
65
66
    *lines_terminated= NULL, *enclosed= NULL, *opt_enclosed= NULL,
66
67
    *escaped= NULL, *opt_columns= NULL;
67
68
static uint32_t opt_drizzle_port= 0;
 
69
static char * opt_drizzle_unix_port= 0;
68
70
static int64_t opt_ignore_lines= -1;
69
71
 
70
 
static struct option my_long_options[] =
 
72
static struct my_option my_long_options[] =
71
73
{
72
74
  {"columns", 'c',
73
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.",
74
76
   (char**) &opt_columns, (char**) &opt_columns, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,
75
77
   0, 0, 0},
 
78
  {"compress", 'C', "Use compression in server/client protocol.",
 
79
   (char**) &opt_compress, (char**) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
 
80
   0, 0, 0},
76
81
  {"debug",'#', "Output debug log. Often this is 'd:t:o,filename'.", 0, 0, 0,
77
82
   GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
83
  {"debug-check", OPT_DEBUG_CHECK, "Check memory and open file usage at exit.",
 
84
   (char**) &debug_check_flag, (char**) &debug_check_flag, 0,
 
85
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
86
  {"debug-info", OPT_DEBUG_INFO, "Print some debug info at exit.",
 
87
   (char**) &debug_info_flag, (char**) &debug_info_flag,
 
88
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
78
89
  {"delete", 'd', "First delete all rows from table.", (char**) &opt_delete,
79
90
   (char**) &opt_delete, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
80
91
  {"fields-terminated-by", OPT_FTB,
112
123
  {"low-priority", OPT_LOW_PRIORITY,
113
124
   "Use LOW_PRIORITY when updating the table.", (char**) &opt_low_priority,
114
125
   (char**) &opt_low_priority, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
115
 
  {"mysql", 'm', N_("Use MySQL Protocol."),
116
 
   (char**) &opt_mysql, (char**) &opt_mysql, 0, GET_BOOL, NO_ARG, 1, 0, 0,
117
 
   0, 0, 0},
118
126
  {"password", 'P',
119
127
   "Password to use when connecting to server. If password is not given it's asked from the tty.",
120
128
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
128
136
   (char**) &opt_replace, (char**) &opt_replace, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
129
137
  {"silent", 's', "Be more silent.", (char**) &silent, (char**) &silent, 0,
130
138
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
139
  {"socket", 'S', "Socket file to use for connection.",
 
140
   (char**) &opt_drizzle_unix_port, (char**) &opt_drizzle_unix_port, 0, GET_STR,
 
141
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
131
142
  {"use-threads", OPT_USE_THREADS,
132
143
   "Load files in parallel. The argument is the number "
133
144
   "of threads to use for loading data.",
147
158
 
148
159
static void print_version(void)
149
160
{
150
 
  printf("%s  Ver %s Distrib %s, for %s-%s (%s)\n" ,internal::my_progname,
 
161
  printf("%s  Ver %s Distrib %s, for %s-%s (%s)\n" ,my_progname,
151
162
    IMPORT_VERSION, drizzle_version(),HOST_VENDOR,HOST_OS,HOST_CPU);
152
163
}
153
164
 
164
175
read the text file directly. In other cases the client will open the text\n\
165
176
file. The SQL command 'LOAD DATA INFILE' is used to import the rows.\n");
166
177
 
167
 
  printf("\nUsage: %s [OPTIONS] database textfile...",internal::my_progname);
168
 
  internal::print_defaults("drizzle",load_default_groups);
 
178
  printf("\nUsage: %s [OPTIONS] database textfile...",my_progname);
 
179
  print_defaults("drizzle",load_default_groups);
169
180
  my_print_help(my_long_options);
170
181
  my_print_variables(my_long_options);
171
182
}
172
183
 
173
 
static int get_one_option(int optid, const struct option *, char *argument)
 
184
bool get_one_option(int optid, const struct my_option *, char *argument)
174
185
{
175
186
  char *endchar= NULL;
176
187
  uint64_t temp_drizzle_port= 0;
182
193
    if (strlen(endchar) != 0)
183
194
    {
184
195
      fprintf(stderr, _("Non-integer value supplied for port.  If you are trying to enter a password please use --password instead.\n"));
185
 
      return EXIT_ARGUMENT_INVALID;
 
196
      exit(1);
186
197
    }
187
198
    /* If the port number is > 65535 it is not a valid port
188
199
       This also helps with potential data loss casting unsigned long to a
190
201
    if ((temp_drizzle_port == 0) || (temp_drizzle_port > 65535))
191
202
    {
192
203
      fprintf(stderr, _("Value supplied for port is not valid.\n"));
193
 
      return EXIT_ARGUMENT_INVALID;
 
204
      exit(1);
194
205
    }
195
206
    else
196
207
    {
208
219
      {
209
220
        fprintf(stderr, "Memory allocation error while copying password. "
210
221
                        "Aborting.\n");
211
 
        return EXIT_OUT_OF_MEMORY;
 
222
        exit(ENOMEM);
212
223
      }
213
224
      while (*argument)
214
225
      {
243
254
 
244
255
  if ((ho_error=handle_options(argc, argv, my_long_options, get_one_option)))
245
256
    exit(ho_error);
 
257
  if (debug_info_flag)
 
258
    my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;
 
259
  if (debug_check_flag)
 
260
    my_end_arg= MY_CHECK_ERROR;
246
261
 
247
262
  if (enclosed && opt_enclosed)
248
263
  {
275
290
  drizzle_result_st result;
276
291
  drizzle_return_t ret;
277
292
 
278
 
  internal::fn_format(tablename, filename, "", "", 1 | 2); /* removes path & ext. */
 
293
  fn_format(tablename, filename, "", "", 1 | 2); /* removes path & ext. */
279
294
  if (!opt_local_file)
280
295
    strcpy(hard_path,filename);
281
296
  else
282
 
    internal::my_load_path(hard_path, filename, NULL); /* filename includes the path */
 
297
    my_load_path(hard_path, filename, NULL); /* filename includes the path */
283
298
 
284
299
  if (opt_delete)
285
300
  {
286
301
    if (verbose)
287
302
      fprintf(stdout, "Deleting the old data from table %s\n", tablename);
288
303
#ifdef HAVE_SNPRINTF
289
 
    snprintf(sql_statement, sizeof(sql_statement), "DELETE FROM %s", tablename);
 
304
    snprintf(sql_statement, FN_REFLEN*16+256, "DELETE FROM %s", tablename);
290
305
#else
291
 
    snprintf(sql_statement, sizeof(sql_statement), "DELETE FROM %s", tablename);
 
306
    sprintf(sql_statement, "DELETE FROM %s", tablename);
292
307
#endif
293
308
    if (drizzle_query_str(con, &result, sql_statement, &ret) == NULL ||
294
309
        ret != DRIZZLE_RETURN_OK)
307
322
      fprintf(stdout, "Loading data from SERVER file: %s into %s\n",
308
323
        hard_path, tablename);
309
324
  }
310
 
  snprintf(sql_statement, sizeof(sql_statement), "LOAD DATA %s %s INFILE '%s'",
 
325
  sprintf(sql_statement, "LOAD DATA %s %s INFILE '%s'",
311
326
    opt_low_priority ? "LOW_PRIORITY" : "",
312
327
    opt_local_file ? "LOCAL" : "", hard_path);
313
328
  end= strchr(sql_statement, '\0');
374
389
  query.append("LOCK TABLES ");
375
390
  for (i=0 ; i < tablecount ; i++)
376
391
  {
377
 
    internal::fn_format(tablename, raw_tablename[i], "", "", 1 | 2);
 
392
    fn_format(tablename, raw_tablename[i], "", "", 1 | 2);
378
393
    query.append(tablename);
379
394
    query.append(" WRITE,");
380
395
  }
402
417
  if (!(drizzle= drizzle_create(NULL)))
403
418
    return 0;
404
419
  if (!(con= drizzle_con_add_tcp(drizzle,NULL,host,opt_drizzle_port,user,passwd,
405
 
                                 database, opt_mysql ? DRIZZLE_CON_MYSQL : DRIZZLE_CON_NONE)))
 
420
                                 database, DRIZZLE_CON_NONE)))
406
421
  {
407
422
    return 0;
408
423
  }
549
564
  counter--;
550
565
  pthread_cond_signal(&count_threshhold);
551
566
  pthread_mutex_unlock(&counter_mutex);
552
 
  internal::my_thread_end();
 
567
  my_thread_end();
553
568
 
554
569
  return 0;
555
570
}
561
576
  char **argv_to_free;
562
577
  MY_INIT(argv[0]);
563
578
 
564
 
  internal::load_defaults("drizzle",load_default_groups,&argc,&argv);
 
579
  load_defaults("drizzle",load_default_groups,&argc,&argv);
565
580
  /* argv is changed in the program */
566
581
  argv_to_free= argv;
567
582
  if (get_options(&argc, &argv))
568
583
  {
569
 
    internal::free_defaults(argv_to_free);
 
584
    free_defaults(argv_to_free);
570
585
    return(1);
571
586
  }
572
587
 
603
618
        counter--;
604
619
        pthread_mutex_unlock(&counter_mutex);
605
620
        fprintf(stderr,"%s: Could not create thread\n",
606
 
                internal::my_progname);
 
621
                my_progname);
607
622
      }
608
623
    }
609
624
 
631
646
    drizzle_return_t ret;
632
647
    if (!(con= db_connect(current_host,current_db,current_user,opt_password)))
633
648
    {
634
 
      internal::free_defaults(argv_to_free);
635
 
      return(1);
 
649
      free_defaults(argv_to_free);
 
650
      return(1); /* purecov: deadcode */
636
651
    }
637
652
 
638
653
    if (drizzle_query_str(con, &result,
656
671
    db_disconnect(current_host, con);
657
672
  }
658
673
  free(opt_password);
659
 
  internal::free_defaults(argv_to_free);
660
 
  internal::my_end();
 
674
  free_defaults(argv_to_free);
 
675
  my_end(my_end_arg);
661
676
  return(exitcode);
662
677
}