Skip navigation links

 Systems for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Downloads
• Documentation
• Articles
• Forums
• Bugs
• Forge
• Blogs

 

---

Learn about new MySQL releases, technical articles, events and more.

Subscribe Now »

mysql/src/5.1-dbg/sql/sql_load.cc File Reference

#include "mysql_priv.h"
#include <my_dir.h>
#include <m_ctype.h>
#include "sql_repl.h"
#include "sp_head.h"
#include "sql_trigger.h"

Include dependency graph for sql_load.cc:

Go to the source code of this file.

Classes
class	READ_INFO
Defines
#define	GET   (stack_pos != stack ? *--stack_pos : my_b_get(&cache))
#define	PUSH(A)   *(stack_pos++)=(A)
Functions
static int	read_fixed_length (THD *thd, COPY_INFO &info, TABLE_LIST *table_list, List< Item > &fields_vars, List< Item > &set_fields, List< Item > &set_values, READ_INFO &read_info, ulong skip_lines, bool ignore_check_option_errors)
static int	read_sep_field (THD *thd, COPY_INFO &info, TABLE_LIST *table_list, List< Item > &fields_vars, List< Item > &set_fields, List< Item > &set_values, READ_INFO &read_info, String &enclosed, ulong skip_lines, bool ignore_check_option_errors)
static bool	write_execute_load_query_log_event (THD *thd, bool duplicates, bool ignore, bool transactional_table)
bool	mysql_load (THD *thd, sql_exchange *ex, TABLE_LIST *table_list, List< Item > &fields_vars, List< Item > &set_fields, List< Item > &set_values, enum enum_duplicates handle_duplicates, bool ignore, bool read_file_from_client)

---

Define Documentation

#define GET   (stack_pos != stack ? *--stack_pos : my_b_get(&cache))

Definition at line 940 of file sql_load.cc.

Referenced by READ_INFO::find_start_of_fields(), READ_INFO::next_line(), READ_INFO::read_field(), READ_INFO::read_fixed_length(), and READ_INFO::terminator().

#define PUSH

(

A

)

*(stack_pos++)=(A)

Definition at line 941 of file sql_load.cc.

---

Function Documentation

bool mysql_load	(	THD *	thd,
		sql_exchange *	ex,
		TABLE_LIST *	table_list,
		List< Item > &	fields_vars,
		List< Item > &	set_fields,
		List< Item > &	set_values,
		enum enum_duplicates	handle_duplicates,
		bool	ignore,
		bool	read_file_from_client
	)

Definition at line 112 of file sql_load.cc.

References st_table_list::alias, bitmap_is_set(), bitmap_set_all, bitmap_set_bit(), BLOB_FLAG, bzero, CHECK_FIELD_IGNORE, check_key_in_view(), check_that_all_fields_are_given_values(), st_table::copy_blobs, st_table_list::db, db, DBUG_ENTER, DBUG_RETURN, dirname_length(), DUP_ERROR, DUP_REPLACE, base_list::elements, enclosed, READ_INFO::end_io_cache(), ER, ER_BLOBS_AND_NO_TERMINATED, ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR, ER_LOAD_INFO, ER_NON_UPDATABLE_TABLE, ER_TEXTFILE_NOT_READABLE, ER_UPDATE_TABLE_USED, ER_WRONG_FIELD_TERMINATORS, err, READ_INFO::error, error, escaped, handler::extra(), FALSE, st_table::field, Field::field_index, Item::FIELD_ITEM, st_table::file, Log_event::flags, fn_format(), FN_REFLEN, st_table::found_next_number_field, free_blobs(), ha_autocommit_or_rollback(), ha_enable_transaction(), handler::ha_end_bulk_insert(), HA_EXTRA_IGNORE_DUP_KEY, HA_EXTRA_NO_IGNORE_DUP_KEY, HA_EXTRA_WRITE_CAN_REPLACE, HA_EXTRA_WRITE_CANNOT_REPLACE, HA_POS_ERROR, handler::ha_release_auto_increment(), handler::ha_start_bulk_insert(), Table_triggers_list::has_delete_triggers(), handler::has_transactions(), HAVE_ROW_BASED_REPLICATION, info, INSERT_ACL, MYSQL_LOG::is_open(), String::length(), LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F, st_table::mark_columns_needed_for_insert(), MARK_COLUMNS_READ, MARK_COLUMNS_WRITE, MODE_STRICT_ALL_TABLES, MODE_STRICT_TRANS_TABLES, my_close(), my_errno, my_error(), my_message(), my_open(), MY_RELATIVE_PATH, my_stat(), MY_STAT, MY_UNPACK_FILENAME, MY_WME, MYF, mysql_bin_log, mysql_real_data_home, mysql_unlock_tables(), name, net_request_file(), st_table_list::next_global, READ_INFO::next_line(), st_table::next_number_field, NULL, NullS, open_and_lock_tables(), OPTION_STATUS_NO_TRANS_UPDATE, st_table_list::prepare_check_option(), st_table_list::prepare_where(), handler::print_error(), List< T >::push_back(), read_fixed_length(), read_sep_field(), S_IROTH, st_table_list::select_lex, send_ok(), READ_INFO::set_io_cache_arg(), setup_fields(), setup_tables_and_check_access(), strxnmov(), st_table_list::table, st_table_list::table_name, test, st_table::timestamp_field, st_table::timestamp_field_type, TIMESTAMP_NO_AUTO_SET, st_table::triggers, TRUE, Item::type(), unique_table(), st_table_list::updatable, UPDATE_ACL, MYSQL_BIN_LOG::write(), write_execute_load_query_log_event(), and st_table::write_set.

