~drizzle-trunk/drizzle/development

 

/* Copy data from a textfile to table */

 

#include <drizzled/sql_load.h>

#include <drizzled/error.h>

#include <drizzled/data_home.h>

#include <drizzled/session.h>

#include <drizzled/sql_base.h>

#include <drizzled/field/epoch.h>

 

#include <sys/stat.h>

#include <fcntl.h>

 

  /*

    Either this method, or we need to make cache public

    either the table or Session value

  */

  void set_io_cache_arg(void* arg) { cache.arg = arg; }

  Execute LOAD DATA query

 

  SYNOPSYS

      session - current thread

      ex  - file_exchange object representing source cursor and its parsing rules

      table_list  - list of tables to which we are loading data

    true - error / false - success

*/

 

                List<Item> &fields_vars, List<Item> &set_fields,

                List<Item> &set_values,

                enum enum_duplicates handle_duplicates, bool ignore)

  if (session->openTablesLock(table_list))

    return(true);

 

                                    table_list,

     return(-1);

 

  /*

 

  size_t tot_length=0;

  bool use_blobs= 0, use_vars= 0;

  Item *item;

 

  while ((item= it++))

  info.handle_duplicates=handle_duplicates;

  info.escape_char=escaped->length() ? (*escaped)[0] : INT_MAX;

 

  READ_INFO read_info(file, tot_length,

                      ex->cs ? ex->cs : plugin::StorageEngine::getSchemaCollation(identifier),

                      *field_term, *ex->line_start, *ex->line_term, *enclosed,

    table->cursor->ha_start_bulk_insert((ha_rows) 0);

    table->copy_blobs=1;

 

 

    if (!field_term->length() && !enclosed->length())

      error= read_fixed_length(session, info, table_list, fields_vars,

              session->transaction.stmt.hasModifiedNonTransData());

  table->cursor->ha_release_auto_increment();

  table->auto_increment_field_not_null= false;

  return(error);

}

 

                  List<Item> &set_values, READ_INFO &read_info,

                  uint32_t skip_lines, bool ignore_check_option_errors)

{

  Item_field *sql_field;

  Table *table= table_list->table;

  uint64_t id;

      skip_lines--;

      continue;

    }

    unsigned char *pos=read_info.row_start;

#ifdef HAVE_VALGRIND

    read_info.row_end[0]=0;

                            ER_WARN_TOO_FEW_RECORDS,

                            ER(ER_WARN_TOO_FEW_RECORDS), session->row_count);

 

            ((field::Epoch::pointer) field)->set_time();

      }

      else

               String &enclosed, uint32_t skip_lines,

               bool ignore_check_option_errors)

{

  Item *item;

  Table *table= table_list->table;

  uint32_t enclosed_length;

  enclosed_length=enclosed.length();

  id= 0;

 

  {

    if (session->getKilled())

    {

            return(1);

          }

          field->set_null();

          {

            {

              ((field::Epoch::pointer) field)->set_time();

            }

                     session->row_count);

            return(1);

          }

              ((field::Epoch::pointer) field)->set_time();

          /*

            QQ: We probably should not throw warning for each field.