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

 

 

 

• Get Started with MySQL
• Development with MySQL
• PHP
• Perl
• Python
• Ruby
• Java/JDBC
• C#/.NET

The world's most popular open source database

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

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

Include dependency graph for sql_update.cc:

Go to the source code of this file.

Functions
static bool	safe_update_on_fly (JOIN_TAB *join_tab, List< Item > *fields)
static bool	compare_record (TABLE *table)
static bool	check_fields (THD *thd, List< Item > &items)
int	mysql_update (THD *thd, TABLE_LIST *table_list, List< Item > &fields, List< Item > &values, COND *conds, uint order_num, ORDER *order, ha_rows limit, enum enum_duplicates handle_duplicates, bool ignore)
bool	mysql_prepare_update (THD *thd, TABLE_LIST *table_list, Item **conds, uint order_num, ORDER *order)
static table_map	get_table_map (List< Item > *items)
bool	mysql_multi_update_prepare (THD *thd)
bool	mysql_multi_update (THD *thd, TABLE_LIST *table_list, List< Item > *fields, List< Item > *values, COND *conds, ulonglong options, enum enum_duplicates handle_duplicates, bool ignore, SELECT_LEX_UNIT *unit, SELECT_LEX *select_lex)

---

Function Documentation

static bool check_fields	(	THD *	thd,
		List< Item > &	items
	)			[static]

Definition at line 65 of file sql_update.cc.

References ER_NONUPDATEABLE_COLUMN, FALSE, Item::filed_for_view_update(), my_error(), MYF, Item::name, List_iterator< T >::ref(), and TRUE.

{
  List_iterator<Item> it(items);
  Item *item;
  Item_field *field;
  Name_resolution_context *context= &thd->lex->select_lex.context;

  while ((item= it++))
  {
    if (!(field= item->filed_for_view_update()))
    {
      /* item has name, because it comes from VIEW SELECT list */
      my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), item->name);
      return TRUE;
    }
    /*
      we make temporary copy of Item_field, to avoid influence of changing
      result_field on Item_ref which refer on this field
    */
    thd->change_item_tree(it.ref(), new Item_field(thd, field));
  }
  return FALSE;
}

Here is the call graph for this function:

static bool compare_record

(

TABLE *

table

)

[static]

Definition at line 32 of file sql_update.cc.

References bitmap_is_set(), st_table_share::blob_fields, cmp_record, FALSE, st_table::field, memcmp(), st_table_share::null_bytes, st_table::null_flags, st_table_share::rec_buff_length, st_table::s, TRUE, st_table_share::varchar_fields, and st_table::write_set.

{
  if (table->s->blob_fields + table->s->varchar_fields == 0)
    return cmp_record(table,record[1]);
  /* Compare null bits */
  if (memcmp(table->null_flags,
             table->null_flags+table->s->rec_buff_length,
             table->s->null_bytes))
    return TRUE;                                // Diff in NULL value
  /* Compare updated fields */
  for (Field **ptr= table->field ; *ptr ; ptr++)
  {
    if (bitmap_is_set(table->write_set, (*ptr)->field_index) &&
        (*ptr)->cmp_binary_offset(table->s->rec_buff_length))
      return TRUE;
  }
  return FALSE;
}

Here is the call graph for this function:

static table_map get_table_map

(

List< Item > *

items

)

[static]

Definition at line 780 of file sql_update.cc.

References DBUG_PRINT, map, and Item_field::used_tables().

{
  List_iterator_fast<Item> item_it(*items);
  Item_field *item;
  table_map map= 0;

  while ((item= (Item_field *) item_it++)) 
    map|= item->used_tables();
  DBUG_PRINT("info",("table_map: 0x%08x", map));
  return map;
}

Here is the call graph for this function:

bool mysql_multi_update	(	THD *	thd,
		TABLE_LIST *	table_list,
		List< Item > *	fields,
		List< Item > *	values,
		COND *	conds,
		ulonglong	options,
		enum enum_duplicates	handle_duplicates,
		bool	ignore,
		SELECT_LEX_UNIT *	unit,
		SELECT_LEX *	select_lex
	)

Definition at line 1011 of file sql_update.cc.

References DBUG_ENTER, DBUG_RETURN, FALSE, MODE_STRICT_ALL_TABLES, MODE_STRICT_TRANS_TABLES, mysql_select(), NULL, OPTION_SETUP_TABLES_DONE, st_table_list::select_lex, SELECT_NO_JOIN_CACHE, SELECT_NO_UNLOCK, test, and TRUE.

