~drizzle-trunk/drizzle/development

 

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

 

/*

**

*/

#define IMPORT_VERSION "3.7"

 

#include "client_priv.h"

 

 

/* Global Thread counter */

uint counter;

pthread_mutex_t counter_mutex;

pthread_cond_t count_threshhold;

 

static char *field_escape(char *to,const char *from,uint length);

static char *add_load_option(char *ptr,const char *object,

 

static bool debug_info_flag= 0, debug_check_flag= 0;

static uint opt_use_threads=0, opt_local_file=0, my_end_arg= 0;

static int64_t opt_ignore_lines= -1;

 

static struct my_option my_long_options[] =

{

  {"local", 'L', "Read all files through the client.", (char**) &opt_local_file,

   (char**) &opt_local_file, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"lock-tables", 'l', "Lock all tables for write (this disables threads).",

    0, 0, 0, 0, 0, 0},

  {"low-priority", OPT_LOW_PRIORITY,

   "Use LOW_PRIORITY when updating the table.", (char**) &opt_low_priority,

   "Password to use when connecting to server. If password is not given it's asked from the tty.",

   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

  {"port", 'P', "Port number to use for connection or 0 for default to, in "

   0},

   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"replace", 'r', "If duplicate unique key was found, replace old row.",

  {"silent", 's', "Be more silent.", (char**) &silent, (char**) &silent, 0,

   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"socket", 'S', "Socket file to use for connection.",

   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"use-threads", OPT_USE_THREADS,

   "Load files in parallel. The argument is the number "

   "of threads to use for loading data.",

   GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

#ifndef DONT_ALLOW_USER_CHANGE

  {"user", 'u', "User for login if not current user.", (char**) &current_user,

};

 

 

 

static void print_version(void)

{

  printf("%s  Ver %s Distrib %s, for %s (%s)\n" ,my_progname,

}

 

 

static void usage(void)

{

  print_version();

  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");

  printf("\

Loads tables from text files in various formats.  The base name of the\n\

text file must be the name of the table that should be used.\n\

read the text file directly. In other cases the client will open the text\n\

file. The SQL command 'LOAD DATA INFILE' is used to import the rows.\n");

 

  my_print_variables(my_long_options);

}

 

static bool

get_one_option(int optid, const struct my_option *opt __attribute__((unused)),

{

  switch(optid) {

  case 'p':

    if (argument)

    {

      char *start=argument;

      opt_password=my_strdup(argument,MYF(MY_FAE));

      if (*start)

      tty_password= 0;

    }

    else

      tty_password= 1;

    break;

    break;

  case 'V': print_version(); exit(0);

  case 'I':

    fprintf(stderr, "You can't use ..enclosed.. and ..optionally-enclosed.. at the same time.\n");

    return(1);

  }

  {

    fprintf(stderr, "You can't use --ignore (-i) and --replace (-r) at the same time.\n");

    return(1);

  }

  if (strcmp(default_charset, charset_info->csname) &&

      !(charset_info= get_charset_by_csname(default_charset,

    exit(1);

  if (*argc < 2)

  {

  current_db= *((*argv)++);

  (*argc)--;

  if (tty_password)

  return(0);

}

 

 

 

{

  char tablename[FN_REFLEN], hard_path[FN_REFLEN],

       sql_statement[FN_REFLEN*16+256], *end;

 

  fn_format(tablename, filename, "", "", 1 | 2); /* removes path & ext. */

  if (!opt_local_file)

  else

    my_load_path(hard_path, filename, NULL); /* filename includes the path */

 

#else

    sprintf(sql_statement, "DELETE FROM %s", tablename);

#endif

    {

      return(1);

    }

  }

  {

    if (opt_local_file)

      fprintf(stdout, "Loading data from LOCAL file: %s into %s\n",

    else

      fprintf(stdout, "Loading data from SERVER file: %s into %s\n",

  }

  sprintf(sql_statement, "LOAD DATA %s %s INFILE '%s'",

  if (ignore)

 

  if (fields_terminated || enclosed || opt_enclosed || escaped)

  end= add_load_option(end, fields_terminated, " TERMINATED BY");

  end= add_load_option(end, enclosed, " ENCLOSED BY");

  end= add_load_option(end, opt_enclosed,

  end= add_load_option(end, escaped, " ESCAPED BY");

  end= add_load_option(end, lines_terminated, " LINES TERMINATED BY");

  if (opt_ignore_lines >= 0)

  if (opt_columns)

  *end= '\0';

 

  {

    return(1);

  }

  if (!silent)

  {

    {

      fprintf(stdout, "%s.%s: %s\n", current_db, tablename,

    }

  }

  return(0);

 

 

 

{

  int i;

  char tablename[FN_REFLEN];

 

  if (verbose)

    fprintf(stdout, "Locking tables for write\n");

  for (i=0 ; i < tablecount ; i++)

  {

    fn_format(tablename, raw_tablename[i], "", "", 1 | 2);

  }

}

 

 

 

 

                         char *user, char *passwd)

{

  if (verbose)

    fprintf(stdout, "Connecting to %s\n", host ? host : "localhost");

    return 0;

  if (opt_compress)

  if (opt_local_file)

  if (opt_protocol)

                           0)))

  {

  }

  if (verbose)

    fprintf(stdout, "Selecting database %s\n", database);

  {

    ignore_errors=0;

  }

}

 

 

 

{

  if (verbose)

    fprintf(stdout, "Disconnecting from %s\n", host ? host : "localhost");

}

 

 

 

{

  if (ignore_errors)

    return;

  exit(error);

}

 

 

 

{

  my_printf_error(0,"Error: %d, %s, when using table: %s",

}

 

 

 

{

}

 

 

static char *add_load_option(char *ptr, const char *object,

{

  if (object)

  {

    /* Don't escape hex constants */

    if (object[0] == '0' && (object[1] == 'x' || object[1] == 'X'))

    else

    {

      /* char constant; escape */

      ptr= field_escape(ptr,object,(uint) strlen(object));

      *ptr++= '\'';

    }

** "'", "\", "\\" (escaped backslash), "\t" (tab), "\n" (newline)

** This is done by doubleing ' and add a end -\ if needed to avoid

** syntax errors from the SQL parser.

 

static char *field_escape(char *to,const char *from,uint length)

{

  const char *end;

 

  for (end= from+length; from != end; from++)

  {

    *to++= *from;

    if (*from == '\\')

      end_backslashes^=1;    /* find odd number of backslashes */

    {

      if (*from == '\'' && !end_backslashes)

      end_backslashes=0;

    }

  }

  /* Add missing backslashes if user has specified odd number of backs.*/

  if (end_backslashes)

  return to;

}

 

int exitcode= 0;

 

{

  int error;

  char *raw_table_name= (char *)arg;

 

  {

    goto error;

  }

 

  {

    goto error;

  }

 

  /*

    We are not currently catching the error here.

  */

    if (exitcode == 0)

      exitcode= error;

 

error:

 

  pthread_mutex_lock(&counter_mutex);

  counter--;

    pthread_attr_setdetachstate(&attr,

                                PTHREAD_CREATE_DETACHED);

 

 

    for (counter= 0; *argv != NULL; argv++) /* Loop through tables */

    {

      counter++;

      pthread_mutex_unlock(&counter_mutex);

      /* now create the thread */

                         (void *)*argv) != 0)

      {

        pthread_mutex_lock(&counter_mutex);

      pthread_cond_timedwait(&count_threshhold, &counter_mutex, &abstime);

    }

    pthread_mutex_unlock(&counter_mutex);

    pthread_attr_destroy(&attr);

  }

  else

#endif

  {

    {

      free_defaults(argv_to_free);

      return(1); /* purecov: deadcode */

    }

 

    {

      return(1);

    }

 

    if (lock_tables)

    for (; *argv != NULL; argv++)

        if (exitcode == 0)

          exitcode= error;

  }

  free_defaults(argv_to_free);

  my_end(my_end_arg);

  return(exitcode);