Referenced by mysql_execute_command().

{
  char name[FN_REFLEN];
  File file;
  TABLE *table= NULL;
  int error;
  String *field_term=ex->field_term,*escaped=ex->escaped;
  String *enclosed=ex->enclosed;
  bool is_fifo=0;
#ifndef EMBEDDED_LIBRARY
  LOAD_FILE_INFO lf_info;
#endif
  char *db = table_list->db;                    // This is never null
  /*
    If path for file is not defined, we will use the current database.
    If this is not set, we will use the directory where the table to be
    loaded is located
  */
  char *tdb= thd->db ? thd->db : db;            // Result is never null
  ulong skip_lines= ex->skip_lines;
  bool transactional_table;
  DBUG_ENTER("mysql_load");

#ifdef EMBEDDED_LIBRARY
  read_file_from_client  = 0; //server is always in the same process 
#endif

  if (escaped->length() > 1 || enclosed->length() > 1)
  {
    my_message(ER_WRONG_FIELD_TERMINATORS,ER(ER_WRONG_FIELD_TERMINATORS),
               MYF(0));
    DBUG_RETURN(TRUE);
  }
  /*
    This needs to be done before external_lock
  */
  ha_enable_transaction(thd, FALSE); 
  if (open_and_lock_tables(thd, table_list))
    DBUG_RETURN(TRUE);
  if (setup_tables_and_check_access(thd, &thd->lex->select_lex.context,
                                    &thd->lex->select_lex.top_join_list,
                                    table_list,
                                    &thd->lex->select_lex.leaf_tables, FALSE,
                                    INSERT_ACL | UPDATE_ACL))
     DBUG_RETURN(-1);
  if (!table_list->table ||               // do not suport join view
      !table_list->updatable ||           // and derived tables
      check_key_in_view(thd, table_list))
  {
    my_error(ER_NON_UPDATABLE_TABLE, MYF(0), table_list->alias, "LOAD");
    DBUG_RETURN(TRUE);
  }
  if (table_list->prepare_where(thd, 0, TRUE) ||
      table_list->prepare_check_option(thd))
  {
    DBUG_RETURN(TRUE);
  }
  /*
    Let us emit an error if we are loading data to table which is used
    in subselect in SET clause like we do it for INSERT.

    The main thing to fix to remove this restriction is to ensure that the
    table is marked to be 'used for insert' in which case we should never
    mark this table as 'const table' (ie, one that has only one row).
  */
  if (unique_table(thd, table_list, table_list->next_global))
  {
    my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->table_name);
    DBUG_RETURN(TRUE);
  }

  table= table_list->table;
  transactional_table= table->file->has_transactions();

  if (!fields_vars.elements)
  {
    Field **field;
    for (field=table->field; *field ; field++)
      fields_vars.push_back(new Item_field(*field));
    bitmap_set_all(table->write_set);
    table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
    /*
      Let us also prepare SET clause, altough it is probably empty
      in this case.
    */
    if (setup_fields(thd, 0, set_fields, MARK_COLUMNS_WRITE, 0, 0) ||
        setup_fields(thd, 0, set_values, MARK_COLUMNS_READ, 0, 0))
      DBUG_RETURN(TRUE);
  }
  else
  {                                             // Part field list
    /* TODO: use this conds for 'WITH CHECK OPTIONS' */
    if (setup_fields(thd, 0, fields_vars, MARK_COLUMNS_WRITE, 0, 0) ||
        setup_fields(thd, 0, set_fields, MARK_COLUMNS_WRITE, 0, 0) ||
        check_that_all_fields_are_given_values(thd, table, table_list))
      DBUG_RETURN(TRUE);
    /*
      Check whenever TIMESTAMP field with auto-set feature specified
      explicitly.
    */
    if (table->timestamp_field)
    {
      if (bitmap_is_set(table->write_set,
                        table->timestamp_field->field_index))
        table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
      else
      {
        bitmap_set_bit(table->write_set,
                       table->timestamp_field->field_index);
      }
    }
    /* Fix the expressions in SET clause */
    if (setup_fields(thd, 0, set_values, MARK_COLUMNS_READ, 0, 0))
      DBUG_RETURN(TRUE);
  }

  table->mark_columns_needed_for_insert();

  uint tot_length=0;
  bool use_blobs= 0, use_vars= 0;
  List_iterator_fast<Item> it(fields_vars);
  Item *item;

  while ((item= it++))
  {
    if (item->type() == Item::FIELD_ITEM)
    {
      Field *field= ((Item_field*)item)->field;
      if (field->flags & BLOB_FLAG)
      {
        use_blobs= 1;
        tot_length+= 256;                       // Will be extended if needed
      }
      else
        tot_length+= field->field_length;
    }
    else
      use_vars= 1;
  }
  if (use_blobs && !ex->line_term->length() && !field_term->length())
  {
    my_message(ER_BLOBS_AND_NO_TERMINATED,ER(ER_BLOBS_AND_NO_TERMINATED),
               MYF(0));
    DBUG_RETURN(TRUE);
  }
  if (use_vars && !field_term->length() && !enclosed->length())
  {
    my_error(ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR, MYF(0));
    DBUG_RETURN(TRUE);
  }

  /* We can't give an error in the middle when using LOCAL files */
  if (read_file_from_client && handle_duplicates == DUP_ERROR)
    ignore= 1;