Referenced by mysql_execute_command().

{
  multi_update *result;
  DBUG_ENTER("mysql_multi_update");

  if (!(result= new multi_update(table_list,
                                 thd->lex->select_lex.leaf_tables,
                                 fields, values,
                                 handle_duplicates, ignore)))
    DBUG_RETURN(TRUE);

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

  List<Item> total_list;
  (void) mysql_select(thd, &select_lex->ref_pointer_array,
                      table_list, select_lex->with_wild,
                      total_list,
                      conds, 0, (ORDER *) NULL, (ORDER *)NULL, (Item *) NULL,
                      (ORDER *)NULL,
                      options | SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK |
                      OPTION_SETUP_TABLES_DONE,
                      result, unit, select_lex);
  delete result;
  thd->abort_on_warning= 0;
  DBUG_RETURN(FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool mysql_multi_update_prepare

(

THD *

thd

)

Definition at line 805 of file sql_update.cc.

References DBUG_ENTER, DBUG_RETURN, FALSE, MARK_COLUMNS_WRITE, mysql_derived_prepare(), mysql_handle_derived(), st_table_list::next_local, open_tables(), reopen_tables(), st_table_list::select_lex, setup_tables_and_check_access(), SQLCOM_UPDATE_MULTI, TRUE, UPDATE_ACL, and st_table_list::view.

{
  LEX *lex= thd->lex;
  TABLE_LIST *table_list= lex->query_tables;
  TABLE_LIST *tl, *leaves;
  List<Item> *fields= &lex->select_lex.item_list;
  table_map tables_for_update;
  bool update_view= 0;
  /*
    if this multi-update was converted from usual update, here is table
    counter else junk will be assigned here, but then replaced with real
    count in open_tables()
  */
  uint  table_count= lex->table_count;
  const bool using_lock_tables= thd->locked_tables != 0;
  bool original_multiupdate= (thd->lex->sql_command == SQLCOM_UPDATE_MULTI);
  bool need_reopen= FALSE;
  DBUG_ENTER("mysql_multi_update_prepare");

  /* following need for prepared statements, to run next time multi-update */
  thd->lex->sql_command= SQLCOM_UPDATE_MULTI;

reopen_tables:

  /* open tables and create derived ones, but do not lock and fill them */
  if (((original_multiupdate || need_reopen) &&
       open_tables(thd, &table_list, &table_count, 0)) ||
      mysql_handle_derived(lex, &mysql_derived_prepare))
    DBUG_RETURN(TRUE);
  /*
    setup_tables() need for VIEWs. JOIN::prepare() will call setup_tables()
    second time, but this call will do nothing (there are check for second
    call in setup_tables()).
  */

  if (setup_tables_and_check_access(thd, &lex->select_lex.context,
                                    &lex->select_lex.top_join_list,
                                    table_list,
                                    &lex->select_lex.leaf_tables, FALSE,
                                    UPDATE_ACL))
    DBUG_RETURN(TRUE);

  if (setup_fields_with_no_wrap(thd, 0, *fields, MARK_COLUMNS_WRITE, 0, 0))
    DBUG_RETURN(TRUE);

  for (tl= table_list; tl ; tl= tl->next_local)
  {
    if (tl->view)
    {
      update_view= 1;
      break;
    }
  }

  if (update_view && check_fields(thd, *fields))
  {
    DBUG_RETURN(TRUE);
  }

  tables_for_update= get_table_map(fields);

  /*
    Setup timestamp handling and locking mode
  */
  leaves= lex->select_lex.leaf_tables;
  for (tl= leaves; tl; tl= tl->next_leaf)
  {
    TABLE *table= tl->table;
    /* Only set timestamp column if this is not modified */
    if (table->timestamp_field &&
        bitmap_is_set(table->write_set,
                      table->timestamp_field->field_index))
      table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;

    /* if table will be updated then check that it is unique */
    if (table->map & tables_for_update)
    {
      if (!tl->updatable || check_key_in_view(thd, tl))
      {
        my_error(ER_NON_UPDATABLE_TABLE, MYF(0), tl->alias, "UPDATE");
        DBUG_RETURN(TRUE);
      }

      table->mark_columns_needed_for_update();
      DBUG_PRINT("info",("setting table `%s` for update", tl->alias));
      /*
        If table will be updated we should not downgrade lock for it and
        leave it as is.
      */
    }
    else
    {
      DBUG_PRINT("info",("setting table `%s` for read-only", tl->alias));
      /*
        If we are using the binary log, we need TL_READ_NO_INSERT to get
        correct order of statements. Otherwise, we use a TL_READ lock to
        improve performance.
      */
      tl->lock_type= using_update_log ? TL_READ_NO_INSERT : TL_READ;
      tl->updating= 0;
      /* Update TABLE::lock_type accordingly. */
      if (!tl->placeholder() && !tl->schema_table && !using_lock_tables)
        tl->table->reginfo.lock_type= tl->lock_type;
    }
  }
  for (tl= table_list; tl; tl= tl->next_local)
  {
    /* Check access privileges for table */
    if (!tl->derived)
    {
      uint want_privilege= tl->updating ? UPDATE_ACL : SELECT_ACL;
      if (check_access(thd, want_privilege,
                       tl->db, &tl->grant.privilege, 0, 0, 
                       test(tl->schema_table)) ||
          (grant_option && check_grant(thd, want_privilege, tl, 0, 1, 0)))
        DBUG_RETURN(TRUE);
    }
  }

  /* check single table update for view compound from several tables */
  for (tl= table_list; tl; tl= tl->next_local)
  {
    if (tl->effective_algorithm == VIEW_ALGORITHM_MERGE)
    {
      TABLE_LIST *for_update= 0;
      if (tl->check_single_table(&for_update, tables_for_update, tl))
      {
        my_error(ER_VIEW_MULTIUPDATE, MYF(0),
                 tl->view_db.str, tl->view_name.str);
        DBUG_RETURN(-1);
      }
    }
  }

  /* now lock and fill tables */
  if (lock_tables(thd, table_list, table_count, &need_reopen))
  {
    if (!need_reopen)
      DBUG_RETURN(TRUE);

    /*
      We have to reopen tables since some of them were altered or dropped
      during lock_tables() or something was done with their triggers.
      Let us do some cleanups to be able do setup_table() and setup_fields()
      once again.
    */
    List_iterator_fast<Item> it(*fields);
    Item *item;
    while ((item= it++))
      item->cleanup();

    /* We have to cleanup translation tables of views. */
    for (TABLE_LIST *tbl= table_list; tbl; tbl= tbl->next_global)
      tbl->cleanup_items();

    close_tables_for_reopen(thd, &table_list);
    goto reopen_tables;
  }

  /*
    Check that we are not using table that we are updating, but we should
    skip all tables of UPDATE SELECT itself
  */
  lex->select_lex.exclude_from_table_unique_test= TRUE;
  /* We only need SELECT privilege for columns in the values list */
  for (tl= leaves; tl; tl= tl->next_leaf)
  {
    TABLE *table= tl->table;
    TABLE_LIST *tlist;
    if (!(tlist= tl->top_table())->derived)
    {
      tlist->grant.want_privilege=
        (SELECT_ACL & ~tlist->grant.privilege);
      table->grant.want_privilege= (SELECT_ACL & ~table->grant.privilege);
    }
    DBUG_PRINT("info", ("table: %s  want_privilege: %u", tl->alias,
                        (uint) table->grant.want_privilege));
    if (tl->lock_type != TL_READ &&
        tl->lock_type != TL_READ_NO_INSERT)
    {
      TABLE_LIST *duplicate;
      if ((duplicate= unique_table(thd, tl, table_list)))
      {
        update_non_unique_table_error(table_list, "UPDATE", duplicate);
        DBUG_RETURN(TRUE);
      }
    }
  }
  /*
    Set exclude_from_table_unique_test value back to FALSE. It is needed for
    further check in multi_update::prepare whether to use record cache.
  */
  lex->select_lex.exclude_from_table_unique_test= FALSE;
 
  if (thd->fill_derived_tables() &&
      mysql_handle_derived(lex, &mysql_derived_filling))
    DBUG_RETURN(TRUE);

  DBUG_RETURN (FALSE);
}

Here is the call graph for this function:

bool mysql_prepare_update	(	THD *	thd,
		TABLE_LIST *	table_list,
		Item **	conds,
		uint	order_num,
		ORDER *	order
	)

Definition at line 725 of file sql_update.cc.

References st_table_list::alias, st_table::alias, bzero, DBUG_ENTER, DBUG_RETURN, ER_UPDATE_TABLE_USED, FALSE, st_table::grant, st_table_list::grant, my_error(), MYF, st_table_list::next_global, order, st_grant_info::privilege, st_table_list::register_want_access(), SELECT_ACL, setup_conds(), setup_ftfuncs(), setup_order(), setup_tables_and_check_access(), st_table_list::table, st_table_list::table_name, TRUE, unique_table(), UPDATE_ACL, update_non_unique_table_error(), and st_grant_info::want_privilege.

{
  TABLE *table= table_list->table;
  TABLE_LIST tables;
  List<Item> all_fields;
  SELECT_LEX *select_lex= &thd->lex->select_lex;
  DBUG_ENTER("mysql_prepare_update");

#ifndef NO_EMBEDDED_ACCESS_CHECKS
  table_list->grant.want_privilege= table->grant.want_privilege= 
    (SELECT_ACL & ~table->grant.privilege);
  table_list->register_want_access(SELECT_ACL);
#endif

  bzero((char*) &tables,sizeof(tables));        // For ORDER BY
  tables.table= table;
  tables.alias= table_list->alias;
  thd->lex->allow_sum_func= 0;

  if (setup_tables_and_check_access(thd, &select_lex->context, 
                                    &select_lex->top_join_list,
                                    table_list,
                                    &select_lex->leaf_tables,
                                    FALSE, UPDATE_ACL) ||
      setup_conds(thd, table_list, select_lex->leaf_tables, conds) ||
      select_lex->setup_ref_array(thd, order_num) ||
      setup_order(thd, select_lex->ref_pointer_array,
                  table_list, all_fields, all_fields, order) ||
      setup_ftfuncs(select_lex))
    DBUG_RETURN(TRUE);

  /* Check that we are not using table that we are updating in a sub select */
  {
    TABLE_LIST *duplicate;
    if ((duplicate= unique_table(thd, table_list, table_list->next_global)))
    {
      update_non_unique_table_error(table_list, "UPDATE", duplicate);
      my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->table_name);
      DBUG_RETURN(TRUE);
    }
  }
  select_lex->fix_prepare_information(thd, conds);
  DBUG_RETURN(FALSE);
}

Here is the call graph for this function:

int mysql_update	(	THD *	thd,
		TABLE_LIST *	table_list,
		List< Item > &	fields,
		List< Item > &	values,
		COND *	conds,
		uint	order_num,
		ORDER *	order,
		ha_rows	limit,
		enum enum_duplicates	handle_duplicates,
		bool	ignore
	)

Definition at line 111 of file sql_update.cc.

References close_tables_for_reopen(), DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, error, HA_POS_ERROR, id, info, lock_tables, MAX_KEY, st_table_list::multitable_view, open_tables(), OPTION_SAFE_UPDATES, TRUE, updated, and st_table_list::view.

Referenced by mysql_execute_command().

{
  bool          using_limit= limit != HA_POS_ERROR;
  bool          safe_update= thd->options & OPTION_SAFE_UPDATES;
  bool          used_key_is_modified, transactional_table, will_batch;
  bool          can_compare_record;
  int           res;
  int           error, loc_error;
  uint          used_index= MAX_KEY, dup_key_found;
  bool          need_sort= TRUE;
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  uint          want_privilege;
#endif
  uint          table_count= 0;
  ha_rows       updated, found;
  key_map       old_used_keys;
  TABLE         *table;
  SQL_SELECT    *select;
  READ_RECORD   info;
  SELECT_LEX    *select_lex= &thd->lex->select_lex;
  bool          need_reopen;
  ulonglong     id;
  DBUG_ENTER("mysql_update");

  for ( ; ; )
  {
    if (open_tables(thd, &table_list, &table_count, 0))
      DBUG_RETURN(1);

    if (table_list->multitable_view)
    {
      DBUG_ASSERT(table_list->view != 0);
      DBUG_PRINT("info", ("Switch to multi-update"));
      /* pass counter value */
      thd->lex->table_count= table_count;
      /* convert to multiupdate */
      DBUG_RETURN(2);
    }
    if (!lock_tables(thd, table_list, table_count, &need_reopen))
      break;
    if (!need_reopen)
      DBUG_RETURN(1);
    close_tables_for_reopen(thd, &table_list);
  }

  if (mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
      (thd->fill_derived_tables() &&
       mysql_handle_derived(thd->lex, &mysql_derived_filling)))
    DBUG_RETURN(1);

  thd->proc_info="init";
  table= table_list->table;

  /* Calculate "table->used_keys" based on the WHERE */
  table->used_keys= table->s->keys_in_use;
  table->quick_keys.clear_all();

#ifndef NO_EMBEDDED_ACCESS_CHECKS
  /* TABLE_LIST contain right privilages request */
  want_privilege= table_list->grant.want_privilege;
#endif
  if (mysql_prepare_update(thd, table_list, &conds, order_num, order))
    DBUG_RETURN(1);

  old_used_keys= table->used_keys;              // Keys used in WHERE
  /* Check the fields we are going to modify */
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  table_list->grant.want_privilege= table->grant.want_privilege= want_privilege;
  table_list->register_want_access(want_privilege);
#endif
  if (setup_fields_with_no_wrap(thd, 0, fields, MARK_COLUMNS_WRITE, 0, 0))
    DBUG_RETURN(1);                     /* purecov: inspected */
  if (table_list->view && check_fields(thd, fields))
  {
    DBUG_RETURN(1);
  }
  if (!table_list->updatable || check_key_in_view(thd, table_list))
  {
    my_error(ER_NON_UPDATABLE_TABLE, MYF(0), table_list->alias, "UPDATE");
    DBUG_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))
      table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
    else
    {
      bitmap_set_bit(table->write_set,
                     table->timestamp_field->field_index);
    }
  }

