~mkindahl/drizzle/remove-mem-casts

 

   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"

 

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,

 

                opt_low_priority= 0, tty_password= 0;

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 CHARSET_INFO *charset_info= &my_charset_latin1;

 

  {"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,

   "/etc/services, "

#endif

   "built-in default (" STRINGIFY_ARG(MYSQL_PORT) ").",

   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.",

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

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

 

 

static bool

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

{

  switch(optid) {

  case 'p':

      char *start=argument;

      my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));

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

      if (*start)

      tty_password= 0;

    }

    else

      tty_password= 1;

    break;

    opt_protocol= find_type_or_exit(argument, &sql_protocol_typelib,

                                    opt->name);

    break;

  }

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

      !(charset_info= get_charset_by_csname(default_charset,

    exit(1);

  if (*argc < 2)

  {

 

 

 

{

  char tablename[FN_REFLEN], hard_path[FN_REFLEN],

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

#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'",

  end= strend(sql_statement);

  if (replace)

    end= strmov(end, " REPLACE");

  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= strmov(strmov(strmov(end, " ("), opt_columns), ")");

  *end= '\0';

 

  {

    return(1);

  }

  if (!silent)

  {

    {

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

    }

  }

  return(0);

 

 

 

{

  DYNAMIC_STRING query;

  int i;

    dynstr_append(&query, tablename);

    dynstr_append(&query, " WRITE,");

  }

}

 

 

 

 

                         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)

  {

** "'", "\", "\\" (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 error;

  char *raw_table_name= (char *)arg;

 

    goto error;

  {

    goto error;

  }

 

  {

    goto error;

  }

 

  /*

    We are not currently catching the error here.

  */

    if (exitcode == 0)

      exitcode= error;

 

error:

 

  pthread_mutex_lock(&counter_mutex);

  counter--;

      counter++;

      pthread_mutex_unlock(&counter_mutex);

      /* now create the thread */

                         (void *)*argv) != 0)

      {

        pthread_mutex_lock(&counter_mutex);

  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;

  }

  my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));

  free_defaults(argv_to_free);