Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

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

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

The world's most popular open source database

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

#include "mysql_priv.h"
#include "sp_head.h"
#include "sql_trigger.h"
#include "sql_select.h"
#include "sql_show.h"

Include dependency graph for sql_insert.cc:

Go to the source code of this file.

Classes
class	delayed_row
class	delayed_insert
Defines
#define	my_safe_alloca(size, min_length)   my_alloca(size)
#define	my_safe_afree(ptr, size, min_length)   my_afree(ptr)
Functions
static int	check_null_fields (THD *thd, TABLE *entry)
static TABLE *	delayed_get_table (THD *thd, TABLE_LIST *table_list)
static int	write_delayed (THD *thd, TABLE *table, enum_duplicates dup, LEX_STRING query, bool ignore, bool log_on)
static void	end_delayed_insert (THD *thd)
pthread_handler_t	handle_delayed_insert (void *arg)
static void	unlink_blobs (register TABLE *table)
static bool	check_view_insertability (THD *thd, TABLE_LIST *view)
static int	check_insert_fields (THD *thd, TABLE_LIST *table_list, List< Item > &fields, List< Item > &values, bool check_unique)
static int	check_update_fields (THD *thd, TABLE_LIST *insert_table_list, List< Item > &update_fields)
bool	mysql_insert (THD *thd, TABLE_LIST *table_list, List< Item > &fields, List< List_item > &values_list, List< Item > &update_fields, List< Item > &update_values, enum_duplicates duplic, bool ignore)
static bool	mysql_prepare_insert_check_table (THD *thd, TABLE_LIST *table_list, List< Item > &fields, bool select_insert)
bool	mysql_prepare_insert (THD *thd, TABLE_LIST *table_list, TABLE *table, List< Item > &fields, List_item *values, List< Item > &update_fields, List< Item > &update_values, enum_duplicates duplic, COND **where, bool select_insert)
static int	last_uniq_key (TABLE *table, uint keynr)
int	write_record (THD *thd, TABLE *table, COPY_INFO *info)
int	check_that_all_fields_are_given_values (THD *thd, TABLE *entry, TABLE_LIST *table_list)
delayed_insert *	find_handler (THD *thd, TABLE_LIST *table_list)
void	kill_delayed_threads (void)
static void	free_delayed_insert_blobs (register TABLE *table)
bool	mysql_insert_select_prepare (THD *thd)
static TABLE *	create_table_from_items (THD *thd, HA_CREATE_INFO *create_info, TABLE_LIST *create_table, List< create_field > *extra_fields, List< Key > *keys, List< Item > *items, MYSQL_LOCK **lock, TABLEOP_HOOKS *hooks)
Variables
I_List< delayed_insert >	delayed_threads

---

Define Documentation

#define my_safe_afree	(	ptr,
		size,
		min_length		)	my_afree(ptr)

Definition at line 79 of file sql_insert.cc.

Referenced by write_record().

#define my_safe_alloca	(	size,
		min_length		)	my_alloca(size)

Definition at line 78 of file sql_insert.cc.

Referenced by write_record().

---

Function Documentation

static int check_insert_fields	(	THD *	thd,
		TABLE_LIST *	table_list,
		List< Item > &	fields,
		List< Item > &	values,
		bool	check_unique
	)			[static]

Definition at line 107 of file sql_insert.cc.

References st_table_list::alias, bitmap_is_set(), bitmap_set_all, bitmap_set_bit(), check_grant_all_columns(), check_key_in_view(), st_table_list::check_single_table(), check_view_insertability(), clear_timestamp_auto_bits, st_table_share::db, st_table_list::effective_algorithm, base_list::elements, ER_FIELD_SPECIFIED_TWICE, ER_NON_UPDATABLE_TABLE, ER_VIEW_MULTIUPDATE, ER_VIEW_NO_INSERT_FIELD_LIST, ER_WRONG_VALUE_COUNT_ON_ROW, FALSE, Field::field_index, st_table_share::fields, st_table::grant, grant_option, INSERT_ACL, map, MARK_COLUMNS_WRITE, my_error(), MYF, st_table_list::next_local, st_grant_info::privilege, Name_resolution_context::resolve_in_table_list_only(), Name_resolution_context_state::restore_state(), st_table::s, Name_resolution_context_state::save_state(), SELECT_ACL, Field_iterator_table::set_table(), setup_fields(), LEX_STRING::str, st_table_list::table, st_table_share::table_name, TIMESTAMP_AUTO_SET_ON_INSERT, st_table::timestamp_field, st_table::timestamp_field_type, TRUE, st_table_list::updatable, Item::used_tables(), st_table_list::view, VIEW_ALGORITHM_MERGE, st_table_list::view_db, st_table_list::view_name, st_grant_info::want_privilege, and st_table::write_set.

Referenced by mysql_prepare_insert().

{
  TABLE *table= table_list->table;

  if (!table_list->updatable)
  {
    my_error(ER_NON_UPDATABLE_TABLE, MYF(0), table_list->alias, "INSERT");
    return -1;
  }

  if (fields.elements == 0 && values.elements != 0)
  {
    if (!table)
    {
      my_error(ER_VIEW_NO_INSERT_FIELD_LIST, MYF(0),
               table_list->view_db.str, table_list->view_name.str);
      return -1;
    }
    if (values.elements != table->s->fields)
    {
      my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1L);
      return -1;
    }
#ifndef NO_EMBEDDED_ACCESS_CHECKS
    if (grant_option)
    {
      Field_iterator_table fields;
      fields.set_table(table);
      if (check_grant_all_columns(thd, INSERT_ACL, &table->grant,
                                  table->s->db.str, table->s->table_name.str,
                                  &fields))
        return -1;
    }
#endif
    clear_timestamp_auto_bits(table->timestamp_field_type,
                              TIMESTAMP_AUTO_SET_ON_INSERT);
    /*
      No fields are provided so all fields must be provided in the values.
      Thus we set all bits in the write set.
    */
    bitmap_set_all(table->write_set);
  }
  else
  {                                             // Part field list
    SELECT_LEX *select_lex= &thd->lex->select_lex;
    Name_resolution_context *context= &select_lex->context;
    Name_resolution_context_state ctx_state;
    int res;

    if (fields.elements != values.elements)
    {
      my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1L);
      return -1;
    }

    thd->dup_field= 0;
    select_lex->no_wrap_view_item= TRUE;

    /* Save the state of the current name resolution context. */
    ctx_state.save_state(context, table_list);

    /*
      Perform name resolution only in the first table - 'table_list',
      which is the table that is inserted into.
    */
    table_list->next_local= 0;
    context->resolve_in_table_list_only(table_list);
    res= setup_fields(thd, 0, fields, MARK_COLUMNS_WRITE, 0, 0);

    /* Restore the current context. */
    ctx_state.restore_state(context, table_list);
    thd->lex->select_lex.no_wrap_view_item= FALSE;

    if (res)
      return -1;

    if (table_list->effective_algorithm == VIEW_ALGORITHM_MERGE)
    {
      /* it is join view => we need to find table for update */
      List_iterator_fast<Item> it(fields);
      Item *item;
      TABLE_LIST *tbl= 0;            // reset for call to check_single_table()
      table_map map= 0;

      while ((item= it++))
        map|= item->used_tables();
      if (table_list->check_single_table(&tbl, map, table_list) || tbl == 0)
      {
        my_error(ER_VIEW_MULTIUPDATE, MYF(0),
                 table_list->view_db.str, table_list->view_name.str);
        return -1;
      }
      table_list->table= table= tbl->table;
    }

    if (check_unique && thd->dup_field)
    {
      my_error(ER_FIELD_SPECIFIED_TWICE, MYF(0), thd->dup_field->field_name);
      return -1;
    }
    if (table->timestamp_field) // Don't automaticly set timestamp if used
    {
      if (bitmap_is_set(table->write_set,
                        table->timestamp_field->field_index))
        clear_timestamp_auto_bits(table->timestamp_field_type,
                                  TIMESTAMP_AUTO_SET_ON_INSERT);
      else
      {
        bitmap_set_bit(table->write_set,
                       table->timestamp_field->field_index);
      }
    }
  }
  // For the values we need select_priv
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  table->grant.want_privilege= (SELECT_ACL & ~table->grant.privilege);
#endif

  if (check_key_in_view(thd, table_list) ||
      (table_list->view &&
       check_view_insertability(thd, table_list)))
  {
    my_error(ER_NON_UPDATABLE_TABLE, MYF(0), table_list->alias, "INSERT");
    return -1;
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int check_null_fields	(	THD *	thd,
		TABLE *	entry
	)			[static]

int check_that_all_fields_are_given_values	(	THD *	thd,
		TABLE *	entry,
		TABLE_LIST *	table_list
	)

Definition at line 1271 of file sql_insert.cc.

References bitmap_is_set(), ER, ER_NO_DEFAULT_FOR_FIELD, ER_NO_DEFAULT_FOR_VIEW_FIELD, err, FALSE, st_find_field::field, FIELD_TYPE_ENUM, NO_DEFAULT_VALUE_FLAG, push_warning_printf(), LEX_STRING::str, test, st_table_list::top_table(), st_table_list::view, st_table_list::view_db, st_table_list::view_name, and MYSQL_ERROR::WARN_LEVEL_WARN.

Referenced by mysql_insert(), and mysql_load().

{
  int err= 0;
  MY_BITMAP *write_set= entry->write_set;

  for (Field **field=entry->field ; *field ; field++)
  {
    if (!bitmap_is_set(write_set, (*field)->field_index) &&
        ((*field)->flags & NO_DEFAULT_VALUE_FLAG) &&
        ((*field)->real_type() != FIELD_TYPE_ENUM))
    {
      bool view= FALSE;
      if (table_list)
      {
        table_list= table_list->top_table();
        view= test(table_list->view);
      }
      if (view)
      {
        push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                            ER_NO_DEFAULT_FOR_VIEW_FIELD,
                            ER(ER_NO_DEFAULT_FOR_VIEW_FIELD),
                            table_list->view_db.str,
                            table_list->view_name.str);
      }
      else
      {
        push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                            ER_NO_DEFAULT_FOR_FIELD,
                            ER(ER_NO_DEFAULT_FOR_FIELD),
                            (*field)->field_name);
      }
      err= 1;
    }
  }
  return thd->abort_on_warning ? err : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int check_update_fields	(	THD *	thd,
		TABLE_LIST *	insert_table_list,
		List< Item > &	update_fields
	)			[static]