#ifndef EMBEDDED_LIBRARY
  if (read_file_from_client)
  {
    (void)net_request_file(&thd->net,ex->file_name);
    file = -1;
  }
  else
#endif
  {
#ifdef DONT_ALLOW_FULL_LOAD_DATA_PATHS
    ex->file_name+=dirname_length(ex->file_name);
#endif
    if (!dirname_length(ex->file_name))
    {
      strxnmov(name, FN_REFLEN-1, mysql_real_data_home, tdb, NullS);
      (void) fn_format(name, ex->file_name, name, "",
                       MY_RELATIVE_PATH | MY_UNPACK_FILENAME);
    }
    else
    {
      (void) fn_format(name, ex->file_name, mysql_real_data_home, "",
                       MY_RELATIVE_PATH | MY_UNPACK_FILENAME);
#if !defined(__WIN__) && ! defined(__NETWARE__)
      MY_STAT stat_info;
      if (!my_stat(name,&stat_info,MYF(MY_WME)))
        DBUG_RETURN(TRUE);

      // if we are not in slave thread, the file must be:
      if (!thd->slave_thread &&
          !((stat_info.st_mode & S_IROTH) == S_IROTH &&  // readable by others
            (stat_info.st_mode & S_IFLNK) != S_IFLNK && // and not a symlink
            ((stat_info.st_mode & S_IFREG) == S_IFREG ||
             (stat_info.st_mode & S_IFIFO) == S_IFIFO)))
      {
        my_error(ER_TEXTFILE_NOT_READABLE, MYF(0), name);
        DBUG_RETURN(TRUE);
      }
      if ((stat_info.st_mode & S_IFIFO) == S_IFIFO)
        is_fifo = 1;
#endif
    }
    if ((file=my_open(name,O_RDONLY,MYF(MY_WME))) < 0)
      DBUG_RETURN(TRUE);
  }

  COPY_INFO info;
  bzero((char*) &info,sizeof(info));
  info.ignore= ignore;
  info.handle_duplicates=handle_duplicates;
  info.escape_char=escaped->length() ? (*escaped)[0] : INT_MAX;

  READ_INFO read_info(file,tot_length,thd->variables.collation_database,
                      *field_term,*ex->line_start, *ex->line_term, *enclosed,
                      info.escape_char, read_file_from_client, is_fifo);
  if (read_info.error)
  {
    if  (file >= 0)
      my_close(file,MYF(0));                    // no files in net reading
    DBUG_RETURN(TRUE);                          // Can't allocate buffers
  }