#ifndef NO_EMBEDDED_ACCESS_CHECKS
  /* Check values */
  table_list->grant.want_privilege= table->grant.want_privilege=
    (SELECT_ACL & ~table->grant.privilege);
#endif
  if (setup_fields(thd, 0, values, MARK_COLUMNS_READ, 0, 0))
  {
    free_underlaid_joins(thd, select_lex);
    DBUG_RETURN(1);                             /* purecov: inspected */
  }

  if (conds)
  {
    Item::cond_result cond_value;
    conds= remove_eq_conds(thd, conds, &cond_value);
    if (cond_value == Item::COND_FALSE)
      limit= 0;                                   // Impossible WHERE
  }
  // Don't count on usage of 'only index' when calculating which key to use
  table->used_keys.clear_all();

#ifdef WITH_PARTITION_STORAGE_ENGINE
  if (prune_partitions(thd, table, conds))
  {
    free_underlaid_joins(thd, select_lex);
    send_ok(thd);                               // No matching records
    DBUG_RETURN(0);
  }
#endif
  /* Update the table->file->stats.records number */
  table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);

  select= make_select(table, 0, 0, conds, 0, &error);
  if (error || !limit ||
      (select && select->check_quick(thd, safe_update, limit)))
  {
    delete select;
    free_underlaid_joins(thd, select_lex);
    if (error)
    {
      DBUG_RETURN(1);                           // Error in where
    }
    send_ok(thd);                               // No matching records
    DBUG_RETURN(0);
  }
  if (!select && limit != HA_POS_ERROR)
  {
    if ((used_index= get_index_for_order(table, order, limit)) != MAX_KEY)
      need_sort= FALSE;
  }
  /* If running in safe sql mode, don't allow updates without keys */
  if (table->quick_keys.is_clear_all())
  {
    thd->server_status|=SERVER_QUERY_NO_INDEX_USED;
    if (safe_update && !using_limit)
    {
      my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
                 ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
      goto err;
    }
  }
  init_ftfuncs(thd, select_lex, 1);
  /* Check if we are modifying a key that we are used to search with */
  
  if (select && select->quick)
  {
    used_index= select->quick->index;
    used_key_is_modified= (!select->quick->unique_key_range() &&
                          select->quick->check_if_keys_used(&fields));
  }
  else
  {
    used_key_is_modified= 0;
    if (used_index == MAX_KEY)                  // no index for sort order
      used_index= table->file->key_used_on_scan;
    if (used_index != MAX_KEY)
      used_key_is_modified= check_if_key_used(table, used_index, fields);
  }