Definition at line 258 of file sql_insert.cc.

References bitmap_is_set(), bitmap_set_bit(), bitmap_test_and_clear(), clear_timestamp_auto_bits, Field::field_index, MARK_COLUMNS_WRITE, setup_fields(), st_table_list::table, TIMESTAMP_AUTO_SET_ON_UPDATE, st_table::timestamp_field, st_table::timestamp_field_type, and st_table::write_set.

Referenced by mysql_prepare_insert().

{
  TABLE *table= insert_table_list->table;
  my_bool timestamp_mark;

  if (table->timestamp_field)
  {
    /*
      Unmark the timestamp field so that we can check if this is modified
      by update_fields
    */
    timestamp_mark= bitmap_test_and_clear(table->write_set,
                                          table->timestamp_field->field_index);
  }

  /* Check the fields we are going to modify */
  if (setup_fields(thd, 0, update_fields, MARK_COLUMNS_WRITE, 0, 0))
    return -1;

  if (table->timestamp_field)
  {
    /* Don't set timestamp column if this is modified. */
    if (bitmap_is_set(table->write_set,
                      table->timestamp_field->field_index))
      clear_timestamp_auto_bits(table->timestamp_field_type,
                                TIMESTAMP_AUTO_SET_ON_UPDATE);
    if (timestamp_mark)
      bitmap_set_bit(table->write_set,
                     table->timestamp_field->field_index);
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool check_view_insertability	(	THD *	thd,
		TABLE_LIST *	view
	)			[static]

Definition at line 722 of file sql_insert.cc.

References bitmap_buffer_size, bitmap_clear_all, bitmap_fast_test_and_set(), bitmap_init(), st_table_list::contain_auto_increment, DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, FALSE, st_find_field::field, st_table::field, Field::field_index, st_table_list::field_translation, st_table_share::fields, Item::filed_for_view_update(), Item::fix_fields(), Item::fixed, Field_translator::item, MARK_COLUMNS_NONE, Field::NEXT_NUMBER, st_table::s, Field::table, st_table_list::table, TRUE, Field::unireg_check, st_table_list::view, and VOID.

Referenced by check_insert_fields().

{
  uint num= view->view->select_lex.item_list.elements;
  TABLE *table= view->table;
  Field_translator *trans_start= view->field_translation,
                   *trans_end= trans_start + num;
  Field_translator *trans;
  Field **field_ptr= table->field;
  uint used_fields_buff_size= bitmap_buffer_size(table->s->fields);
  uint32 *used_fields_buff= (uint32*)thd->alloc(used_fields_buff_size);
  MY_BITMAP used_fields;
  enum_mark_columns save_mark_used_columns= thd->mark_used_columns;
  DBUG_ENTER("check_key_in_view");

  if (!used_fields_buff)
    DBUG_RETURN(TRUE);  // EOM

  DBUG_ASSERT(view->table != 0 && view->field_translation != 0);

  VOID(bitmap_init(&used_fields, used_fields_buff, table->s->fields, 0));
  bitmap_clear_all(&used_fields);

  view->contain_auto_increment= 0;
  /* 
    we must not set query_id for fields as they're not 
    really used in this context
  */
  thd->mark_used_columns= MARK_COLUMNS_NONE;
  /* check simplicity and prepare unique test of view */
  for (trans= trans_start; trans != trans_end; trans++)
  {
    if (!trans->item->fixed && trans->item->fix_fields(thd, &trans->item))
    {
      thd->mark_used_columns= save_mark_used_columns;
      DBUG_RETURN(TRUE);
    }
    Item_field *field;
    /* simple SELECT list entry (field without expression) */
    if (!(field= trans->item->filed_for_view_update()))
    {
      thd->mark_used_columns= save_mark_used_columns;
      DBUG_RETURN(TRUE);
    }
    if (field->field->unireg_check == Field::NEXT_NUMBER)
      view->contain_auto_increment= 1;
    /* prepare unique test */
    /*
      remove collation (or other transparent for update function) if we have
      it
    */
    trans->item= field;
  }
  thd->mark_used_columns= save_mark_used_columns;
  /* unique test */
  for (trans= trans_start; trans != trans_end; trans++)
  {
    /* Thanks to test above, we know that all columns are of type Item_field */
    Item_field *field= (Item_field *)trans->item;
    /* check fields belong to table in which we are inserting */
    if (field->field->table == table &&
        bitmap_fast_test_and_set(&used_fields, field->field->field_index))
      DBUG_RETURN(TRUE);
  }

  DBUG_RETURN(FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static TABLE* create_table_from_items	(	THD *	thd,
		HA_CREATE_INFO *	create_info,
		TABLE_LIST *	create_table,
		List< create_field > *	extra_fields,
		List< Key > *	keys,
		List< Item > *	items,
		MYSQL_LOCK **	lock,
		TABLEOP_HOOKS *	hooks
	)			[static]

Definition at line 2735 of file sql_insert.cc.

References st_table::alias, st_table_share::blob_ptr_size, create_table(), create_tmp_field(), st_table_share::db_create_options, st_table_share::db_low_byte_first, st_ha_create_information::db_type, DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, base_list::elements, handler::extra(), Item::FIELD_ITEM, st_table::file, create_field::flags, Item::FUNC_ITEM, HA_EXTRA_WRITE_CACHE, HA_LEX_CREATE_TMP_TABLE, hash_delete(), heap_hton, init_tmp_table_share(), keys, lock, LOCK_open, st_reginfo::lock_type, Item::maybe_null, st_table::maybe_null, myisam_hton, mysql_create_table(), mysql_lock_tables(), NOT_NULL_FLAG, st_table::null_row, open_cache, open_table(), st_ha_create_information::options, portable_sizeof_char_ptr, TABLEOP_HOOKS::prelock(), pthread_mutex_lock, pthread_mutex_unlock, List< T >::push_back(), quick_rm_table(), st_table::reginfo, st_table::s, test, st_table::timestamp_field, TL_WRITE, Item::tmp_table_field(), Item::type(), and VOID.

{
  TABLE tmp_table;              // Used during 'create_field()'
  TABLE_SHARE share;
  TABLE *table= 0;
  uint select_field_count= items->elements;
  /* Add selected items to field list */
  List_iterator_fast<Item> it(*items);
  Item *item;
  Field *tmp_field;
  bool not_used;
  DBUG_ENTER("create_table_from_items");

  tmp_table.alias= 0;
  tmp_table.timestamp_field= 0;
  tmp_table.s= &share;
  init_tmp_table_share(&share, "", 0, "", "");

  tmp_table.s->db_create_options=0;
  tmp_table.s->blob_ptr_size= portable_sizeof_char_ptr;
  tmp_table.s->db_low_byte_first= 
        test(create_info->db_type == &myisam_hton ||
             create_info->db_type == &heap_hton);
  tmp_table.null_row=tmp_table.maybe_null=0;

  while ((item=it++))
  {
    create_field *cr_field;
    Field *field, *def_field;
    if (item->type() == Item::FUNC_ITEM)
      field= item->tmp_table_field(&tmp_table);
    else
      field= create_tmp_field(thd, &tmp_table, item, item->type(),
                              (Item ***) 0, &tmp_field, &def_field, 0, 0, 0, 0,
                              0);
    if (!field ||
        !(cr_field=new create_field(field,(item->type() == Item::FIELD_ITEM ?
                                           ((Item_field *)item)->field :
                                           (Field*) 0))))
      DBUG_RETURN(0);
    if (item->maybe_null)
      cr_field->flags &= ~NOT_NULL_FLAG;
    extra_fields->push_back(cr_field);
  }
  /*
    create and lock table

    We don't log the statement, it will be logged later.

    If this is a HEAP table, the automatic DELETE FROM which is written to the
    binlog when a HEAP table is opened for the first time since startup, must
    not be written: 1) it would be wrong (imagine we're in CREATE SELECT: we
    don't want to delete from it) 2) it would be written before the CREATE
    TABLE, which is a wrong order. So we keep binary logging disabled when we
    open_table().
    NOTE: By locking table which we just have created (or for which we just
    have have found that it already exists) separately from other tables used
    by the statement we create potential window for deadlock.
    TODO: create and open should be done atomic !
  */
  {
    tmp_disable_binlog(thd);
    if (!mysql_create_table(thd, create_table->db, create_table->table_name,
                            create_info, *extra_fields, *keys, 0,
                            select_field_count, 0))
    {
      /*
        If we are here in prelocked mode we either create temporary table
        or prelocked mode is caused by the SELECT part of this statement.
      */
      DBUG_ASSERT(!thd->prelocked_mode ||
                  create_info->options & HA_LEX_CREATE_TMP_TABLE ||
                  thd->lex->requires_prelocking());

      /*
        NOTE: We don't want to ignore set of locked tables here if we are
              under explicit LOCK TABLES since it will open gap for deadlock
              too wide (and also is not backward compatible).
      */

      if (! (table= open_table(thd, create_table, thd->mem_root, (bool*) 0,
                               (MYSQL_LOCK_IGNORE_FLUSH |
                                ((thd->prelocked_mode == PRELOCKED) ?
                                 MYSQL_OPEN_IGNORE_LOCKED_TABLES:0)))))
        quick_rm_table(create_info->db_type, create_table->db,
                       table_case_name(create_info, create_table->table_name),
                       0);
    }
    reenable_binlog(thd);
    if (!table)                                   // open failed
      DBUG_RETURN(0);
  }

  /*
    FIXME: What happens if trigger manages to be created while we are
           obtaining this lock ? May be it is sensible just to disable
           trigger execution in this case ? Or will MYSQL_LOCK_IGNORE_FLUSH
           save us from that ?
  */
  table->reginfo.lock_type=TL_WRITE;
  hooks->prelock(&table, 1);                    // Call prelock hooks
  if (! ((*lock)= mysql_lock_tables(thd, &table, 1,
                                    MYSQL_LOCK_IGNORE_FLUSH, &not_used)))
  {
    VOID(pthread_mutex_lock(&LOCK_open));
    hash_delete(&open_cache,(byte*) table);
    VOID(pthread_mutex_unlock(&LOCK_open));
    quick_rm_table(create_info->db_type, create_table->db,
                   table_case_name(create_info, create_table->table_name), 0);
    DBUG_RETURN(0);
  }
  table->file->extra(HA_EXTRA_WRITE_CACHE);
  DBUG_RETURN(table);
}

Here is the call graph for this function:

static TABLE * delayed_get_table	(	THD *	thd,
		TABLE_LIST *	table_list
	)			[static]

Definition at line 1456 of file sql_insert.cc.

References st_table_list::alias, connection_attrib, st_table_list::db, DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, delayed_insert_threads, ER, ER_CANT_CREATE_THREAD, ER_OUT_OF_RESOURCES, ER_OUTOFMEMORY, err, error, find_handler(), delayed_insert::get_local_table(), handle_delayed_insert(), delayed_insert::lock(), LOCK_delayed_create, LOCK_thread_count, delayed_insert::mutex, my_error(), my_message(), my_strdup(), MY_WME, MYF, NULL, pthread_mutex_lock, pthread_mutex_unlock, strlen(), strmov(), st_table_list::table, delayed_insert::table_list, st_table_list::table_name, delayed_insert::thd, thread_count, and delayed_insert::unlock().

Referenced by mysql_insert().

{
  int error;
  delayed_insert *tmp;
  TABLE *table;
  DBUG_ENTER("delayed_get_table");

  /* Must be set in the parser */
  DBUG_ASSERT(table_list->db);

  /* Find the thread which handles this table. */
  if (!(tmp=find_handler(thd,table_list)))
  {
    /*
      No match. Create a new thread to handle the table, but
      no more than max_insert_delayed_threads.
    */
    if (delayed_insert_threads >= thd->variables.max_insert_delayed_threads)
      DBUG_RETURN(0);
    thd->proc_info="Creating delayed handler";
    pthread_mutex_lock(&LOCK_delayed_create);
    /*
      The first search above was done without LOCK_delayed_create.
      Another thread might have created the handler in between. Search again.
    */
    if (! (tmp= find_handler(thd, table_list)))
    {
      if (!(tmp=new delayed_insert()))
      {
        my_error(ER_OUTOFMEMORY,MYF(0),sizeof(delayed_insert));
        goto err1;
      }
      pthread_mutex_lock(&LOCK_thread_count);
      thread_count++;
      pthread_mutex_unlock(&LOCK_thread_count);
      tmp->thd.set_db(table_list->db, strlen(table_list->db));
      tmp->thd.query= my_strdup(table_list->table_name,MYF(MY_WME));
      if (tmp->thd.db == NULL || tmp->thd.query == NULL)
      {
        delete tmp;
        my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
        goto err1;
      }
      tmp->table_list= *table_list;                     // Needed to open table
      tmp->table_list.alias= tmp->table_list.table_name= tmp->thd.query;
      tmp->lock();
      pthread_mutex_lock(&tmp->mutex);
      if ((error=pthread_create(&tmp->thd.real_id,&connection_attrib,
                                handle_delayed_insert,(void*) tmp)))
      {
        DBUG_PRINT("error",
                   ("Can't create thread to handle delayed insert (error %d)",
                    error));
        pthread_mutex_unlock(&tmp->mutex);
        tmp->unlock();
        delete tmp;
        my_error(ER_CANT_CREATE_THREAD, MYF(0), error);
        goto err1;
      }

      /* Wait until table is open */
      thd->proc_info="waiting for handler open";
      while (!tmp->thd.killed && !tmp->table && !thd->killed)
      {
        pthread_cond_wait(&tmp->cond_client,&tmp->mutex);
      }
      pthread_mutex_unlock(&tmp->mutex);
      thd->proc_info="got old table";
      if (tmp->thd.killed)
      {
        if (tmp->thd.is_fatal_error)
        {
          /* Copy error message and abort */
          thd->fatal_error();
          strmov(thd->net.last_error,tmp->thd.net.last_error);
          thd->net.last_errno=tmp->thd.net.last_errno;
        }
        tmp->unlock();
        goto err;
      }
      if (thd->killed)
      {
        tmp->unlock();
        goto err;
      }
    }
    pthread_mutex_unlock(&LOCK_delayed_create);
  }

  pthread_mutex_lock(&tmp->mutex);
  table= tmp->get_local_table(thd);
  pthread_mutex_unlock(&tmp->mutex);
  if (table)
    thd->di=tmp;
  else if (tmp->thd.is_fatal_error)
    thd->fatal_error();
  /* Unlock the delayed insert object after its last access. */
  tmp->unlock();
  DBUG_RETURN((table_list->table=table));

 err1:
  thd->fatal_error();
 err:
  pthread_mutex_unlock(&LOCK_delayed_create);
  DBUG_RETURN(0); // Continue with normal insert
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void end_delayed_insert

(

THD *

thd

)

[static]

Definition at line 1756 of file sql_insert.cc.

References delayed_insert::cond, DBUG_ENTER, DBUG_PRINT, DBUG_VOID_RETURN, delayed_insert::mutex, pthread_mutex_lock, pthread_mutex_unlock, delayed_insert::status, delayed_insert::tables_in_use, and delayed_insert::thd.

Referenced by mysql_insert().

{
  DBUG_ENTER("end_delayed_insert");
  delayed_insert *di=thd->di;
  pthread_mutex_lock(&di->mutex);
  DBUG_PRINT("info",("tables in use: %d",di->tables_in_use));
  if (!--di->tables_in_use || di->thd.killed)
  {                                             // Unlock table
    di->status=1;
    pthread_cond_signal(&di->cond);
  }
  pthread_mutex_unlock(&di->mutex);
  DBUG_VOID_RETURN;
}

Here is the caller graph for this function:

delayed_insert* find_handler	(	THD *	thd,
		TABLE_LIST *	table_list
	)

Definition at line 1436 of file sql_insert.cc.

References st_table_list::db, delayed_threads, delayed_insert::lock(), LOCK_delayed_insert, pthread_mutex_lock, pthread_mutex_unlock, st_table::s, LEX_STRING::str, strcmp(), delayed_insert::table, st_table_share::table_name, st_table_list::table_name, and delayed_insert::thd.

Referenced by delayed_get_table().

{
  thd->proc_info="waiting for delay_list";
  pthread_mutex_lock(&LOCK_delayed_insert);     // Protect master list
  I_List_iterator<delayed_insert> it(delayed_threads);
  delayed_insert *tmp;
  while ((tmp=it++))
  {
    if (!strcmp(tmp->thd.db, table_list->db) &&
        !strcmp(table_list->table_name, tmp->table->s->table_name.str))
    {
      tmp->lock();
      break;
    }
  }
  pthread_mutex_unlock(&LOCK_delayed_insert); // For unlink from list
  return tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void free_delayed_insert_blobs

(

register TABLE *

table

)

[static]

Definition at line 2046 of file sql_insert.cc.

References BLOB_FLAG, MY_ALLOW_ZERO_PTR, my_free, and MYF.

Referenced by delayed_insert::handle_inserts().

{
  for (Field **ptr=table->field ; *ptr ; ptr++)
  {
    if ((*ptr)->flags & BLOB_FLAG)
    {
      char *str;
      ((Field_blob *) (*ptr))->get_ptr(&str);
      my_free(str,MYF(MY_ALLOW_ZERO_PTR));
      ((Field_blob *) (*ptr))->reset();
    }
  }
}

Here is the caller graph for this function:

pthread_handler_t handle_delayed_insert

(

void *

arg

)

Definition at line 1812 of file sql_insert.cc.

References abort_loop, delayed_insert::cond, delayed_insert::cond_client, st_table::copy_blobs, DBUG_ENTER, DBUG_PRINT, delayed_insert::dead, delayed_insert_timeout, delayed_threads, ER, ER_ILLEGAL_HA, ER_OUT_OF_RESOURCES, err, error, ETIME, st_table::file, delayed_insert::group_count, HA_CAN_INSERT_DELAYED, handler::ha_release_auto_increment(), handler::ha_table_flags(), delayed_insert::handle_inserts(), init_thr_lock(), KILL_CONNECTION, lock, delayed_insert::lock_count(), LOCK_delayed_insert, LOCK_thread_count, delayed_insert::mutex, my_error(), my_thread_init(), MYF, mysql_lock_tables(), mysql_unlock_tables(), open_ltable(), pthread_detach_this_thread, pthread_mutex_lock, pthread_mutex_unlock, set_timespec, sigemptyset, delayed_insert::stacked_inserts, delayed_insert::status, strmov(), delayed_insert::table, delayed_insert::table_list, st_table_list::table_name, delayed_insert::tables_in_use, delayed_insert::thd, thread_id, threads, TL_WRITE_DELAYED, ilink::unlink(), and VOID.

Referenced by delayed_get_table().

{
  delayed_insert *di=(delayed_insert*) arg;
  THD *thd= &di->thd;

  pthread_detach_this_thread();
  /* Add thread to THD list so that's it's visible in 'show processlist' */
  pthread_mutex_lock(&LOCK_thread_count);
  thd->thread_id=thread_id++;
  thd->end_time();
  threads.append(thd);
  thd->killed=abort_loop ? THD::KILL_CONNECTION : THD::NOT_KILLED;
  pthread_mutex_unlock(&LOCK_thread_count);

  /*
    Wait until the client runs into pthread_cond_wait(),
    where we free it after the table is opened and di linked in the list.
    If we did not wait here, the client might detect the opened table
    before it is linked to the list. It would release LOCK_delayed_create
    and allow another thread to create another handler for the same table,
    since it does not find one in the list.
  */
  pthread_mutex_lock(&di->mutex);
#if !defined( __WIN__) /* Win32 calls this in pthread_create */
  if (my_thread_init())
  {
    strmov(thd->net.last_error,ER(thd->net.last_errno=ER_OUT_OF_RESOURCES));
    goto end;
  }
#endif

  DBUG_ENTER("handle_delayed_insert");
  thd->thread_stack= (char*) &thd;
  if (init_thr_lock() || thd->store_globals())
  {
    thd->fatal_error();
    strmov(thd->net.last_error,ER(thd->net.last_errno=ER_OUT_OF_RESOURCES));
    goto err;
  }
#if !defined(__WIN__) && !defined(__NETWARE__)
  sigset_t set;
  VOID(sigemptyset(&set));                      // Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
#endif

  /* open table */

  if (!(di->table=open_ltable(thd,&di->table_list,TL_WRITE_DELAYED)))
  {
    thd->fatal_error();                         // Abort waiting inserts
    goto err;
  }
  if (!(di->table->file->ha_table_flags() & HA_CAN_INSERT_DELAYED))
  {
    thd->fatal_error();
    my_error(ER_ILLEGAL_HA, MYF(0), di->table_list.table_name);
    goto err;
  }
  di->table->copy_blobs=1;

  /* One can now use this */
  pthread_mutex_lock(&LOCK_delayed_insert);
  delayed_threads.append(di);
  pthread_mutex_unlock(&LOCK_delayed_insert);

  /* Tell client that the thread is initialized */
  pthread_cond_signal(&di->cond_client);

  /* Now wait until we get an insert or lock to handle */
  /* We will not abort as long as a client thread uses this thread */

  for (;;)
  {
    if (thd->killed == THD::KILL_CONNECTION)
    {
      uint lock_count;
      /*
        Remove this from delay insert list so that no one can request a
        table from this
      */
      pthread_mutex_unlock(&di->mutex);
      pthread_mutex_lock(&LOCK_delayed_insert);
      di->unlink();
      lock_count=di->lock_count();
      pthread_mutex_unlock(&LOCK_delayed_insert);
      pthread_mutex_lock(&di->mutex);
      if (!lock_count && !di->tables_in_use && !di->stacked_inserts)
        break;                                  // Time to die
    }

    if (!di->status && !di->stacked_inserts)
    {
      struct timespec abstime;
      set_timespec(abstime, delayed_insert_timeout);

      /* Information for pthread_kill */
      di->thd.mysys_var->current_mutex= &di->mutex;
      di->thd.mysys_var->current_cond= &di->cond;
      di->thd.proc_info="Waiting for INSERT";

      DBUG_PRINT("info",("Waiting for someone to insert rows"));
      while (!thd->killed)
      {
        int error;
#if defined(HAVE_BROKEN_COND_TIMEDWAIT)
        error=pthread_cond_wait(&di->cond,&di->mutex);
#else
        error=pthread_cond_timedwait(&di->cond,&di->mutex,&abstime);
#ifdef EXTRA_DEBUG
        if (error && error != EINTR && error != ETIMEDOUT)
        {
          fprintf(stderr, "Got error %d from pthread_cond_timedwait\n",error);
          DBUG_PRINT("error",("Got error %d from pthread_cond_timedwait",
                              error));
        }
#endif
#endif
        if (thd->killed || di->status)
          break;
        if (error == ETIMEDOUT || error == ETIME)
        {
          thd->killed= THD::KILL_CONNECTION;
          break;
        }
      }
      /* We can't lock di->mutex and mysys_var->mutex at the same time */
      pthread_mutex_unlock(&di->mutex);
      pthread_mutex_lock(&di->thd.mysys_var->mutex);
      di->thd.mysys_var->current_mutex= 0;
      di->thd.mysys_var->current_cond= 0;
      pthread_mutex_unlock(&di->thd.mysys_var->mutex);
      pthread_mutex_lock(&di->mutex);
    }
    di->thd.proc_info=0;

    if (di->tables_in_use && ! thd->lock)
    {
      bool not_used;
      /*
        Request for new delayed insert.
        Lock the table, but avoid to be blocked by a global read lock.
        If we got here while a global read lock exists, then one or more
        inserts started before the lock was requested. These are allowed
        to complete their work before the server returns control to the
        client which requested the global read lock. The delayed insert
        handler will close the table and finish when the outstanding
        inserts are done.
      */
      if (! (thd->lock= mysql_lock_tables(thd, &di->table, 1,
                                          MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK,
                                          &not_used)))
      {
        /* Fatal error */
        di->dead= 1;
        thd->killed= THD::KILL_CONNECTION;
      }
      pthread_cond_broadcast(&di->cond_client);
    }
    if (di->stacked_inserts)
    {
      if (di->handle_inserts())
      {
        /* Some fatal error */
        di->dead= 1;
        thd->killed= THD::KILL_CONNECTION;
      }
    }
    di->status=0;
    if (!di->stacked_inserts && !di->tables_in_use && thd->lock)
    {
      /*
        No one is doing a insert delayed
        Unlock table so that other threads can use it
      */
      MYSQL_LOCK *lock=thd->lock;
      thd->lock=0;
      pthread_mutex_unlock(&di->mutex);
      di->table->file->ha_release_auto_increment();
      mysql_unlock_tables(thd, lock);
      di->group_count=0;
      pthread_mutex_lock(&di->mutex);
    }
    if (di->tables_in_use)
      pthread_cond_broadcast(&di->cond_client); // If waiting clients
  }

err:
  /*
    mysql_lock_tables() can potentially start a transaction and write
    a table map. In the event of an error, that transaction has to be
    rolled back.  We only need to roll back a potential statement
    transaction, since real transactions are rolled back in
    close_thread_tables().
   */
  ha_rollback_stmt(thd);

end:
  /*
    di should be unlinked from the thread handler list and have no active
    clients
  */

  close_thread_tables(thd);                     // Free the table
  di->table=0;
  di->dead= 1;                                  // If error
  thd->killed= THD::KILL_CONNECTION;            // If error
  pthread_cond_broadcast(&di->cond_client);     // Safety
  pthread_mutex_unlock(&di->mutex);

  pthread_mutex_lock(&LOCK_delayed_create);     // Because of delayed_get_table
  pthread_mutex_lock(&LOCK_delayed_insert);     
  delete di;
  pthread_mutex_unlock(&LOCK_delayed_insert);
  pthread_mutex_unlock(&LOCK_delayed_create);  

  my_thread_end();
  pthread_exit(0);
  DBUG_RETURN(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void kill_delayed_threads

(

void

)

Definition at line 1774 of file sql_insert.cc.

References delayed_threads, KILL_CONNECTION, LOCK_delayed_insert, delayed_insert::mutex, pthread_mutex_lock, pthread_mutex_unlock, delayed_insert::thd, and VOID.

Referenced by close_cached_tables().

{
  VOID(pthread_mutex_lock(&LOCK_delayed_insert)); // For unlink from list

  I_List_iterator<delayed_insert> it(delayed_threads);
  delayed_insert *tmp;
  while ((tmp=it++))
  {
    /* Ensure that the thread doesn't kill itself while we are looking at it */
    pthread_mutex_lock(&tmp->mutex);
    tmp->thd.killed= THD::KILL_CONNECTION;
    if (tmp->thd.mysys_var)
    {
      pthread_mutex_lock(&tmp->thd.mysys_var->mutex);
      if (tmp->thd.mysys_var->current_cond)
      {
        /*
          We need the following test because the main mutex may be locked
          in handle_delayed_insert()
        */
        if (&tmp->mutex != tmp->thd.mysys_var->current_mutex)
          pthread_mutex_lock(tmp->thd.mysys_var->current_mutex);
        pthread_cond_broadcast(tmp->thd.mysys_var->current_cond);
        if (&tmp->mutex != tmp->thd.mysys_var->current_mutex)
          pthread_mutex_unlock(tmp->thd.mysys_var->current_mutex);
      }
      pthread_mutex_unlock(&tmp->thd.mysys_var->mutex);
    }
    pthread_mutex_unlock(&tmp->mutex);
  }
  VOID(pthread_mutex_unlock(&LOCK_delayed_insert)); // For unlink from list
}

Here is the caller graph for this function:

static int last_uniq_key	(	TABLE *	table,
		uint	keynr
	)			[static]

Definition at line 980 of file sql_insert.cc.

References st_key::flags, HA_NOSAME, and st_table::key_info.

Referenced by write_record().

{
  while (++keynr < table->s->keys)
    if (table->key_info[keynr].flags & HA_NOSAME)
      return 0;
  return 1;
}

Here is the caller graph for this function:

bool mysql_insert	(	THD *	thd,
		TABLE_LIST *	table_list,
		List< Item > &	fields,
		List< List_item > &	values_list,
		List< Item > &	update_fields,
		List< Item > &	update_values,
		enum_duplicates	duplic,
		bool	ignore
	)

Definition at line 293 of file sql_insert.cc.

References abort(), CHECK_FIELD_ERROR_FOR_NULL, CHECK_FIELD_IGNORE, CHECK_FIELD_WARN, check_that_all_fields_are_given_values(), st_copy_info::copied, counter, st_table_list::db, DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, st_table_share::default_values, delayed_get_table(), st_copy_info::deleted, st_table_list::derived, DUP_ERROR, DUP_REPLACE, DUP_UPDATE, base_list::elements, end_delayed_insert(), ER, ER_DELAYED_INSERT_TABLE_LOCKED, ER_INSERT_INFO, ER_WRONG_VALUE_COUNT_ON_ROW, error, handler::extra(), FALSE, st_table::field, st_table::file, fill_record_n_invoke_before_triggers(), find_locked_table(), st_table::found_next_number_field, free_underlaid_joins(), ha_autocommit_or_rollback(), 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, handler::ha_release_auto_increment(), handler::ha_start_bulk_insert(), st_copy_info::handle_duplicates, Table_triggers_list::has_delete_triggers(), handler::has_transactions(), id, st_copy_info::ignore, info, MYSQL_LOG::is_open(), st_table_list::lock_type, st_table::mark_columns_needed_for_insert(), MARK_COLUMNS_READ, MODE_STRICT_ALL_TABLES, MODE_STRICT_TRANS_TABLES, my_errno, my_error(), MYF, mysql_bin_log, mysql_prepare_insert(), mysql_unlock_tables(), st_table_list::next_global, st_table_list::next_local, st_table::next_number_field, NULL, open_and_lock_tables(), OPTION_BIN_LOG, OPTION_STATUS_NO_TRANS_UPDATE, OPTION_WARNINGS, st_table_list::prepare_check_option(), st_table_list::prepare_where(), handler::print_error(), st_table::record, st_copy_info::records, Name_resolution_context::resolve_in_table_list_only(), restore_record, Name_resolution_context_state::restore_state(), List_iterator_fast< T >::rewind(), st_table::s, Name_resolution_context_state::save_state(), Name_resolution_context::select_lex, send_ok(), setup_fields(), SPECIAL_NO_NEW_FUNC, SPECIAL_SAFE_MODE, specialflag, SUPER_ACL, st_table_list::table, st_table_list::table_name, TL_WRITE, TL_WRITE_CONCURRENT_INSERT, TL_WRITE_DELAYED, TRG_EVENT_INSERT, st_table::triggers, TRUE, st_table_list::updatable, st_copy_info::update_fields, st_copy_info::update_values, st_copy_info::updated, Field::val_int(), st_copy_info::view, st_table_list::view, VIEW_CHECK_ERROR, st_table_list::view_check_option(), VIEW_CHECK_SKIP, write_delayed(), and write_record().

Referenced by mysql_execute_command().

{
  int error, res;
  /*
    log_on is about delayed inserts only.
    By default, both logs are enabled (this won't cause problems if the server
    runs without --log-update or --log-bin).
  */
  bool log_on= ((thd->options & OPTION_BIN_LOG) ||
                (!(thd->security_ctx->master_access & SUPER_ACL)));
  bool transactional_table, joins_freed= FALSE;
  bool changed;
  uint value_count;
  ulong counter = 1;
  ulonglong id;
  COPY_INFO info;
  TABLE *table= 0;
  List_iterator_fast<List_item> its(values_list);
  List_item *values;
  Name_resolution_context *context;
  Name_resolution_context_state ctx_state;
#ifndef EMBEDDED_LIBRARY
  char *query= thd->query;
#endif
  thr_lock_type lock_type = table_list->lock_type;
  Item *unused_conds= 0;
  DBUG_ENTER("mysql_insert");

  /*
    in safe mode or with skip-new change delayed insert to be regular
    if we are told to replace duplicates, the insert cannot be concurrent
    delayed insert changed to regular in slave thread
   */
#ifdef EMBEDDED_LIBRARY
  if (lock_type == TL_WRITE_DELAYED)
    lock_type=TL_WRITE;
#else
  if ((lock_type == TL_WRITE_DELAYED &&
       ((specialflag & (SPECIAL_NO_NEW_FUNC | SPECIAL_SAFE_MODE)) ||
        thd->slave_thread || !thd->variables.max_insert_delayed_threads)) ||
      (lock_type == TL_WRITE_CONCURRENT_INSERT && duplic == DUP_REPLACE) ||
      (duplic == DUP_UPDATE))
    lock_type=TL_WRITE;
#endif
  table_list->lock_type= lock_type;

#ifndef EMBEDDED_LIBRARY
  if (lock_type == TL_WRITE_DELAYED)
  {
    if (thd->locked_tables)
    {
      DBUG_ASSERT(table_list->db); /* Must be set in the parser */
      if (find_locked_table(thd, table_list->db, table_list->table_name))
      {
        my_error(ER_DELAYED_INSERT_TABLE_LOCKED, MYF(0),
                 table_list->table_name);
        DBUG_RETURN(TRUE);
      }
    }
    if ((table= delayed_get_table(thd,table_list)) && !thd->is_fatal_error)
    {
      /*
        Open tables used for sub-selects or in stored functions, will also
        cache these functions.
      */
      res= open_and_lock_tables(thd, table_list->next_global);
      /*
        First is not processed by open_and_lock_tables() => we need set
        updateability flags "by hands".
      */
      if (!table_list->derived && !table_list->view)
        table_list->updatable= 1;  // usual table
    }
    else
    {
      /* Too many delayed insert threads;  Use a normal insert */
      table_list->lock_type= lock_type= TL_WRITE;
      res= open_and_lock_tables(thd, table_list);
    }
  }
  else
#endif /* EMBEDDED_LIBRARY */
    res= open_and_lock_tables(thd, table_list);
  if (res || thd->is_fatal_error)
    DBUG_RETURN(TRUE);

  thd->proc_info="init";
  thd->used_tables=0;
  values= its++;

  if (mysql_prepare_insert(thd, table_list, table, fields, values,
                           update_fields, update_values, duplic, &unused_conds,
                           FALSE))
    goto abort;

  /* mysql_prepare_insert set table_list->table if it was not set */
  table= table_list->table;

  context= &thd->lex->select_lex.context;
  /* Save the state of the current name resolution context. */
  ctx_state.save_state(context, table_list);

  /*
    Perform name resolution only in the first table - 'table_list',
    which is the table that is inserted into.
  */
  table_list->next_local= 0;
  context->resolve_in_table_list_only(table_list);

  value_count= values->elements;
  while ((values= its++))
  {
    counter++;
    if (values->elements != value_count)
    {
      my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), counter);
      goto abort;
    }
    if (setup_fields(thd, 0, *values, MARK_COLUMNS_READ, 0, 0))
      goto abort;
  }
  its.rewind ();
 
  /* Restore the current context. */
  ctx_state.restore_state(context, table_list);

  /*
    Fill in the given fields and dump it to the table file
  */
  info.records= info.deleted= info.copied= info.updated= 0;
  info.ignore= ignore;
  info.handle_duplicates=duplic;
  info.update_fields= &update_fields;
  info.update_values= &update_values;
  info.view= (table_list->view ? table_list : 0);

  /*
    Count warnings for all inserts.
    For single line insert, generate an error if try to set a NOT NULL field
    to NULL.
  */
  thd->count_cuted_fields= ((values_list.elements == 1 &&
                             !ignore) ?
                            CHECK_FIELD_ERROR_FOR_NULL :
                            CHECK_FIELD_WARN);
  thd->cuted_fields = 0L;
  table->next_number_field=table->found_next_number_field;

  error=0;
  thd->proc_info="update";
  if (duplic != DUP_ERROR || ignore)
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
  if (duplic == DUP_REPLACE &&
      (!table->triggers || !table->triggers->has_delete_triggers()))
    table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
  /*
    let's *try* to start bulk inserts. It won't necessary
    start them as values_list.elements should be greater than
    some - handler dependent - threshold.
    We should not start bulk inserts if this statement uses
    functions or invokes triggers since they may access
    to the same table and therefore should not see its
    inconsistent state created by this optimization.
    So we call start_bulk_insert to perform nesessary checks on
    values_list.elements, and - if nothing else - to initialize
    the code to make the call of end_bulk_insert() below safe.
  */
  if (lock_type != TL_WRITE_DELAYED && !thd->prelocked_mode)
    table->file->ha_start_bulk_insert(values_list.elements);

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

  if ((fields.elements || !value_count) &&
      check_that_all_fields_are_given_values(thd, table, table_list))
  {
    /* thd->net.report_error is now set, which will abort the next loop */
    error= 1;
  }

  table->mark_columns_needed_for_insert();

  if (table_list->prepare_where(thd, 0, TRUE) ||
      table_list->prepare_check_option(thd))
    error= 1;

  while ((values= its++))
  {
    if (fields.elements || !value_count)
    {
      restore_record(table,s->default_values);  // Get empty record
      if (fill_record_n_invoke_before_triggers(thd, fields, *values, 0,
                                               table->triggers,
                                               TRG_EVENT_INSERT))
      {
        if (values_list.elements != 1 && !thd->net.report_error)
        {
          info.records++;
          continue;
        }
        /*
          TODO: set thd->abort_on_warning if values_list.elements == 1
          and check that all items return warning in case of problem with
          storing field.
        */
        error=1;
        break;
      }
    }
    else
    {
      if (thd->used_tables)                     // Column used in values()
        restore_record(table,s->default_values);        // Get empty record
      else
      {
        /*
          Fix delete marker. No need to restore rest of record since it will
          be overwritten by fill_record() anyway (and fill_record() does not
          use default values in this case).
        */
        table->record[0][0]= table->s->default_values[0];
      }
      if (fill_record_n_invoke_before_triggers(thd, table->field, *values, 0,
                                               table->triggers,
                                               TRG_EVENT_INSERT))
      {
        if (values_list.elements != 1 && ! thd->net.report_error)
        {
          info.records++;
          continue;
        }
        error=1;
        break;
      }
    }

    if ((res= table_list->view_check_option(thd,
                                            (values_list.elements == 1 ?
                                             0 :
                                             ignore))) ==
        VIEW_CHECK_SKIP)
      continue;
    else if (res == VIEW_CHECK_ERROR)
    {
      error= 1;
      break;
    }
#ifndef EMBEDDED_LIBRARY
    if (lock_type == TL_WRITE_DELAYED)
    {
      LEX_STRING const st_query = { query, thd->query_length };
      error=write_delayed(thd, table, duplic, st_query, ignore, log_on);
      query=0;
    }
    else
#endif
      error=write_record(thd, table ,&info);
    if (error)
      break;
    thd->row_count++;
  }

  free_underlaid_joins(thd, &thd->lex->select_lex);
  joins_freed= TRUE;
  table->file->ha_release_auto_increment();

  /*
    Now all rows are inserted.  Time to update logs and sends response to
    user
  */
#ifndef EMBEDDED_LIBRARY
  if (lock_type == TL_WRITE_DELAYED)
  {
    if (!error)
    {
      info.copied=values_list.elements;
      end_delayed_insert(thd);
    }
    query_cache_invalidate3(thd, table_list, 1);
  }
  else
#endif
  {
    if (!thd->prelocked_mode && table->file->ha_end_bulk_insert() && !error)
    {
      table->file->print_error(my_errno,MYF(0));
      error=1;
    }
    transactional_table= table->file->has_transactions();

    if ((changed= (info.copied || info.deleted || info.updated)))
    {
      /*
        Invalidate the table in the query cache if something changed.
        For the transactional algorithm to work the invalidation must be
        before binlog writing and ha_autocommit_or_rollback
      */
      query_cache_invalidate3(thd, table_list, 1);
      if (error <= 0 || !transactional_table)
      {
        if (mysql_bin_log.is_open())
        {
          if (error <= 0)
            thd->clear_error();
          if (thd->binlog_query(THD::ROW_QUERY_TYPE,
                                thd->query, thd->query_length,
                                transactional_table, FALSE) &&
              transactional_table)
          {
            error=1;
          }
        }
        if (!transactional_table)
          thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
      }
    }
    if (transactional_table)
      error=ha_autocommit_or_rollback(thd,error);

    if (thd->lock)
    {
      mysql_unlock_tables(thd, thd->lock);
      /*
        Invalidate the table in the query cache if something changed
        after unlocking when changes become fisible.
        TODO: this is workaround. right way will be move invalidating in
        the unlock procedure.
      */
      if (lock_type ==  TL_WRITE_CONCURRENT_INSERT && changed)
      {
        query_cache_invalidate3(thd, table_list, 1);
      }
      thd->lock=0;
    }
  }
  thd->proc_info="end";
  /*
    We'll report to the client this id:
    - if the table contains an autoincrement column and we successfully
    inserted an autogenerated value, the autogenerated value.
    - if the table contains no autoincrement column and LAST_INSERT_ID(X) was
    called, X.
    - if the table contains an autoincrement column, and some rows were
    inserted, the id of the last "inserted" row (if IGNORE, that value may not
    have been really inserted but ignored).
  */
  id= (thd->first_successful_insert_id_in_cur_stmt > 0) ?
    thd->first_successful_insert_id_in_cur_stmt :
    (thd->arg_of_last_insert_id_function ?
     thd->first_successful_insert_id_in_prev_stmt :
     ((table->next_number_field && info.copied) ?
     table->next_number_field->val_int() : 0));
  table->next_number_field=0;
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
  if (duplic != DUP_ERROR || ignore)
    table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
  if (duplic == DUP_REPLACE &&
      (!table->triggers || !table->triggers->has_delete_triggers()))
    table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);

  if (error)
    goto abort;
  if (values_list.elements == 1 && (!(thd->options & OPTION_WARNINGS) ||
                                    !thd->cuted_fields))
  {
    thd->row_count_func= info.copied+info.deleted+info.updated;
    send_ok(thd, (ulong) thd->row_count_func, id);
  }
  else
  {
    char buff[160];
    if (ignore)
      sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
              (lock_type == TL_WRITE_DELAYED) ? (ulong) 0 :
              (ulong) (info.records - info.copied), (ulong) thd->cuted_fields);
    else
      sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
              (ulong) (info.deleted+info.updated), (ulong) thd->cuted_fields);
    thd->row_count_func= info.copied+info.deleted+info.updated;
    ::send_ok(thd, (ulong) thd->row_count_func, id, buff);
  }
  thd->abort_on_warning= 0;
  DBUG_RETURN(FALSE);

abort:
#ifndef EMBEDDED_LIBRARY
  if (lock_type == TL_WRITE_DELAYED)
    end_delayed_insert(thd);
#endif
  if (table != NULL)
    table->file->ha_release_auto_increment();
  if (!joins_freed)
    free_underlaid_joins(thd, &thd->lex->select_lex);
  thd->abort_on_warning= 0;
  DBUG_RETURN(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool mysql_insert_select_prepare

(

THD *

thd

)

Definition at line 2273 of file sql_insert.cc.

References st_table_list::belong_to_view, DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, FALSE, mysql_prepare_insert(), st_table_list::next_leaf, and TRUE.

{
  LEX *lex= thd->lex;
  SELECT_LEX *select_lex= &lex->select_lex;
  TABLE_LIST *first_select_leaf_table;
  DBUG_ENTER("mysql_insert_select_prepare");

  /*
    SELECT_LEX do not belong to INSERT statement, so we can't add WHERE
    clause if table is VIEW
  */
  
  if (mysql_prepare_insert(thd, lex->query_tables,
                           lex->query_tables->table, lex->field_list, 0,
                           lex->update_list, lex->value_list,
                           lex->duplicates,
                           &select_lex->where, TRUE))
    DBUG_RETURN(TRUE);

  /*
    exclude first table from leaf tables list, because it belong to
    INSERT
  */
  DBUG_ASSERT(select_lex->leaf_tables != 0);
  lex->leaf_tables_insert= select_lex->leaf_tables;
  /* skip all leaf tables belonged to view where we are insert */
  for (first_select_leaf_table= select_lex->leaf_tables->next_leaf;
       first_select_leaf_table &&
       first_select_leaf_table->belong_to_view &&
       first_select_leaf_table->belong_to_view ==
       lex->leaf_tables_insert->belong_to_view;
       first_select_leaf_table= first_select_leaf_table->next_leaf)
  {}
  select_lex->leaf_tables= first_select_leaf_table;
  DBUG_RETURN(FALSE);
}

Here is the call graph for this function:

bool mysql_prepare_insert	(	THD *	thd,
		TABLE_LIST *	table_list,
		TABLE *	table,
		List< Item > &	fields,
		List_item *	values,
		List< Item > &	update_fields,
		List< Item > &	update_values,
		enum_duplicates	duplic,
		COND **	where,
		bool	select_insert
	)

Definition at line 870 of file sql_insert.cc.

References check_insert_fields(), check_update_fields(), DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, DUP_REPLACE, DUP_UPDATE, FALSE, Name_resolution_context::first_name_resolution_table, MARK_COLUMNS_READ, mysql_prepare_insert_check_table(), st_table_list::next_local, Name_resolution_context::resolve_in_table_list_only(), Name_resolution_context_state::restore_state(), Name_resolution_context_state::save_next_local, Name_resolution_context_state::save_state(), setup_fields(), Name_resolution_context::table_list, TRUE, unique_table(), update_non_unique_table_error(), and st_table_list::view.

Referenced by mysql_insert(), mysql_insert_select_prepare(), and mysql_test_insert().

{
  SELECT_LEX *select_lex= &thd->lex->select_lex;
  Name_resolution_context *context= &select_lex->context;
  Name_resolution_context_state ctx_state;
  bool insert_into_view= (table_list->view != 0);
  bool res= 0;
  DBUG_ENTER("mysql_prepare_insert");
  DBUG_PRINT("enter", ("table_list 0x%lx, table 0x%lx, view %d",
                       (ulong)table_list, (ulong)table,
                       (int)insert_into_view));

  /*
    For subqueries in VALUES() we should not see the table in which we are
    inserting (for INSERT ... SELECT this is done by changing table_list,
    because INSERT ... SELECT share SELECT_LEX it with SELECT.
  */
  if (!select_insert)
  {
    for (SELECT_LEX_UNIT *un= select_lex->first_inner_unit();
         un;
         un= un->next_unit())
    {
      for (SELECT_LEX *sl= un->first_select();
           sl;
           sl= sl->next_select())
      {
        sl->context.outer_context= 0;
      }
    }
  }

  if (duplic == DUP_UPDATE)
  {
    /* it should be allocated before Item::fix_fields() */
    if (table_list->set_insert_values(thd->mem_root))
      DBUG_RETURN(TRUE);
  }

  if (mysql_prepare_insert_check_table(thd, table_list, fields, select_insert))
    DBUG_RETURN(TRUE);

  /* Save the state of the current name resolution context. */
  ctx_state.save_state(context, table_list);

  /*
    Perform name resolution only in the first table - 'table_list',
    which is the table that is inserted into.
  */
  table_list->next_local= 0;
  context->resolve_in_table_list_only(table_list);

  /* Prepare the fields in the statement. */
  if (values &&
      !(res= check_insert_fields(thd, context->table_list, fields, *values,
                                 !insert_into_view) ||
        setup_fields(thd, 0, *values, MARK_COLUMNS_READ, 0, 0)) &&
      duplic == DUP_UPDATE)
  {
    select_lex->no_wrap_view_item= TRUE;
    res= check_update_fields(thd, context->table_list, update_fields);
    select_lex->no_wrap_view_item= FALSE;
    /*
      When we are not using GROUP BY we can refer to other tables in the
      ON DUPLICATE KEY part.
    */       
    if (select_lex->group_list.elements == 0)
    {
      context->table_list->next_local=       ctx_state.save_next_local;
      /* first_name_resolution_table was set by resolve_in_table_list_only() */
      context->first_name_resolution_table->
        next_name_resolution_table=          ctx_state.save_next_local;
    }
    if (!res)
      res= setup_fields(thd, 0, update_values, MARK_COLUMNS_READ, 0, 0);
  }

  /* Restore the current context. */
  ctx_state.restore_state(context, table_list);

  if (res)
    DBUG_RETURN(res);

  if (!table)
    table= table_list->table;

  if (!select_insert)
  {
    Item *fake_conds= 0;
    TABLE_LIST *duplicate;
    if ((duplicate= unique_table(thd, table_list, table_list->next_global)))
    {
      update_non_unique_table_error(table_list, "INSERT", duplicate);
      DBUG_RETURN(TRUE);
    }
    select_lex->fix_prepare_information(thd, &fake_conds);
    select_lex->first_execution= 0;
  }
  if (duplic == DUP_UPDATE || duplic == DUP_REPLACE)
    table->prepare_for_position();
  DBUG_RETURN(FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool mysql_prepare_insert_check_table	(	THD *	thd,
		TABLE_LIST *	table_list,
		List< Item > &	fields,
		bool	select_insert
	)			[static]

Definition at line 806 of file sql_insert.cc.

References DBUG_ENTER, DBUG_RETURN, base_list::elements, ER_VIEW_NO_INSERT_FIELD_LIST, FALSE, insert_view_fields(), my_error(), MYF, SELECT_ACL, st_table_list::select_lex, setup_tables_and_check_access(), LEX_STRING::str, st_table_list::table, TRUE, st_table_list::view, st_table_list::view_db, and st_table_list::view_name.

Referenced by mysql_prepare_insert().

{
  bool insert_into_view= (table_list->view != 0);
  DBUG_ENTER("mysql_prepare_insert_check_table");

  /*
     first table in list is the one we'll INSERT into, requires INSERT_ACL.
     all others require SELECT_ACL only. the ACL requirement below is for
     new leaves only anyway (view-constituents), so check for SELECT rather
     than INSERT.
  */

  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,
                                    select_insert, SELECT_ACL))
    DBUG_RETURN(TRUE);

  if (insert_into_view && !fields.elements)
  {
    thd->lex->empty_field_list_on_rset= 1;
    if (!table_list->table)
    {
      my_error(ER_VIEW_NO_INSERT_FIELD_LIST, MYF(0),
               table_list->view_db.str, table_list->view_name.str);
      DBUG_RETURN(TRUE);
    }
    DBUG_RETURN(insert_view_fields(thd, &fields, table_list));
  }

  DBUG_RETURN(FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void unlink_blobs

(

register TABLE *

table

)

[static]

Definition at line 2035 of file sql_insert.cc.

References BLOB_FLAG.

Referenced by write_delayed().

{
  for (Field **ptr=table->field ; *ptr ; ptr++)
  {
    if ((*ptr)->flags & BLOB_FLAG)
      ((Field_blob *) (*ptr))->clear_temporary();
  }
}

Here is the caller graph for this function:

static int write_delayed	(	THD *	thd,
		TABLE *	table,
		enum_duplicates	dup,
		LEX_STRING	query,
		bool	ignore,
		bool	log_on
	)			[static]

Definition at line 1684 of file sql_insert.cc.

References st_table_share::blob_fields, delayed_insert::cond, delayed_insert::cond_client, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, delayed_queue_size, delayed_rows_in_use, err, delayed_row::first_successful_insert_id_in_prev_stmt, LOCK_delayed_status, memcpy, delayed_insert::mutex, my_free, my_malloc(), my_strndup(), MY_WME, MYF, NULL, pthread_mutex_lock, pthread_mutex_unlock, I_List< T >::push_back(), query, delayed_row::query_start_used, st_table_share::reclength, st_table::record, delayed_row::record, delayed_insert::rows, st_table::s, delayed_insert::stacked_inserts, delayed_row::start_time, delayed_insert::status, delayed_row::stmt_depends_on_first_successful_insert_id_in_prev_stmt, thread_safe_increment, st_table::timestamp_field_type, delayed_row::timestamp_field_type, and unlink_blobs().

Referenced by mysql_insert().

{
  delayed_row *row;
  delayed_insert *di=thd->di;
  DBUG_ENTER("write_delayed");
  DBUG_PRINT("enter", ("query = '%s' length %u", query.str, query.length));

  thd->proc_info="waiting for handler insert";
  pthread_mutex_lock(&di->mutex);
  while (di->stacked_inserts >= delayed_queue_size && !thd->killed)
    pthread_cond_wait(&di->cond_client,&di->mutex);
  thd->proc_info="storing row into queue";

  if (thd->killed)
    goto err;

  /*
    Take a copy of the query string, if there is any. The string will
    be free'ed when the row is destroyed. If there is no query string,
    we don't do anything special.
   */

  if (query.str)
  {
    char *str;
    if (!(str= my_strndup(query.str, query.length, MYF(MY_WME))))
      goto err;
    query.str= str;
  }
  row= new delayed_row(query, duplic, ignore, log_on);
  if (row == NULL)
  {
    my_free(query.str, MYF(MY_WME));
    goto err;
  }

  if (!(row->record= (char*) my_malloc(table->s->reclength, MYF(MY_WME))))
    goto err;
  memcpy(row->record, table->record[0], table->s->reclength);
  row->start_time=              thd->start_time;
  row->query_start_used=        thd->query_start_used;
  /*
    those are for the binlog: LAST_INSERT_ID() has been evaluated at this
    time, so record does not need it, but statement-based binlogging of the
    INSERT will need when the row is actually inserted.
    As for SET INSERT_ID, DELAYED does not honour it (BUG#20830).
  */
  row->stmt_depends_on_first_successful_insert_id_in_prev_stmt=
    thd->stmt_depends_on_first_successful_insert_id_in_prev_stmt;
  row->first_successful_insert_id_in_prev_stmt=
    thd->first_successful_insert_id_in_prev_stmt;
  row->timestamp_field_type=    table->timestamp_field_type;

  di->rows.push_back(row);
  di->stacked_inserts++;
  di->status=1;
  if (table->s->blob_fields)
    unlink_blobs(table);
  pthread_cond_signal(&di->cond);

  thread_safe_increment(delayed_rows_in_use,&LOCK_delayed_status);
  pthread_mutex_unlock(&di->mutex);
  DBUG_RETURN(0);

 err:
  delete row;
  pthread_mutex_unlock(&di->mutex);
  DBUG_RETURN(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int write_record	(	THD *	thd,
		TABLE *	table,
		COPY_INFO *	info
	)

Definition at line 1016 of file sql_insert.cc.

References handler::adjust_next_insert_id_after_explicit_value(), st_table::column_bitmaps_set(), st_copy_info::copied, current_thd, DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, st_copy_info::deleted, handler::dup_ref, DUP_REPLACE, DUP_UPDATE, base_list::elements, err, error, handler::extra(), st_table::file, fill_record_n_invoke_before_triggers(), handler::get_dup_key(), HA_CHECK_DUP, HA_CHECK_DUP_KEY, handler::ha_delete_row(), HA_DUPLICATE_POS, HA_ERR_FOUND_DUPP_KEY, HA_EXTRA_FLUSH_CACHE, HA_READ_KEY_EXACT, handler::ha_table_flags(), handler::ha_update_row(), handler::ha_write_row(), st_copy_info::handle_duplicates, Table_triggers_list::has_delete_triggers(), handler::has_transactions(), st_copy_info::ignore, handler::index_read_idx(), handler::insert_id_for_cur_row, st_table::insert_values, handler::is_fatal_error(), key, key_copy(), st_table::key_info, key_length, st_copy_info::last_errno, last_uniq_key(), MAX_KEY_LENGTH, st_table_share::max_unique_length, my_errno, my_safe_afree, my_safe_alloca, MYF, handler::next_insert_id, st_table::next_number_field, st_table_share::next_number_index, NULL, prev_insert_id(), handler::print_error(), Table_triggers_list::process_triggers(), st_table::read_set, st_table::record, st_copy_info::records, handler::referenced_by_foreign_key(), handler::restore_auto_increment(), restore_record, handler::rnd_pos(), st_table::s, store_record, TIMESTAMP_AUTO_SET_ON_BOTH, st_table::timestamp_field_type, TIMESTAMP_NO_AUTO_SET, TRG_ACTION_AFTER, TRG_ACTION_BEFORE, TRG_EVENT_DELETE, TRG_EVENT_INSERT, TRG_EVENT_UPDATE, st_table::triggers, TRUE, st_copy_info::update_fields, st_copy_info::update_values, st_copy_info::updated, st_table::use_all_columns(), Field::val_int(), st_copy_info::view, VIEW_CHECK_ERROR, st_table_list::view_check_option(), VIEW_CHECK_SKIP, and st_table::write_set.

Referenced by delayed_insert::handle_inserts(), mysql_insert(), read_fixed_length(), and read_sep_field().

{
  int error, trg_error= 0;
  char *key=0;
  MY_BITMAP *save_read_set, *save_write_set;
  ulonglong prev_insert_id= table->file->next_insert_id;
  ulonglong insert_id_for_cur_row= 0;
  DBUG_ENTER("write_record");

  info->records++;
  save_read_set=  table->read_set;
  save_write_set= table->write_set;

  if (info->handle_duplicates == DUP_REPLACE ||
      info->handle_duplicates == DUP_UPDATE)
  {
    while ((error=table->file->ha_write_row(table->record[0])))
    {
      uint key_nr;
      /*
        If we do more than one iteration of this loop, from the second one the
        row will have an explicit value in the autoinc field, which was set at
        the first call of handler::update_auto_increment(). So we must save
        the autogenerated value to avoid thd->insert_id_for_cur_row to become
        0.
      */
      if (table->file->insert_id_for_cur_row > 0)
        insert_id_for_cur_row= table->file->insert_id_for_cur_row;
      else
        table->file->insert_id_for_cur_row= insert_id_for_cur_row;
      bool is_duplicate_key_error;
      if (table->file->is_fatal_error(error, HA_CHECK_DUP))
        goto err;
      is_duplicate_key_error= table->file->is_fatal_error(error, 0);
      if (!is_duplicate_key_error)
      {
        /*
          We come here when we had an ignorable error which is not a duplicate
          key error. In this we ignore error if ignore flag is set, otherwise
          report error as usual. We will not do any duplicate key processing.
        */
        if (info->ignore)
          goto ok_or_after_trg_err; /* Ignoring a not fatal error, return 0 */
        goto err;
      }
      if ((int) (key_nr = table->file->get_dup_key(error)) < 0)
      {
        error= HA_ERR_FOUND_DUPP_KEY;         /* Database can't find key */
        goto err;
      }
      /* Read all columns for the row we are going to replace */
      table->use_all_columns();
      /*
        Don't allow REPLACE to replace a row when a auto_increment column
        was used.  This ensures that we don't get a problem when the
        whole range of the key has been used.
      */
      if (info->handle_duplicates == DUP_REPLACE &&
          table->next_number_field &&
          key_nr == table->s->next_number_index &&
          (insert_id_for_cur_row > 0))
        goto err;
      if (table->file->ha_table_flags() & HA_DUPLICATE_POS)
      {
        if (table->file->rnd_pos(table->record[1],table->file->dup_ref))
          goto err;
      }
      else
      {
        if (table->file->extra(HA_EXTRA_FLUSH_CACHE)) /* Not needed with NISAM */
        {
          error=my_errno;
          goto err;
        }

        if (!key)
        {
          if (!(key=(char*) my_safe_alloca(table->s->max_unique_length,
                                           MAX_KEY_LENGTH)))
          {
            error=ENOMEM;
            goto err;
          }
        }
        key_copy((byte*) key,table->record[0],table->key_info+key_nr,0);
        if ((error=(table->file->index_read_idx(table->record[1],key_nr,
                                                (byte*) key,
                                                table->key_info[key_nr].
                                                key_length,
                                                HA_READ_KEY_EXACT))))
          goto err;
      }
      if (info->handle_duplicates == DUP_UPDATE)
      {
        int res= 0;
        /*
          We don't check for other UNIQUE keys - the first row
          that matches, is updated. If update causes a conflict again,
          an error is returned
        */
        DBUG_ASSERT(table->insert_values != NULL);
        store_record(table,insert_values);
        restore_record(table,record[1]);
        DBUG_ASSERT(info->update_fields->elements ==
                    info->update_values->elements);
        if (fill_record_n_invoke_before_triggers(thd, *info->update_fields,
                                                 *info->update_values, 0,
                                                 table->triggers,
                                                 TRG_EVENT_UPDATE))
          goto before_trg_err;

        /* CHECK OPTION for VIEW ... ON DUPLICATE KEY UPDATE ... */
        if (info->view &&
            (res= info->view->view_check_option(current_thd, info->ignore)) ==
            VIEW_CHECK_SKIP)
          goto ok_or_after_trg_err;
        if (res == VIEW_CHECK_ERROR)
          goto before_trg_err;

        if ((error=table->file->ha_update_row(table->record[1],
                                              table->record[0])))
        {
          if (info->ignore &&
              !table->file->is_fatal_error(error, HA_CHECK_DUP_KEY))
          {
            table->file->restore_auto_increment(prev_insert_id);
            goto ok_or_after_trg_err;
          }
          goto err;
        }
        info->updated++;
        /*
          If ON DUP KEY UPDATE updates a row instead of inserting one, and
          there is an auto_increment column, then SELECT LAST_INSERT_ID()
          returns the id of the updated row:
        */
        if (table->next_number_field)
        {
          longlong field_val= table->next_number_field->val_int();
          thd->record_first_successful_insert_id_in_cur_stmt(field_val);
          table->file->adjust_next_insert_id_after_explicit_value(field_val);
        }
        trg_error= (table->triggers &&
                    table->triggers->process_triggers(thd, TRG_EVENT_UPDATE,
                                                      TRG_ACTION_AFTER, TRUE));
        info->copied++;
        goto ok_or_after_trg_err;
      }
      else /* DUP_REPLACE */
      {
        /*
          The manual defines the REPLACE semantics that it is either
          an INSERT or DELETE(s) + INSERT; FOREIGN KEY checks in
          InnoDB do not function in the defined way if we allow MySQL
          to convert the latter operation internally to an UPDATE.
          We also should not perform this conversion if we have 
          timestamp field with ON UPDATE which is different from DEFAULT.
          Another case when conversion should not be performed is when
          we have ON DELETE trigger on table so user may notice that
          we cheat here. Note that it is ok to do such conversion for
          tables which have ON UPDATE but have no ON DELETE triggers,
          we just should not expose this fact to users by invoking
          ON UPDATE triggers.
        */
        if (last_uniq_key(table,key_nr) &&
            !table->file->referenced_by_foreign_key() &&
            (table->timestamp_field_type == TIMESTAMP_NO_AUTO_SET ||
             table->timestamp_field_type == TIMESTAMP_AUTO_SET_ON_BOTH) &&
            (!table->triggers || !table->triggers->has_delete_triggers()))
        {
          if ((error=table->file->ha_update_row(table->record[1],
                                                table->record[0])))
            goto err;
          info->deleted++;
          thd->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
          /*
            Since we pretend that we have done insert we should call
            its after triggers.
          */
          goto after_trg_n_copied_inc;
        }
        else
        {
          if (table->triggers &&
              table->triggers->process_triggers(thd, TRG_EVENT_DELETE,
                                                TRG_ACTION_BEFORE, TRUE))
            goto before_trg_err;
          if ((error=table->file->ha_delete_row(table->record[1])))
            goto err;
          info->deleted++;
          if (!table->file->has_transactions())
            thd->no_trans_update= 1;
          if (table->triggers &&
              table->triggers->process_triggers(thd, TRG_EVENT_DELETE,
                                                TRG_ACTION_AFTER, TRUE))
          {
            trg_error= 1;
            goto ok_or_after_trg_err;
          }
          /* Let us attempt do write_row() once more */
        }
      }
    }
    thd->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
    /*
      Restore column maps if they where replaced during an duplicate key
      problem.
    */
    if (table->read_set != save_read_set ||
        table->write_set != save_write_set)
      table->column_bitmaps_set(save_read_set, save_write_set);
  }
  else if ((error=table->file->ha_write_row(table->record[0])))
  {
    if (!info->ignore ||
        table->file->is_fatal_error(error, HA_CHECK_DUP))
      goto err;
    table->file->restore_auto_increment(prev_insert_id);
    goto ok_or_after_trg_err;
  }

after_trg_n_copied_inc:
  info->copied++;
  thd->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
  trg_error= (table->triggers &&
              table->triggers->process_triggers(thd, TRG_EVENT_INSERT,
                                                TRG_ACTION_AFTER, TRUE));

ok_or_after_trg_err:
  if (key)
    my_safe_afree(key,table->s->max_unique_length,MAX_KEY_LENGTH);
  if (!table->file->has_transactions())
    thd->no_trans_update= 1;
  DBUG_RETURN(trg_error);

err:
  info->last_errno= error;
  /* current_select is NULL if this is a delayed insert */
  if (thd->lex->current_select)
    thd->lex->current_select->no_error= 0;        // Give error
  table->file->print_error(error,MYF(0));

before_trg_err:
  table->file->restore_auto_increment(prev_insert_id);
  if (key)
    my_safe_afree(key, table->s->max_unique_length, MAX_KEY_LENGTH);
  table->column_bitmaps_set(save_read_set, save_write_set);
  DBUG_RETURN(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

I_List<delayed_insert> delayed_threads

Definition at line 1433 of file sql_insert.cc.

Referenced by find_handler(), handle_delayed_insert(), and kill_delayed_threads().

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About
• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.