#ifndef EMBEDDED_LIBRARY
  if (mysql_bin_log.is_open())
  {
    lf_info.thd = thd;
    lf_info.wrote_create_file = 0;
    lf_info.last_pos_in_file = HA_POS_ERROR;
    lf_info.log_delayed= transactional_table;
    read_info.set_io_cache_arg((void*) &lf_info);
  }
#endif 
  thd->count_cuted_fields= CHECK_FIELD_WARN;            /* calc cuted fields */
  thd->cuted_fields=0L;
  /* Skip lines if there is a line terminator */
  if (ex->line_term->length())
  {
    /* ex->skip_lines needs to be preserved for logging */
    while (skip_lines > 0)
    {
      skip_lines--;
      if (read_info.next_line())
        break;
    }
  }

  if (!(error=test(read_info.error)))
  {

    table->next_number_field=table->found_next_number_field;
    if (ignore ||
        handle_duplicates == DUP_REPLACE)
      table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
    if (handle_duplicates == DUP_REPLACE &&
        (!table->triggers ||
         !table->triggers->has_delete_triggers()))
        table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
    if (!thd->prelocked_mode)
      table->file->ha_start_bulk_insert((ha_rows) 0);
    table->copy_blobs=1;

    thd->no_trans_update= 0;
    thd->abort_on_warning= (!ignore &&
                            (thd->variables.sql_mode &
                             (MODE_STRICT_TRANS_TABLES |
                              MODE_STRICT_ALL_TABLES)));

    if (!field_term->length() && !enclosed->length())
      error= read_fixed_length(thd, info, table_list, fields_vars,
                               set_fields, set_values, read_info,
                               skip_lines, ignore);
    else
      error= read_sep_field(thd, info, table_list, fields_vars,
                            set_fields, set_values, read_info,
                            *enclosed, skip_lines, ignore);
    if (!thd->prelocked_mode && table->file->ha_end_bulk_insert() && !error)
    {
      table->file->print_error(my_errno, MYF(0));
      error= 1;
    }
    table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
    table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
    table->next_number_field=0;
  }
  ha_enable_transaction(thd, TRUE);
  if (file >= 0)
    my_close(file,MYF(0));
  free_blobs(table);                            /* if pack_blob was used */
  table->copy_blobs=0;
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;

  /*
    We must invalidate the table in query cache before binlog writing and
    ha_autocommit_...
  */
  query_cache_invalidate3(thd, table_list, 0);

  if (error)
  {
    if (transactional_table)
      ha_autocommit_or_rollback(thd,error);

    if (read_file_from_client)
      while (!read_info.next_line())
        ;

#ifndef EMBEDDED_LIBRARY
    if (mysql_bin_log.is_open())
    {
      {
        /*
          Make sure last block (the one which caused the error) gets
          logged.  This is needed because otherwise after write of (to
          the binlog, not to read_info (which is a cache))
          Delete_file_log_event the bad block will remain in read_info
          (because pre_read is not called at the end of the last
          block; remember pre_read is called whenever a new block is
          read from disk).  At the end of mysql_load(), the destructor
          of read_info will call end_io_cache() which will flush
          read_info, so we will finally have this in the binlog:

          Append_block # The last successfull block
          Delete_file
          Append_block # The failing block
          which is nonsense.
          Or could also be (for a small file)
          Create_file  # The failing block
          which is nonsense (Delete_file is not written in this case, because:
          Create_file has not been written, so Delete_file is not written, then
          when read_info is destroyed end_io_cache() is called which writes
          Create_file.
        */
        read_info.end_io_cache();
        /* If the file was not empty, wrote_create_file is true */
        if (lf_info.wrote_create_file)
        {
          if ((info.copied || info.deleted) && !transactional_table)
            write_execute_load_query_log_event(thd, handle_duplicates,
                                               ignore, transactional_table);
          else
          {
            Delete_file_log_event d(thd, db, transactional_table);
            d.flags|= LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F;
            mysql_bin_log.write(&d);
          }
        }
      }
    }
#endif 
    error= -1;                          // Error on read
    goto err;
  }
  sprintf(name, ER(ER_LOAD_INFO), (ulong) info.records, (ulong) info.deleted,
          (ulong) (info.records - info.copied), (ulong) thd->cuted_fields);
  send_ok(thd,info.copied+info.deleted,0L,name);

  if (!transactional_table)
    thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