#ifdef WITH_PARTITION_STORAGE_ENGINE
  if (used_key_is_modified || order ||
      partition_key_modified(table, fields))
#else
  if (used_key_is_modified || order)
#endif
  {
    /*
      We can't update table directly;  We must first search after all
      matching rows before updating the table!
    */
    if (used_index < MAX_KEY && old_used_keys.is_set(used_index))
    {
      table->key_read=1;
      table->mark_columns_used_by_index(used_index);
    }
    else
    {
      table->use_all_columns();
    }

    /* note: We avoid sorting avoid if we sort on the used index */
    if (order && (need_sort || used_key_is_modified))
    {
      /*
        Doing an ORDER BY;  Let filesort find and sort the rows we are going
        to update
        NOTE: filesort will call table->prepare_for_position()
      */
      uint         length;
      SORT_FIELD  *sortorder;
      ha_rows examined_rows;

      table->sort.io_cache = (IO_CACHE *) my_malloc(sizeof(IO_CACHE),
                                                    MYF(MY_FAE | MY_ZEROFILL));
      if (!(sortorder=make_unireg_sortorder(order, &length)) ||
          (table->sort.found_records= filesort(thd, table, sortorder, length,
                                               select, limit, 1,
                                               &examined_rows))
          == HA_POS_ERROR)
      {
        goto err;
      }
      /*
        Filesort has already found and selected the rows we want to update,
        so we don't need the where clause
      */
      delete select;
      select= 0;
    }
    else
    {
      /*
        We are doing a search on a key that is updated. In this case
        we go trough the matching rows, save a pointer to them and
        update these in a separate loop based on the pointer.
      */

      IO_CACHE tempfile;
      if (open_cached_file(&tempfile, mysql_tmpdir,TEMP_PREFIX,
                           DISK_BUFFER_SIZE, MYF(MY_WME)))
        goto err;

      /* If quick select is used, initialize it before retrieving rows. */
      if (select && select->quick && select->quick->reset())
        goto err;
      table->file->try_semi_consistent_read(1);

      /*
        When we get here, we have one of the following options:
        A. used_index == MAX_KEY
           This means we should use full table scan, and start it with
           init_read_record call
        B. used_index != MAX_KEY
           B.1 quick select is used, start the scan with init_read_record
           B.2 quick select is not used, this is full index scan (with LIMIT)
               Full index scan must be started with init_read_record_idx
      */

      if (used_index == MAX_KEY || (select && select->quick))
        init_read_record(&info,thd,table,select,0,1);
      else
        init_read_record_idx(&info, thd, table, 1, used_index);

      thd->proc_info="Searching rows for update";
      uint tmp_limit= limit;

      while (!(error=info.read_record(&info)) && !thd->killed)
      {
        if (!(select && select->skip_record()))
        {
          if (table->file->was_semi_consistent_read())
            continue;  /* repeat the read of the same row if it still exists */

          table->file->position(table->record[0]);
          if (my_b_write(&tempfile,table->file->ref,
                         table->file->ref_length))
          {
            error=1; /* purecov: inspected */
            break; /* purecov: inspected */
          }
          if (!--limit && using_limit)
          {
            error= -1;
            break;
          }
        }
        else
          table->file->unlock_row();
      }
      if (thd->killed && !error)
        error= 1;                               // Aborted
      limit= tmp_limit;
      table->file->try_semi_consistent_read(0);
      end_read_record(&info);
     
      /* Change select to use tempfile */
      if (select)
      {
        delete select->quick;
        if (select->free_cond)
          delete select->cond;
        select->quick=0;
        select->cond=0;
      }
      else
      {
        select= new SQL_SELECT;
        select->head=table;
      }
      if (reinit_io_cache(&tempfile,READ_CACHE,0L,0,0))
        error=1; /* purecov: inspected */
      select->file=tempfile;                    // Read row ptrs from this file
      if (error >= 0)
        goto err;
    }
    if (table->key_read)
      table->restore_column_maps_after_mark_index();
  }

  if (ignore)
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
  
  if (select && select->quick && select->quick->reset())
    goto err;
  table->file->try_semi_consistent_read(1);
  init_read_record(&info,thd,table,select,0,1);

  updated= found= 0;
  thd->count_cuted_fields= CHECK_FIELD_WARN;            /* calc cuted fields */
  thd->cuted_fields=0L;
  thd->proc_info="Updating";

  transactional_table= table->file->has_transactions();
  thd->no_trans_update= 0;
  thd->abort_on_warning= test(!ignore &&
                              (thd->variables.sql_mode &
                               (MODE_STRICT_TRANS_TABLES |
                                MODE_STRICT_ALL_TABLES)));
  will_batch= !table->file->start_bulk_update();

  table->mark_columns_needed_for_update();

  /*
    We can use compare_record() to optimize away updates if
    the table handler is returning all columns OR if
    if all updated columns are read
  */
  can_compare_record= (!(table->file->ha_table_flags() &
                         HA_PARTIAL_COLUMN_READ) ||
                       bitmap_is_subset(table->write_set, table->read_set));

  while (!(error=info.read_record(&info)) && !thd->killed)
  {
    if (!(select && select->skip_record()))
    {
      if (table->file->was_semi_consistent_read())
        continue;  /* repeat the read of the same row if it still exists */

      store_record(table,record[1]);
      if (fill_record_n_invoke_before_triggers(thd, fields, values, 0,
                                               table->triggers,
                                               TRG_EVENT_UPDATE))
        break; /* purecov: inspected */

      found++;

      if (!can_compare_record || compare_record(table))
      {
        if ((res= table_list->view_check_option(thd, ignore)) !=
            VIEW_CHECK_OK)
        {
          found--;
          if (res == VIEW_CHECK_SKIP)
            continue;
          else if (res == VIEW_CHECK_ERROR)
          {
            error= 1;
            break;
          }
        }
        if (will_batch)
        {
          /*
            Typically a batched handler can execute the batched jobs when:
            1) When specifically told to do so
            2) When it is not a good idea to batch anymore
            3) When it is necessary to send batch for other reasons
               (One such reason is when READ's must be performed)

            1) is covered by exec_bulk_update calls.
            2) and 3) is handled by the bulk_update_row method.
            
            bulk_update_row can execute the updates including the one
            defined in the bulk_update_row or not including the row
            in the call. This is up to the handler implementation and can
            vary from call to call.

            The dup_key_found reports the number of duplicate keys found
            in those updates actually executed. It only reports those if
            the extra call with HA_EXTRA_IGNORE_DUP_KEY have been issued.
            If this hasn't been issued it returns an error code and can
            ignore this number. Thus any handler that implements batching
            for UPDATE IGNORE must also handle this extra call properly.

            If a duplicate key is found on the record included in this
            call then it should be included in the count of dup_key_found
            and error should be set to 0 (only if these errors are ignored).
          */
          error= table->file->bulk_update_row(table->record[1],
                                              table->record[0],
                                              &dup_key_found);
          limit+= dup_key_found;
          updated-= dup_key_found;
        }
        else
        {
          /* Non-batched update */
          error= table->file->ha_update_row((byte*) table->record[1],
                                           (byte*) table->record[0]);
        }
        if (!error)
        {
          updated++;
          thd->no_trans_update= !transactional_table;

          if (table->triggers &&
              table->triggers->process_triggers(thd, TRG_EVENT_UPDATE,
                                                TRG_ACTION_AFTER, TRUE))
          {
            error= 1;
            break;
          }
        }
        else if (!ignore ||
                 table->file->is_fatal_error(error, HA_CHECK_DUP_KEY))
        {
          /*
            If (ignore && error is ignorable) we don't have to
            do anything; otherwise...
          */
          if (table->file->is_fatal_error(error, HA_CHECK_DUP_KEY))
            thd->fatal_error(); /* Other handler errors are fatal */
          table->file->print_error(error,MYF(0));
          error= 1;
          break;
        }
      }

      if (!--limit && using_limit)
      {
        /*
          We have reached end-of-file in most common situations where no
          batching has occurred and if batching was supposed to occur but
          no updates were made and finally when the batch execution was
          performed without error and without finding any duplicate keys.
          If the batched updates were performed with errors we need to
          check and if no error but duplicate key's found we need to
          continue since those are not counted for in limit.
        */
        if (will_batch &&
            ((error= table->file->exec_bulk_update(&dup_key_found)) ||
            !dup_key_found))
        {
          if (error)
          {
            /*
              The handler should not report error of duplicate keys if they
              are ignored. This is a requirement on batching handlers.
            */
            table->file->print_error(error,MYF(0));
            error= 1;
            break;
          }
          /*
            Either an error was found and we are ignoring errors or there
            were duplicate keys found. In both cases we need to correct
            the counters and continue the loop.
          */
          limit= dup_key_found; //limit is 0 when we get here so need to +
          updated-= dup_key_found;
        }
        else
        {
          error= -1;                            // Simulate end of file
          break;
        }
      }
    }
    else
      table->file->unlock_row();
    thd->row_count++;
  }
  dup_key_found= 0;
  if (thd->killed && !error)
    error= 1;                                   // Aborted
  else if (will_batch &&
           (loc_error= table->file->exec_bulk_update(&dup_key_found)))
    /*
      An error has occurred when a batched update was performed and returned
      an error indication. It cannot be an allowed duplicate key error since
      we require the batching handler to treat this as a normal behavior.

      Otherwise we simply remove the number of duplicate keys records found
      in the batched update.
    */
  {
    thd->fatal_error();
    table->file->print_error(loc_error,MYF(0));
    error= 1;
  }
  else
    updated-= dup_key_found;
  if (will_batch)
    table->file->end_bulk_update();
  table->file->try_semi_consistent_read(0);
  end_read_record(&info);
  delete select;
  thd->proc_info= "end";
  VOID(table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY));

  /*
    Invalidate the table in the query cache if something changed.
    This must be before binlog writing and ha_autocommit_...
  */
  if (updated)
  {
    query_cache_invalidate3(thd, table_list, 1);
  }

  /*
    error < 0 means really no error at all: we processed all rows until the
    last one without error. error > 0 means an error (e.g. unique key
    violation and no IGNORE or REPLACE). error == 0 is also an error (if
    preparing the record or invoking before triggers fails). See
    ha_autocommit_or_rollback(error>=0) and DBUG_RETURN(error>=0) below.
    Sometimes we want to binlog even if we updated no rows, in case user used
    it to be sure master and slave are in same state.
  */
  if ((error < 0) || (updated && !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;                                // Rollback update
      }
    }
    if (!transactional_table)
      thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
  }
  free_underlaid_joins(thd, select_lex);
  if (transactional_table)
  {
    if (ha_autocommit_or_rollback(thd, error >= 0))
      error=1;
  }

  if (thd->lock)
  {
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
  }

  /* If LAST_INSERT_ID(X) was used, report X */
  id= thd->arg_of_last_insert_id_function ?
    thd->first_successful_insert_id_in_prev_stmt : 0;

  if (error < 0)
  {
    char buff[STRING_BUFFER_USUAL_SIZE];
    sprintf(buff, ER(ER_UPDATE_INFO), (ulong) found, (ulong) updated,
            (ulong) thd->cuted_fields);
    thd->row_count_func=
      (thd->client_capabilities & CLIENT_FOUND_ROWS) ? found : updated;
    send_ok(thd, (ulong) thd->row_count_func, id, buff);
    DBUG_PRINT("info",("%d records updated",updated));
  }
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;          /* calc cuted fields */
  thd->abort_on_warning= 0;
  DBUG_RETURN((error >= 0 || thd->net.report_error) ? 1 : 0);