#ifndef EMBEDDED_LIBRARY
  if (mysql_bin_log.is_open())
  {
#ifdef HAVE_ROW_BASED_REPLICATION
    /*
      We need to do the job that is normally done inside
      binlog_query() here, which is to ensure that the pending event
      is written before tables are unlocked and before any other
      events are written.  We also need to update the table map
      version for the binary log to mark that table maps are invalid
      after this point.
     */
    if (thd->current_stmt_binlog_row_based)
      thd->binlog_flush_pending_rows_event(true);
    else
#endif
    {
      /*
        As already explained above, we need to call end_io_cache() or the last
        block will be logged only after Execute_load_query_log_event (which is
        wrong), when read_info is destroyed.
      */
      read_info.end_io_cache();
      if (lf_info.wrote_create_file)
      {
        write_execute_load_query_log_event(thd, handle_duplicates,
                                           ignore, transactional_table);
      }
    }
  }
#endif 
  if (transactional_table)
    error=ha_autocommit_or_rollback(thd,error);

err:
  table->file->ha_release_auto_increment();
  if (thd->lock)
  {
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
  }
  thd->abort_on_warning= 0;
  DBUG_RETURN(error);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int read_fixed_length	(	THD *	thd,
		COPY_INFO &	info,
		TABLE_LIST *	table_list,
		List< Item > &	fields_vars,
		List< Item > &	set_fields,
		List< Item > &	set_values,
		READ_INFO &	read_info,
		ulong	skip_lines,
		bool	ignore_check_option_errors
	)			[static]

Definition at line 537 of file sql_load.cc.

References st_table::auto_increment_field_not_null, DBUG_ENTER, DBUG_RETURN, ER, ER_WARN_TOO_FEW_RECORDS, ER_WARN_TOO_MANY_RECORDS, READ_INFO::error, Item_field::field, Field::field_length, st_table::file, fill_record_n_invoke_before_triggers(), handler::has_transactions(), id, READ_INFO::line_cuted, READ_INFO::next_line(), st_table::next_number_field, pos(), push_warning_printf(), READ_INFO::read_charset, READ_INFO::read_fixed_length(), restore_record, List_iterator_fast< T >::rewind(), READ_INFO::row_end, READ_INFO::row_start, Field::set_notnull(), Field::store(), st_table_list::table, test, TRG_EVENT_INSERT, st_table::triggers, TRUE, VIEW_CHECK_ERROR, st_table_list::view_check_option(), VIEW_CHECK_SKIP, MYSQL_ERROR::WARN_LEVEL_WARN, and write_record().

Referenced by mysql_load().

{
  List_iterator_fast<Item> it(fields_vars);
  Item_field *sql_field;
  TABLE *table= table_list->table;
  ulonglong id;
  bool no_trans_update;
  DBUG_ENTER("read_fixed_length");

  id= 0;
 
  while (!read_info.read_fixed_length())
  {
    if (thd->killed)
    {
      thd->send_kill_message();
      DBUG_RETURN(1);
    }
    if (skip_lines)
    {
      /*
        We could implement this with a simple seek if:
        - We are not using DATA INFILE LOCAL
        - escape character is  ""
        - line starting prefix is ""
      */
      skip_lines--;
      continue;
    }
    it.rewind();
    byte *pos=read_info.row_start;
#ifdef HAVE_purify
    read_info.row_end[0]=0;
#endif
    no_trans_update= !table->file->has_transactions();

    restore_record(table, s->default_values);
    /*
      There is no variables in fields_vars list in this format so
      this conversion is safe.
    */
    while ((sql_field= (Item_field*) it++))
    {
      Field *field= sql_field->field;                  
      if (field == table->next_number_field)
        table->auto_increment_field_not_null= TRUE;
      /*
        No fields specified in fields_vars list can be null in this format.
        Mark field as not null, we should do this for each row because of
        restore_record...
      */
      field->set_notnull();

      if (pos == read_info.row_end)
      {
        thd->cuted_fields++;                    /* Not enough fields */
        push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
                            ER_WARN_TOO_FEW_RECORDS, 
                            ER(ER_WARN_TOO_FEW_RECORDS), thd->row_count);
      }
      else
      {
        uint length;
        byte save_chr;
        if (field == table->next_number_field)
          table->auto_increment_field_not_null= TRUE;
        if ((length=(uint) (read_info.row_end-pos)) >
            field->field_length)
          length=field->field_length;
        save_chr=pos[length]; pos[length]='\0'; // Safeguard aganst malloc
        field->store((char*) pos,length,read_info.read_charset);
        pos[length]=save_chr;
        if ((pos+=length) > read_info.row_end)
          pos= read_info.row_end;       /* Fills rest with space */
      }
    }
    if (pos != read_info.row_end)
    {
      thd->cuted_fields++;                      /* To long row */
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
                          ER_WARN_TOO_MANY_RECORDS, 
                          ER(ER_WARN_TOO_MANY_RECORDS), thd->row_count); 
    }

    if (thd->killed ||
        fill_record_n_invoke_before_triggers(thd, set_fields, set_values,
                                             ignore_check_option_errors,
                                             table->triggers,
                                             TRG_EVENT_INSERT))
      DBUG_RETURN(1);

    switch (table_list->view_check_option(thd,
                                          ignore_check_option_errors)) {
    case VIEW_CHECK_SKIP:
      read_info.next_line();
      goto continue_loop;
    case VIEW_CHECK_ERROR:
      DBUG_RETURN(-1);
    }

    if (write_record(thd, table, &info))
      DBUG_RETURN(1);
    thd->no_trans_update= no_trans_update;
   
    /*
      We don't need to reset auto-increment field since we are restoring
      its default value at the beginning of each loop iteration.
    */
    if (read_info.next_line())                  // Skip to next line
      break;
    if (read_info.line_cuted)
    {
      thd->cuted_fields++;                      /* To long row */
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
                          ER_WARN_TOO_MANY_RECORDS, 
                          ER(ER_WARN_TOO_MANY_RECORDS), thd->row_count); 
    }
    thd->row_count++;
continue_loop:;
  }
  DBUG_RETURN(test(read_info.error));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int read_sep_field	(	THD *	thd,
		COPY_INFO &	info,
		TABLE_LIST *	table_list,
		List< Item > &	fields_vars,
		List< Item > &	set_fields,
		List< Item > &	set_values,
		READ_INFO &	read_info,
		String &	enclosed,
		ulong	skip_lines,
		bool	ignore_check_option_errors
	)			[static]

Definition at line 666 of file sql_load.cc.