err:
  delete select;
  free_underlaid_joins(thd, select_lex);
  if (table->key_read)
  {
    table->key_read=0;
    table->file->extra(HA_EXTRA_NO_KEYREAD);
  }
  thd->abort_on_warning= 0;
  DBUG_RETURN(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool safe_update_on_fly	(	JOIN_TAB *	join_tab,
		List< Item > *	fields
	)			[static]

Definition at line 1302 of file sql_update.cc.

References check_if_key_used(), QUICK_SELECT_I::check_if_keys_used(), FALSE, st_table::file, HA_PRIMARY_KEY_IN_READ_INDEX, handler::ha_table_flags(), Table_triggers_list::has_before_update_triggers(), JT_ALL, JT_CONST, JT_EQ_REF, JT_REF, JT_REF_OR_NULL, JT_SYSTEM, st_table_ref::key, MAX_KEY, st_table_share::primary_key, st_join_table::quick, st_join_table::ref, st_table::s, st_join_table::table, st_table::triggers, TRUE, and st_join_table::type.

{
  TABLE *table= join_tab->table;
  switch (join_tab->type) {
  case JT_SYSTEM:
  case JT_CONST:
  case JT_EQ_REF:
    return TRUE;                                // At most one matching row
  case JT_REF:
  case JT_REF_OR_NULL:
    return !check_if_key_used(table, join_tab->ref.key, *fields) &&
           !(table->triggers &&
             table->triggers->has_before_update_triggers());
  case JT_ALL:
    /* If range search on index */
    if (join_tab->quick)
      return !join_tab->quick->check_if_keys_used(fields) &&
             !(table->triggers &&
               table->triggers->has_before_update_triggers());
    /* If scanning in clustered key */
    if ((table->file->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
        table->s->primary_key < MAX_KEY)
      return !check_if_key_used(table, table->s->primary_key, *fields) &&
             !(table->triggers &&
               table->triggers->has_before_update_triggers());
    return TRUE;
  default:
    break;                                      // Avoid compler warning
  }
  return FALSE;
}

Here is the call graph for this function:

---

• 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.