References st_table::auto_increment_field_not_null, DBUG_ENTER, DBUG_RETURN, READ_INFO::enclosed, enclosed, ER, ER_WARN_NULL_TO_NOTNULL, ER_WARN_TOO_FEW_RECORDS, ER_WARN_TOO_MANY_RECORDS, READ_INFO::error, Item::FIELD_ITEM, FIELD_TYPE_TIMESTAMP, st_table::file, fill_record_n_invoke_before_triggers(), READ_INFO::found_null, handler::has_transactions(), List< T >::head(), id, READ_INFO::line_cuted, memcmp(), READ_INFO::next_line(), st_table::next_number_field, pos(), push_warning_printf(), READ_INFO::read_charset, READ_INFO::read_field(), restore_record, List_iterator_fast< T >::rewind(), READ_INFO::row_end, READ_INFO::row_start, Field::set_warning(), STRING_WITH_LEN, st_table_list::table, test, TRG_EVENT_INSERT, st_table::triggers, TRUE, Item::type(), VIEW_CHECK_ERROR, st_table_list::view_check_option(), VIEW_CHECK_SKIP, MYSQL_ERROR::WARN_LEVEL_WARN, and write_record().

Referenced by mysql_load().

{
  List_iterator_fast<Item> it(fields_vars);
  Item *item;
  TABLE *table= table_list->table;
  uint enclosed_length;
  ulonglong id;
  bool no_trans_update;
  DBUG_ENTER("read_sep_field");

  enclosed_length=enclosed.length();
  id= 0;
  no_trans_update= !table->file->has_transactions();

  for (;;it.rewind())
  {
    if (thd->killed)
    {
      thd->send_kill_message();
      DBUG_RETURN(1);
    }

    restore_record(table, s->default_values);

    while ((item= it++))
    {
      uint length;
      byte *pos;

      if (read_info.read_field())
        break;

      /* If this line is to be skipped we don't want to fill field or var */
      if (skip_lines)
        continue;

      pos=read_info.row_start;
      length=(uint) (read_info.row_end-pos);

      if (!read_info.enclosed &&
          (enclosed_length && length == 4 &&
           !memcmp(pos, STRING_WITH_LEN("NULL"))) ||
          (length == 1 && read_info.found_null))
      {
        if (item->type() == Item::FIELD_ITEM)
        {
          Field *field= ((Item_field *)item)->field;
          field->reset();
          field->set_null();
          if (field == table->next_number_field)
            table->auto_increment_field_not_null= TRUE;
          if (!field->maybe_null())
          {
            if (field->type() == FIELD_TYPE_TIMESTAMP)
              ((Field_timestamp*) field)->set_time();
            else if (field != table->next_number_field)
              field->set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                                 ER_WARN_NULL_TO_NOTNULL, 1);
          }
        }
        else
          ((Item_user_var_as_out_param *)item)->set_null_value(
                                                  read_info.read_charset);
        continue;
      }

      if (item->type() == Item::FIELD_ITEM)
      {

        Field *field= ((Item_field *)item)->field;
        field->set_notnull();
        read_info.row_end[0]=0;                 // Safe to change end marker
        if (field == table->next_number_field)
          table->auto_increment_field_not_null= TRUE;
        field->store((char*) pos, length, read_info.read_charset);
      }
      else
        ((Item_user_var_as_out_param *)item)->set_value((char*) pos, length,
                                                read_info.read_charset);
    }
    if (read_info.error)
      break;
    if (skip_lines)
    {
      skip_lines--;
      continue;
    }
    if (item)
    {
      /* Have not read any field, thus input file is simply ended */
      if (item == fields_vars.head())
        break;
      for (; item ; item= it++)
      {
        if (item->type() == Item::FIELD_ITEM)
        {
          /*
            QQ: We probably should not throw warning for each field.
            But how about intention to always have the same number
            of warnings in THD::cuted_fields (and get rid of cuted_fields
            in the end ?)
          */
          thd->cuted_fields++;
          push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                              ER_WARN_TOO_FEW_RECORDS,
                              ER(ER_WARN_TOO_FEW_RECORDS), thd->row_count);
        }
        else
          ((Item_user_var_as_out_param *)item)->set_null_value(
                                                  read_info.read_charset);
      }
    }

    if (thd->killed ||
        fill_record_n_invoke_before_triggers(thd, set_fields, set_values,
                                             ignore_check_option_errors,
                                             table->triggers,
                                             TRG_EVENT_INSERT))
      DBUG_RETURN(1);

    switch (table_list->view_check_option(thd,
                                          ignore_check_option_errors)) {
    case VIEW_CHECK_SKIP:
      read_info.next_line();
      goto continue_loop;
    case VIEW_CHECK_ERROR:
      DBUG_RETUR