sql_update.cc 40.1 KB
Newer Older
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
2

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
7

bk@work.mysql.com's avatar
bk@work.mysql.com committed
8 9 10 11
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
12

bk@work.mysql.com's avatar
bk@work.mysql.com committed
13 14 15 16 17
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


18 19 20
/*
  Single table and multi table updates of tables.
  Multi-table updates were introduced by Sinisa & Monty
21
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
22 23

#include "mysql_priv.h"
24
#include "sql_select.h"
25 26
#include "sp_head.h"
#include "sql_trigger.h"
bk@work.mysql.com's avatar
bk@work.mysql.com committed
27

28 29
static bool safe_update_on_fly(JOIN_TAB *join_tab, List<Item> *fields);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
30 31
/* Return 0 if row hasn't changed */

32
static bool compare_record(TABLE *table, query_id_t query_id)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
33
{
34
  if (table->s->blob_fields + table->s->varchar_fields == 0)
35
    return cmp_record(table,record[1]);
36
  /* Compare null bits */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
37
  if (memcmp(table->null_flags,
38 39
	     table->null_flags+table->s->rec_buff_length,
	     table->s->null_bytes))
40
    return TRUE;				// Diff in NULL value
41
  /* Compare updated fields */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
42 43
  for (Field **ptr=table->field ; *ptr ; ptr++)
  {
44
    if ((*ptr)->query_id == query_id &&
45
	(*ptr)->cmp_binary_offset(table->s->rec_buff_length))
46
      return TRUE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
47
  }
48
  return FALSE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
49 50 51
}


bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
52 53 54 55 56
/*
  check that all fields are real fields

  SYNOPSIS
    check_fields()
57
    thd             thread handler
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
58 59 60 61 62 63 64
    items           Items for check

  RETURN
    TRUE  Items can't be used in UPDATE
    FALSE Items are OK
*/

65
static bool check_fields(THD *thd, List<Item> &items)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
66
{
67
  List_iterator<Item> it(items);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
68
  Item *item;
69
  Item_field *field;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
70 71
  while ((item= it++))
  {
72
    if (!(field= item->filed_for_view_update()))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
73
    {
74
      /* item has name, because it comes from VIEW SELECT list */
75
      my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), item->name);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
76 77
      return TRUE;
    }
78 79 80 81
    /*
      we make temporary copy of Item_field, to avoid influence of changing
      result_field on Item_ref which refer on this field
    */
monty@mysql.com's avatar
monty@mysql.com committed
82
    thd->change_item_tree(it.ref(), new Item_field(thd, field));
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
83 84 85 86 87
  }
  return FALSE;
}


88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
/*
  Process usual UPDATE

  SYNOPSIS
    mysql_update()
    thd			thread handler
    fields		fields for update
    values		values of fields for update
    conds		WHERE clause expression
    order_num		number of elemen in ORDER BY clause
    order		ORDER BY clause list
    limit		limit clause
    handle_duplicates	how to handle duplicates

  RETURN
    0  - OK
    2  - privilege check and openning table passed, but we need to convert to
         multi-update because of view substitution
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
106
    1  - error
107 108
*/

109 110 111 112 113
int mysql_update(THD *thd,
                 TABLE_LIST *table_list,
                 List<Item> &fields,
		 List<Item> &values,
                 COND *conds,
114
                 uint order_num, ORDER *order,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
115
		 ha_rows limit,
116
		 enum enum_duplicates handle_duplicates, bool ignore)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
117
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
118
  bool		using_limit= limit != HA_POS_ERROR;
119
  bool		safe_update= thd->options & OPTION_SAFE_UPDATES;
120
  bool		used_key_is_modified, transactional_table;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
121
  int           res;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
122
  int		error=0;
serg@serg.mylan's avatar
serg@serg.mylan committed
123
  uint		used_index;
124 125 126
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  uint		want_privilege;
#endif
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
127
  uint          table_count= 0;
128
  query_id_t	query_id=thd->query_id, timestamp_query_id;
129
  ha_rows	updated, found;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
130 131 132 133
  key_map	old_used_keys;
  TABLE		*table;
  SQL_SELECT	*select;
  READ_RECORD	info;
134
  SELECT_LEX    *select_lex= &thd->lex->select_lex;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
135
  DBUG_ENTER("mysql_update");
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
136

137
  LINT_INIT(timestamp_query_id);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
138

139
  if (open_tables(thd, &table_list, &table_count))
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
140
    DBUG_RETURN(1);
141

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
142
  if (table_list->multitable_view)
143
  {
144
    DBUG_ASSERT(table_list->view != 0);
145
    DBUG_PRINT("info", ("Switch to multi-update"));
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
146 147
    /* pass counter value */
    thd->lex->table_count= table_count;
148 149 150
    /* convert to multiupdate */
    return 2;
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
151 152 153 154 155

  if (lock_tables(thd, table_list, table_count) ||
      mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
      (thd->fill_derived_tables() &&
       mysql_handle_derived(thd->lex, &mysql_derived_filling)))
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
156
    DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
157

bk@work.mysql.com's avatar
bk@work.mysql.com committed
158
  thd->proc_info="init";
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
159
  table= table_list->table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
160 161
  table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);

162
  /* Calculate "table->used_keys" based on the WHERE */
163
  table->used_keys= table->s->keys_in_use;
164
  table->quick_keys.clear_all();
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
165

hf@deer.(none)'s avatar
hf@deer.(none) committed
166
#ifndef NO_EMBEDDED_ACCESS_CHECKS
167 168
  /* TABLE_LIST contain right privilages request */
  want_privilege= table_list->grant.want_privilege;
hf@deer.(none)'s avatar
hf@deer.(none) committed
169
#endif
170
  if (mysql_prepare_update(thd, table_list, &conds, order_num, order))
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
171
    DBUG_RETURN(1);
172

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
173
  old_used_keys= table->used_keys;		// Keys used in WHERE
bk@work.mysql.com's avatar
bk@work.mysql.com committed
174
  /*
175 176
    Change the query_id for the timestamp column so that we can
    check if this is modified directly
bk@work.mysql.com's avatar
bk@work.mysql.com committed
177
  */
178 179 180 181 182
  if (table->timestamp_field)
  {
    timestamp_query_id=table->timestamp_field->query_id;
    table->timestamp_field->query_id=thd->query_id-1;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
183

184
  /* Check the fields we are going to modify */
hf@deer.(none)'s avatar
hf@deer.(none) committed
185
#ifndef NO_EMBEDDED_ACCESS_CHECKS
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
186
  table_list->grant.want_privilege= table->grant.want_privilege= want_privilege;
hf@deer.(none)'s avatar
hf@deer.(none) committed
187
#endif
188
  {
189
    bool res;
190
    select_lex->no_wrap_view_item= 1;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
191
    res= setup_fields(thd, 0, table_list, fields, 1, 0, 0);
192
    select_lex->no_wrap_view_item= 0;
193
    if (res)
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
194
      DBUG_RETURN(1);			/* purecov: inspected */
195 196
  }
  if (table_list->view && check_fields(thd, fields))
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
197
  {
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
198
    DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
199 200 201
  }
  if (!table_list->updatable || check_key_in_view(thd, table_list))
  {
202
    my_error(ER_NON_UPDATABLE_TABLE, MYF(0), table_list->alias, "UPDATE");
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
203
    DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
204
  }
205 206 207 208
  if (table->timestamp_field)
  {
    // Don't set timestamp column if this is modified
    if (table->timestamp_field->query_id == thd->query_id)
209
      table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
210 211 212
    else
      table->timestamp_field->query_id=timestamp_query_id;
  }
213

hf@deer.(none)'s avatar
hf@deer.(none) committed
214
#ifndef NO_EMBEDDED_ACCESS_CHECKS
215
  /* Check values */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
216
  table_list->grant.want_privilege= table->grant.want_privilege=
217
    (SELECT_ACL & ~table->grant.privilege);
hf@deer.(none)'s avatar
hf@deer.(none) committed
218
#endif
monty@mishka.local's avatar
monty@mishka.local committed
219
  if (setup_fields(thd, 0, table_list, values, 1, 0, 0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
220
  {
221
    free_underlaid_joins(thd, select_lex);
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
222
    DBUG_RETURN(1);				/* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
223
  }
224

225
  // Don't count on usage of 'only index' when calculating which key to use
226
  table->used_keys.clear_all();
monty@mysql.com's avatar
monty@mysql.com committed
227
  select= make_select(table, 0, 0, conds, 0, &error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
228
  if (error ||
229
      (select && select->check_quick(thd, safe_update, limit)) || !limit)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
230 231
  {
    delete select;
232
    free_underlaid_joins(thd, select_lex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
233 234
    if (error)
    {
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
235
      DBUG_RETURN(1);				// Error in where
bk@work.mysql.com's avatar
bk@work.mysql.com committed
236
    }
237
    send_ok(thd);				// No matching records
bk@work.mysql.com's avatar
bk@work.mysql.com committed
238 239 240
    DBUG_RETURN(0);
  }
  /* If running in safe sql mode, don't allow updates without keys */
241
  if (table->quick_keys.is_clear_all())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
242
  {
243
    thd->server_status|=SERVER_QUERY_NO_INDEX_USED;
244
    if (safe_update && !using_limit)
245
    {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
246 247 248
      my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
		 ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
      goto err;
249
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
250
  }
251
  init_ftfuncs(thd, select_lex, 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
252
  /* Check if we are modifying a key that we are used to search with */
253
  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
254
  if (select && select->quick)
255
  {
256
    used_index= select->quick->index;
257 258
    used_key_is_modified= (!select->quick->unique_key_range() &&
                          select->quick->check_if_keys_used(&fields));
259
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
260 261 262 263
  else if ((used_index=table->file->key_used_on_scan) < MAX_KEY)
    used_key_is_modified=check_if_key_used(table, used_index, fields);
  else
    used_key_is_modified=0;
264

265
  if (used_key_is_modified || order)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
266 267
  {
    /*
268 269
      We can't update table directly;  We must first search after all
      matching rows before updating the table!
bk@work.mysql.com's avatar
bk@work.mysql.com committed
270
    */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
271
    table->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
272
    if (used_index < MAX_KEY && old_used_keys.is_set(used_index))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
273 274 275 276
    {
      table->key_read=1;
      table->file->extra(HA_EXTRA_KEYREAD);
    }
277 278 279

    if (order)
    {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
280 281 282 283
      /*
	Doing an ORDER BY;  Let filesort find and sort the rows we are going
	to update
      */
284 285
      uint         length;
      SORT_FIELD  *sortorder;
286
      ha_rows examined_rows;
287

igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
288
      table->sort.io_cache = (IO_CACHE *) my_malloc(sizeof(IO_CACHE),
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
289
						    MYF(MY_FAE | MY_ZEROFILL));
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
290
      if (!(sortorder=make_unireg_sortorder(order, &length)) ||
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
291
          (table->sort.found_records = filesort(thd, table, sortorder, length,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
292
						select, limit,
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
293
						&examined_rows))
294 295
          == HA_POS_ERROR)
      {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
296
	free_io_cache(table);
297
	goto err;
298
      }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
299 300 301 302 303 304
      /*
	Filesort has already found and selected the rows we want to update,
	so we don't need the where clause
      */
      delete select;
      select= 0;
305
    }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
306
    else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
307
    {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
308 309 310 311 312 313 314 315 316
      /*
	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)))
317
	goto err;
318
      
sergefp@mysql.com's avatar
sergefp@mysql.com committed
319 320 321
      /* If quick select is used, initialize it before retrieving rows. */
      if (select && select->quick && select->quick->reset())
        goto err;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
322
      init_read_record(&info,thd,table,select,0,1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
323

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
324 325
      thd->proc_info="Searching rows for update";
      uint tmp_limit= limit;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
326

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
327
      while (!(error=info.read_record(&info)) && !thd->killed)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
328
      {
329
	if (!(select && select->skip_record()))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
330
	{
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
331 332 333 334 335 336 337 338
	  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)
339 340
	  {
	    error= -1;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
341
	    break;
342
	  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
343 344
	}
      }
345 346
      if (thd->killed && !error)
	error= 1;				// Aborted
347
      limit= tmp_limit;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
348 349 350 351 352 353 354 355 356 357
      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;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
358 359
      else
      {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
360 361
	select= new SQL_SELECT;
	select->head=table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
362
      }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
363 364 365 366
      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)
367
	goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
368 369 370 371 372 373 374 375
    }
    if (table->key_read)
    {
      table->key_read=0;
      table->file->extra(HA_EXTRA_NO_KEYREAD);
    }
  }

376
  if (ignore)
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
377
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
378 379 380
  
  if (select && select->quick && select->quick->reset())
        goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
381 382
  init_read_record(&info,thd,table,select,0,1);

383
  updated= found= 0;
384
  thd->count_cuted_fields= CHECK_FIELD_WARN;		/* calc cuted fields */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
385
  thd->cuted_fields=0L;
386
  thd->proc_info="Updating";
387
  query_id=thd->query_id;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
388

389 390
  transactional_table= table->file->has_transactions();
  thd->no_trans_update= 0;
monty@mysql.com's avatar
monty@mysql.com committed
391
  thd->abort_on_warning= test(!ignore &&
392 393 394
                              (thd->variables.sql_mode &
                               (MODE_STRICT_TRANS_TABLES |
                                MODE_STRICT_ALL_TABLES)));
395

bk@work.mysql.com's avatar
bk@work.mysql.com committed
396 397
  while (!(error=info.read_record(&info)) && !thd->killed)
  {
398
    if (!(select && select->skip_record()))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
399
    {
400
      store_record(table,record[1]);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
401
      if (fill_record(thd, fields, values, 0))
402
	break; /* purecov: inspected */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
403

bk@work.mysql.com's avatar
bk@work.mysql.com committed
404
      found++;
405 406 407 408

      if (table->triggers)
        table->triggers->process_triggers(thd, TRG_EVENT_UPDATE, TRG_ACTION_BEFORE);

409
      if (compare_record(table, query_id))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
410
      {
monty@mysql.com's avatar
monty@mysql.com committed
411
        if ((res= table_list->view_check_option(thd, ignore)) !=
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
412 413 414 415 416 417 418 419 420 421 422
            VIEW_CHECK_OK)
        {
          found--;
          if (res == VIEW_CHECK_SKIP)
            continue;
          else if (res == VIEW_CHECK_ERROR)
          {
            error= 1;
            break;
          }
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
423 424 425 426
	if (!(error=table->file->update_row((byte*) table->record[1],
					    (byte*) table->record[0])))
	{
	  updated++;
427
          thd->no_trans_update= !transactional_table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
428
	}
429
 	else if (!ignore || error != HA_ERR_FOUND_DUPP_KEY)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
430
	{
monty@mysql.com's avatar
monty@mysql.com committed
431
          thd->fatal_error();                   // Force error message
bk@work.mysql.com's avatar
bk@work.mysql.com committed
432 433 434 435 436
	  table->file->print_error(error,MYF(0));
	  error= 1;
	  break;
	}
      }
437 438 439 440

      if (table->triggers)
        table->triggers->process_triggers(thd, TRG_EVENT_UPDATE, TRG_ACTION_AFTER);

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
441 442 443 444 445
      if (!--limit && using_limit)
      {
	error= -1;				// Simulate end of file
	break;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
446
    }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
447 448
    else
      table->file->unlock_row();
449
    thd->row_count++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
450
  }
451 452
  if (thd->killed && !error)
    error= 1;					// Aborted
bk@work.mysql.com's avatar
bk@work.mysql.com committed
453
  end_read_record(&info);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
454
  free_io_cache(table);				// If ORDER BY
455
  delete select;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
456
  thd->proc_info="end";
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
457
  VOID(table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY));
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
458 459 460 461 462 463

  /*
    Invalidate the table in the query cache if something changed.
    This must be before binlog writing and ha_autocommit_...
  */
  if (updated)
monty@mysql.com's avatar
monty@mysql.com committed
464
  {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
465
    query_cache_invalidate3(thd, table_list, 1);
monty@mysql.com's avatar
monty@mysql.com committed
466
  }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
467

468
  if ((updated || (error < 0)) && (error <= 0 || !transactional_table))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
469
  {
470 471
    if (mysql_bin_log.is_open())
    {
guilhem@mysql.com's avatar
guilhem@mysql.com committed
472 473
      if (error <= 0)
        thd->clear_error();
474
      Query_log_event qinfo(thd, thd->query, thd->query_length,
475
			    transactional_table, FALSE);
476 477
      if (mysql_bin_log.write(&qinfo) && transactional_table)
	error=1;				// Rollback update
478
    }
479
    if (!transactional_table)
480
      thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
481
  }
482 483 484 485 486
  if (transactional_table)
  {
    if (ha_autocommit_or_rollback(thd, error >= 0))
      error=1;
  }
487

488 489 490 491 492 493
  if (thd->lock)
  {
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
  }

494
  free_underlaid_joins(thd, select_lex);
495
  if (error < 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
496
  {
497
    char buff[STRING_BUFFER_USUAL_SIZE];
498 499
    sprintf(buff, ER(ER_UPDATE_INFO), (ulong) found, (ulong) updated,
	    (ulong) thd->cuted_fields);
500 501
    thd->row_count_func=
      (thd->client_capabilities & CLIENT_FOUND_ROWS) ? found : updated;
502
    send_ok(thd, (ulong) thd->row_count_func,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
503 504 505
	    thd->insert_id_used ? thd->insert_id() : 0L,buff);
    DBUG_PRINT("info",("%d records updated",updated));
  }
506
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;		/* calc cuted fields */
507
  thd->abort_on_warning= 0;
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
508
  free_io_cache(table);
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
509
  DBUG_RETURN((error >= 0 || thd->net.report_error) ? 1 : 0);
510 511 512

err:
  delete select;
513
  free_underlaid_joins(thd, select_lex);
514 515 516 517 518
  if (table->key_read)
  {
    table->key_read=0;
    table->file->extra(HA_EXTRA_NO_KEYREAD);
  }
519
  thd->abort_on_warning= 0;
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
520
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
521
}
522

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
523 524 525 526 527 528
/*
  Prepare items in UPDATE statement

  SYNOPSIS
    mysql_prepare_update()
    thd			- thread handler
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
529
    table_list		- global/local table list
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
530 531 532 533 534
    conds		- conditions
    order_num		- number of ORDER BY list entries
    order		- ORDER BY clause list

  RETURN VALUE
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
535 536
    FALSE OK
    TRUE  error
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
537
*/
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
538
bool mysql_prepare_update(THD *thd, TABLE_LIST *table_list,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
539 540 541 542 543
			 Item **conds, uint order_num, ORDER *order)
{
  TABLE *table= table_list->table;
  TABLE_LIST tables;
  List<Item> all_fields;
544
  SELECT_LEX *select_lex= &thd->lex->select_lex;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
545 546 547
  DBUG_ENTER("mysql_prepare_update");

#ifndef NO_EMBEDDED_ACCESS_CHECKS
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
548 549
  table_list->grant.want_privilege= table->grant.want_privilege= 
    (SELECT_ACL & ~table->grant.privilege);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
550 551 552 553 554 555
#endif

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

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
556 557
  if (setup_tables(thd, table_list, conds, &select_lex->leaf_tables,
                   FALSE, FALSE) ||
558
      setup_conds(thd, table_list, select_lex->leaf_tables, conds) ||
559 560
      select_lex->setup_ref_array(thd, order_num) ||
      setup_order(thd, select_lex->ref_pointer_array,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
561
		  table_list, all_fields, all_fields, order) ||
562
      setup_ftfuncs(select_lex))
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
563
    DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
564 565

  /* Check that we are not using table that we are updating in a sub select */
566
  if (unique_table(table_list, table_list->next_global))
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
567
  {
568
    my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->table_name);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
569
    DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
570
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
571
  select_lex->fix_prepare_information(thd, conds);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
572
  DBUG_RETURN(FALSE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
573 574
}

575

576
/***************************************************************************
577
  Update multiple tables from join 
578 579
***************************************************************************/

580
/*
581
  Get table map for list of Item_field
582 583
*/

584 585 586 587 588 589 590 591 592 593 594 595 596
static table_map get_table_map(List<Item> *items)
{
  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;
}


bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
597 598
/*
  make update specific preparation and checks after opening tables
599

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
600 601 602
  SYNOPSIS
    mysql_multi_update_prepare()
    thd         thread handler
603

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
604
  RETURN
605 606
    FALSE OK
    TRUE  Error
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
607
*/
608

609
bool mysql_multi_update_prepare(THD *thd)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
610 611
{
  LEX *lex= thd->lex;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
612
  ulong opened_tables;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
613
  TABLE_LIST *table_list= lex->query_tables;
monty@mysql.com's avatar
monty@mysql.com committed
614
  TABLE_LIST *tl, *leaves;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
615
  List<Item> *fields= &lex->select_lex.item_list;
616
  table_map tables_for_update;
617 618
  int res;
  bool update_view= 0;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
619 620 621 622 623 624
  /*
    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;
625
  const bool using_lock_tables= thd->locked_tables != 0;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
626
  bool original_multiupdate= (thd->lex->sql_command == SQLCOM_UPDATE_MULTI);
monty@mysql.com's avatar
monty@mysql.com committed
627 628
  DBUG_ENTER("mysql_multi_update_prepare");

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
629 630
  /* following need for prepared statements, to run next time multi-update */
  thd->lex->sql_command= SQLCOM_UPDATE_MULTI;
631 632

  /* open tables and create derived ones, but do not lock and fill them */
633
  if ((original_multiupdate && open_tables(thd, &table_list, & table_count)) ||
634
      mysql_handle_derived(lex, &mysql_derived_prepare))
635
    DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
636 637 638 639 640
  /*
    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()).
  */
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
641

642
  if (setup_tables(thd, table_list, &lex->select_lex.where,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
643
                   &lex->select_lex.leaf_tables, FALSE, FALSE))
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
644
    DBUG_RETURN(TRUE);
monty@mysql.com's avatar
monty@mysql.com committed
645
  leaves= lex->select_lex.leaf_tables;
646

bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
647
  if ((lex->select_lex.no_wrap_view_item= 1,
648
       res= setup_fields(thd, 0, table_list, *fields, 1, 0, 0),
649
       lex->select_lex.no_wrap_view_item= 0,
650
       res))
651
    DBUG_RETURN(TRUE);
652 653 654 655 656 657 658 659 660 661 662

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

  if (update_view && check_fields(thd, *fields))
663
  {
664
    DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
665 666
  }

667
  tables_for_update= get_table_map(fields);
668 669

  /*
670
    Setup timestamp handling and locking mode
671
  */
672
  for (tl= leaves; tl; tl= tl->next_leaf)
673
  {
674
    TABLE *table= tl->table;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
675
    /* Only set timestamp column if this is not modified */
676 677
    if (table->timestamp_field &&
        table->timestamp_field->query_id == thd->query_id)
monty@mysql.com's avatar
monty@mysql.com committed
678
      table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
679

680 681
    /* if table will be updated then check that it is unique */
    if (table->map & tables_for_update)
682
    {
683
      if (!tl->updatable || check_key_in_view(thd, tl))
684
      {
685
        my_error(ER_NON_UPDATABLE_TABLE, MYF(0), tl->alias, "UPDATE");
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
686
        DBUG_RETURN(TRUE);
687
      }
688 689

      DBUG_PRINT("info",("setting table `%s` for update", tl->alias));
690 691 692 693
      /*
        If table will be updated we should not downgrade lock for it and
        leave it as is.
      */
monty@mysql.com's avatar
monty@mysql.com committed
694
    }
695 696 697
    else
    {
      DBUG_PRINT("info",("setting table `%s` for read-only", tl->alias));
monty@mysql.com's avatar
monty@mysql.com committed
698 699 700 701 702 703
      /*
        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;
704
      tl->updating= 0;
705 706 707
      /* Update TABLE::lock_type accordingly. */
      if (!tl->placeholder() && !tl->schema_table && !using_lock_tables)
        tl->table->reginfo.lock_type= tl->lock_type;
708
    }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
709 710 711
  }
  for(tl= table_list; tl; tl= tl->next_local)
  {
monty@mishka.local's avatar
monty@mishka.local committed
712
    /* Check access privileges for table */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
713
    if (!tl->derived)
714
    {
monty@mysql.com's avatar
monty@mysql.com committed
715 716 717 718
      uint want_privilege= tl->updating ? UPDATE_ACL : SELECT_ACL;
      if (check_access(thd, want_privilege,
                        tl->db, &tl->grant.privilege, 0, 0) ||
          (grant_option && check_grant(thd, want_privilege, tl, 0, 1, 0)))
monty@mishka.local's avatar
monty@mishka.local committed
719
        DBUG_RETURN(TRUE);
720
    }
721
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
722

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
723 724 725
  /* check single table update for view compound from several tables */
  for (tl= table_list; tl; tl= tl->next_local)
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
726
    if (tl->effective_algorithm == VIEW_ALGORITHM_MERGE)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
727 728
    {
      TABLE_LIST *for_update= 0;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
729
      if (tl->check_single_table(&for_update, tables_for_update, tl))
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
730 731 732 733 734 735 736 737
      {
	my_error(ER_VIEW_MULTIUPDATE, MYF(0),
		 tl->view_db.str, tl->view_name.str);
	DBUG_RETURN(-1);
      }
    }
  }

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
738
  opened_tables= thd->status_var.opened_tables;
739
  /* now lock and fill tables */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
740
  if (lock_tables(thd, table_list, table_count))
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
741
    DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
742 743 744 745 746 747 748 749 750 751 752 753 754

  /*
    we have to re-call fixfields for fixed items, because lock maybe
    reopened tables
  */
  if (opened_tables != thd->status_var.opened_tables)
  {
    /*
      Fields items cleanup(). There are only Item_fields in the list, so we
      do not do Item tree walking
    */
    List_iterator_fast<Item> it(*fields);
    Item *item;
monty@mysql.com's avatar
monty@mysql.com committed
755
    while ((item= it++))
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
756 757
      item->cleanup();

monty@mysql.com's avatar
monty@mysql.com committed
758
    /* We have to cleanup translation tables of views. */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
759 760 761
    for (TABLE_LIST *tbl= table_list; tbl; tbl= tbl->next_global)
      tbl->cleanup_items();

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
762
    if (setup_tables(thd, table_list, &lex->select_lex.where,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
763
                     &lex->select_lex.leaf_tables, FALSE, FALSE) ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
764 765 766 767
        (lex->select_lex.no_wrap_view_item= 1,
         res= setup_fields(thd, 0, table_list, *fields, 1, 0, 0),
         lex->select_lex.no_wrap_view_item= 0,
         res))
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
768
      DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
769
  }
monty@mysql.com's avatar
monty@mysql.com committed
770

771 772 773 774 775
  /*
    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;
monty@mysql.com's avatar
monty@mysql.com committed
776 777 778 779 780 781 782 783 784 785 786 787 788
  /* 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->belong_to_view ? tl->belong_to_view : tl)->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));
789 790 791 792 793 794 795
    if (tl->lock_type != TL_READ &&
        tl->lock_type != TL_READ_NO_INSERT &&
        unique_table(tl, table_list))
    {
      my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->table_name);
      DBUG_RETURN(TRUE);
    }
monty@mysql.com's avatar
monty@mysql.com committed
796 797
  }

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
798 799
  if (thd->fill_derived_tables() &&
      mysql_handle_derived(lex, &mysql_derived_filling))
800
    DBUG_RETURN(TRUE);
801

bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
802
  DBUG_RETURN (FALSE);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
803 804 805
}


monty@mysql.com's avatar
monty@mysql.com committed
806 807 808
/*
  Setup multi-update handling and call SELECT to do the join
*/
809

810 811 812 813 814 815
bool mysql_multi_update(THD *thd,
                        TABLE_LIST *table_list,
                        List<Item> *fields,
                        List<Item> *values,
                        COND *conds,
                        ulong options,
816
                        enum enum_duplicates handle_duplicates, bool ignore,
817
                        SELECT_LEX_UNIT *unit, SELECT_LEX *select_lex)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
818 819 820 821
{
  multi_update *result;
  DBUG_ENTER("mysql_multi_update");

822 823
  if (mysql_multi_update_prepare(thd))
    DBUG_RETURN(TRUE);
824

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

831 832 833 834 835
  thd->no_trans_update= 0;
  thd->abort_on_warning= test(thd->variables.sql_mode &
                              (MODE_STRICT_TRANS_TABLES |
                               MODE_STRICT_ALL_TABLES));

836
  List<Item> total_list;
837 838 839 840 841 842 843 844
  (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);
845
  delete result;
846
  thd->abort_on_warning= 0;
847
  DBUG_RETURN(FALSE);
848 849
}

850 851

multi_update::multi_update(THD *thd_arg, TABLE_LIST *table_list,
852
			   TABLE_LIST *leaves_list,
853
			   List<Item> *field_list, List<Item> *value_list,
monty@mysql.com's avatar
monty@mysql.com committed
854 855
			   enum enum_duplicates handle_duplicates_arg,
                           bool ignore_arg)
856 857 858 859
  :all_tables(table_list), leaves(leaves_list), update_tables(0),
   thd(thd_arg), tmp_tables(0), updated(0), found(0), fields(field_list),
   values(value_list), table_count(0), copy_field(0),
   handle_duplicates(handle_duplicates_arg), do_update(1), trans_safe(0),
860
   transactional_tables(1), ignore(ignore_arg)
861 862 863 864 865 866 867
{}


/*
  Connect fields with tables and create list of tables that are updated
*/

868 869
int multi_update::prepare(List<Item> &not_used_values,
			  SELECT_LEX_UNIT *lex_unit)
870
{
871 872
  TABLE_LIST *table_ref;
  SQL_LIST update;
873
  table_map tables_to_update;
874 875 876 877
  Item_field *item;
  List_iterator_fast<Item> field_it(*fields);
  List_iterator_fast<Item> value_it(*values);
  uint i, max_fields;
878
  DBUG_ENTER("multi_update::prepare");
879

880
  thd->count_cuted_fields= CHECK_FIELD_WARN;
881
  thd->cuted_fields=0L;
882 883
  thd->proc_info="updating main table";

884
  tables_to_update= get_table_map(fields);
885

886
  if (!tables_to_update)
887
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
888
    my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));
889
    DBUG_RETURN(1);
890
  }
891

892
  /*
893 894
    We have to check values after setup_tables to get used_keys right in
    reference tables
895
  */
896

897
  if (setup_fields(thd, 0, all_tables, *values, 1, 0, 0))
898 899
    DBUG_RETURN(1);

900
  /*
901 902 903
    Save tables beeing updated in update_tables
    update_table->shared is position for table
    Don't use key read on tables that are updated
904
  */
905 906

  update.empty();
907
  for (table_ref= leaves; table_ref; table_ref= table_ref->next_leaf)
908
  {
909
    /* TODO: add support of view of join support */
910 911
    TABLE *table=table_ref->table;
    if (tables_to_update & table->map)
912
    {
913 914 915
      TABLE_LIST *tl= (TABLE_LIST*) thd->memdup((char*) table_ref,
						sizeof(*tl));
      if (!tl)
916
	DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
917
      update.link_in_list((byte*) tl, (byte**) &tl->next_local);
918 919
      tl->shared= table_count++;
      table->no_keyread=1;
920
      table->used_keys.clear_all();
921
      table->pos_in_table_list= tl;
922 923
    }
  }
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
924 925


926 927 928
  table_count=  update.elements;
  update_tables= (TABLE_LIST*) update.first;

929
  tmp_tables = (TABLE**) thd->calloc(sizeof(TABLE *) * table_count);
930 931 932 933 934 935
  tmp_table_param = (TMP_TABLE_PARAM*) thd->calloc(sizeof(TMP_TABLE_PARAM) *
						   table_count);
  fields_for_table= (List_item **) thd->alloc(sizeof(List_item *) *
					      table_count);
  values_for_table= (List_item **) thd->alloc(sizeof(List_item *) *
					      table_count);
936
  if (thd->is_fatal_error)
937 938 939 940 941 942
    DBUG_RETURN(1);
  for (i=0 ; i < table_count ; i++)
  {
    fields_for_table[i]= new List_item;
    values_for_table[i]= new List_item;
  }
943
  if (thd->is_fatal_error)
944 945 946 947 948 949 950 951 952 953 954
    DBUG_RETURN(1);

  /* Split fields into fields_for_table[] and values_by_table[] */

  while ((item= (Item_field *) field_it++))
  {
    Item *value= value_it++;
    uint offset= item->field->table->pos_in_table_list->shared;
    fields_for_table[offset]->push_back(item);
    values_for_table[offset]->push_back(value);
  }
955
  if (thd->is_fatal_error)
956 957 958 959 960 961 962
    DBUG_RETURN(1);

  /* Allocate copy fields */
  max_fields=0;
  for (i=0 ; i < table_count ; i++)
    set_if_bigger(max_fields, fields_for_table[i]->elements);
  copy_field= new Copy_field[max_fields];
963 964 965 966 967 968 969 970 971 972 973 974 975

  /*
    Mark all copies of tables that are updates to ensure that
    init_read_record() will not try to enable a cache on them

    The problem is that for queries like

    UPDATE t1, t1 AS t2 SET t1.b=t2.c WHERE t1.a=t2.a;

    the row buffer may contain things that doesn't match what is on disk
    which will cause an error when reading a row.
    (This issue is mostly relevent for MyISAM tables)
  */
976
  for (table_ref= leaves;  table_ref; table_ref= table_ref->next_leaf)
977 978
  {
    TABLE *table=table_ref->table;
979
    if (!(tables_to_update & table->map) &&
980
	find_table_in_local_list(update_tables, table_ref->db,
981
				table_ref->table_name))
982 983
      table->no_cache= 1;			// Disable row cache
  }
984
  DBUG_RETURN(thd->is_fatal_error != 0);
985 986 987
}


988
/*
989
  Initialize table for multi table
990

991 992 993 994
  IMPLEMENTATION
    - Update first table in join on the fly, if possible
    - Create temporary tables to store changed values for all other tables
      that are updated (and main_table if the above doesn't hold).
995 996 997
*/

bool
998 999
multi_update::initialize_tables(JOIN *join)
{
1000 1001 1002 1003 1004 1005 1006
  TABLE_LIST *table_ref;
  DBUG_ENTER("initialize_tables");

  if ((thd->options & OPTION_SAFE_UPDATES) && error_if_full_join(join))
    DBUG_RETURN(1);
  main_table=join->join_tab->table;
  trans_safe= transactional_tables= main_table->file->has_transactions();
1007 1008 1009
  table_to_update= 0;

  /* Create a temporary table for keys to all tables, except main table */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1010
  for (table_ref= update_tables; table_ref; table_ref= table_ref->next_local)
1011
  {
1012
    TABLE *table=table_ref->table;
1013
    uint cnt= table_ref->shared;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1014
    Item_field *ifield;
1015 1016
    List<Item> temp_fields= *fields_for_table[cnt];
    ORDER     group;
1017

1018 1019 1020 1021 1022 1023 1024
    if (table == main_table)			// First table in join
    {
      if (safe_update_on_fly(join->join_tab, &temp_fields))
      {
	table_to_update= main_table;		// Update table on the fly
	continue;
      }
1025
    }
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036

    TMP_TABLE_PARAM *tmp_param= tmp_table_param+cnt;

    /*
      Create a temporary table to store all fields that are changed for this
      table. The first field in the temporary table is a pointer to the
      original row so that we can find and update it
    */

    /* ok to be on stack as this is not referenced outside of this func */
    Field_string offset(table->file->ref_length, 0, "offset",
1037
			table, &my_charset_bin);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1038
    if (!(ifield= new Item_field(((Field *) &offset))))
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
1039
      DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1040 1041
    ifield->maybe_null= 0;
    if (temp_fields.push_front(ifield))
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
      DBUG_RETURN(1);

    /* Make an unique key over the first field to avoid duplicated updates */
    bzero((char*) &group, sizeof(group));
    group.asc= 1;
    group.item= (Item**) temp_fields.head_ref();

    tmp_param->quick_group=1;
    tmp_param->field_count=temp_fields.elements;
    tmp_param->group_parts=1;
    tmp_param->group_length= table->file->ref_length;
    if (!(tmp_tables[cnt]=create_tmp_table(thd,
					   tmp_param,
					   temp_fields,
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1056 1057
					   (ORDER*) &group, 0, 0,
					   TMP_TABLE_ALL_COLUMNS,
1058 1059
					   HA_POS_ERROR,
					   (char *) "")))
1060 1061
      DBUG_RETURN(1);
    tmp_tables[cnt]->file->extra(HA_EXTRA_WRITE_CACHE);
1062
  }
1063
  DBUG_RETURN(0);
1064 1065
}

1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
/*
  Check if table is safe to update on fly

  SYNOPSIS
    safe_update_on_fly
    join_tab		How table is used in join
    fields		Fields that are updated

  NOTES
    We can update the first table in join on the fly if we know that
    a row in this tabel will never be read twice. This is true under
    the folloing conditions:

    - We are doing a table scan and the data is in a separate file (MyISAM) or
      if we don't update a clustered key.

    - We are doing a range scan and we don't update the scan key or
      the primary key for a clustered table handler.

  WARNING
    This code is a bit dependent of how make_join_readinfo() works.

  RETURN
    0		Not safe to update
    1		Safe to update
*/

static bool safe_update_on_fly(JOIN_TAB *join_tab, List<Item> *fields)
{
  TABLE *table= join_tab->table;
  switch (join_tab->type) {
  case JT_SYSTEM:
  case JT_CONST:
  case JT_EQ_REF:
1100
    return TRUE;				// At most one matching row
1101
  case JT_REF:
monty@mysql.com's avatar
monty@mysql.com committed
1102
  case JT_REF_OR_NULL:
1103 1104 1105 1106
    return !check_if_key_used(table, join_tab->ref.key, *fields);
  case JT_ALL:
    /* If range search on index */
    if (join_tab->quick)
1107
      return !join_tab->quick->check_if_keys_used(fields);
1108 1109
    /* If scanning in clustered key */
    if ((table->file->table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
1110 1111
	table->s->primary_key < MAX_KEY)
      return !check_if_key_used(table, table->s->primary_key, *fields);
1112
    return TRUE;
1113 1114 1115
  default:
    break;					// Avoid compler warning
  }
1116
  return FALSE;
1117 1118
}

1119 1120 1121

multi_update::~multi_update()
{
1122
  TABLE_LIST *table;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1123
  for (table= update_tables ; table; table= table->next_local)
1124
    table->table->no_keyread= table->table->no_cache= 0;
1125

1126 1127
  if (tmp_tables)
  {
1128 1129 1130 1131 1132 1133 1134 1135
    for (uint cnt = 0; cnt < table_count; cnt++)
    {
      if (tmp_tables[cnt])
      {
	free_tmp_table(thd, tmp_tables[cnt]);
	tmp_table_param[cnt].cleanup();
      }
    }
1136
  }
1137 1138
  if (copy_field)
    delete [] copy_field;
1139
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;		// Restore this setting
1140 1141
  if (!trans_safe)
    thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
1142 1143 1144
}


1145
bool multi_update::send_data(List<Item> &not_used_values)
1146
{
1147 1148 1149
  TABLE_LIST *cur_table;
  DBUG_ENTER("multi_update::send_data");

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1150
  for (cur_table= update_tables; cur_table; cur_table= cur_table->next_local)
1151
  {
1152
    TABLE *table= cur_table->table;
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
    /*
      Check if we are using outer join and we didn't find the row
      or if we have already updated this row in the previous call to this
      function.

      The same row may be presented here several times in a join of type
      UPDATE t1 FROM t1,t2 SET t1.a=t2.a

      In this case we will do the update for the first found row combination.
      The join algorithm guarantees that we will not find the a row in
      t1 several times.
    */
1165 1166 1167 1168 1169
    if (table->status & (STATUS_NULL_ROW | STATUS_UPDATED))
      continue;

    uint offset= cur_table->shared;
    table->file->position(table->record[0]);
1170
    if (table == table_to_update)
1171 1172
    {
      table->status|= STATUS_UPDATED;
1173
      store_record(table,record[1]);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1174 1175
      if (fill_record(thd, *fields_for_table[offset],
                      *values_for_table[offset], 0))
1176
	DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1177

1178
      found++;
1179
      if (compare_record(table, thd->query_id))
1180
      {
1181
	int error;
monty@mysql.com's avatar
monty@mysql.com committed
1182
        if ((error= cur_table->view_check_option(thd, ignore)) !=
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1183 1184 1185 1186 1187 1188 1189 1190
            VIEW_CHECK_OK)
        {
          found--;
          if (error == VIEW_CHECK_SKIP)
            continue;
          else if (error == VIEW_CHECK_ERROR)
            DBUG_RETURN(1);
        }
1191
	if (!updated++)
1192
	{
1193 1194 1195 1196 1197 1198
	  /*
	    Inform the main table that we are going to update the table even
	    while we may be scanning it.  This will flush the read cache
	    if it's used.
	  */
	  main_table->file->extra(HA_EXTRA_PREPARE_FOR_UPDATE);
1199
	}
1200 1201
	if ((error=table->file->update_row(table->record[1],
					   table->record[0])))
1202
	{
1203
	  updated--;
1204
          if (!ignore || error != HA_ERR_FOUND_DUPP_KEY)
1205
	  {
monty@mysql.com's avatar
monty@mysql.com committed
1206
            thd->fatal_error();                 // Force error message
1207 1208 1209
	    table->file->print_error(error,MYF(0));
	    DBUG_RETURN(1);
	  }
1210
	}
monty@mysql.com's avatar
monty@mysql.com committed
1211
        else if (!table->file->has_transactions())
1212
          thd->no_trans_update= 1;
1213
      }
1214 1215 1216 1217 1218
    }
    else
    {
      int error;
      TABLE *tmp_table= tmp_tables[offset];
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1219
      fill_record(thd, tmp_table->field+1, *values_for_table[offset], 1);
1220
      found++;
1221 1222 1223 1224 1225 1226 1227
      /* Store pointer to row */
      memcpy((char*) tmp_table->field[0]->ptr,
	     (char*) table->file->ref, table->file->ref_length);
      /* Write row, ignoring duplicated updates to a row */
      if ((error= tmp_table->file->write_row(tmp_table->record[0])) &&
	  (error != HA_ERR_FOUND_DUPP_KEY &&
	   error != HA_ERR_FOUND_DUPP_UNIQUE))
1228
      {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1229
	if (create_myisam_from_heap(thd, tmp_table, tmp_table_param + offset,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1230
				    error, 1))
1231
	{
1232 1233
	  do_update=0;
	  DBUG_RETURN(1);			// Not a table_is_full error
1234 1235 1236 1237
	}
      }
    }
  }
1238
  DBUG_RETURN(0);
1239 1240
}

1241

1242 1243 1244
void multi_update::send_error(uint errcode,const char *err)
{
  /* First send error what ever it is ... */
1245
  my_error(errcode, MYF(0), err);
1246 1247 1248 1249

  /* If nothing updated return */
  if (!updated)
    return;
1250

1251
  /* Something already updated so we have to invalidate cache */
1252 1253
  query_cache_invalidate3(thd, update_tables, 1);

1254
  /*
1255 1256
    If all tables that has been updated are trans safe then just do rollback.
    If not attempt to do remaining updates.
1257
  */
1258 1259

  if (trans_safe)
1260
    ha_rollback_stmt(thd);
1261 1262 1263 1264 1265
  else if (do_update && table_count > 1)
  {
    /* Add warning here */
    VOID(do_updates(0));
  }
1266 1267 1268
}


1269
int multi_update::do_updates(bool from_send_error)
1270
{
1271 1272 1273
  TABLE_LIST *cur_table;
  int local_error;
  ha_rows org_updated;
1274
  TABLE *table, *tmp_table;
1275 1276
  DBUG_ENTER("do_updates");

1277
  do_update= 0;					// Don't retry this function
1278
  if (!found)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1279
    DBUG_RETURN(0);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1280
  for (cur_table= update_tables; cur_table; cur_table= cur_table->next_local)
1281
  {
1282
    byte *ref_pos;
1283

1284
    table = cur_table->table;
1285
    if (table == table_to_update)
1286 1287
      continue;					// Already updated
    org_updated= updated;
1288
    tmp_table= tmp_tables[cur_table->shared];
1289
    tmp_table->file->extra(HA_EXTRA_CACHE);	// Change to read cache
1290
    (void) table->file->ha_rnd_init(0);
1291 1292 1293 1294 1295 1296 1297 1298 1299
    table->file->extra(HA_EXTRA_NO_CACHE);

    /*
      Setup copy functions to copy fields from temporary table
    */
    List_iterator_fast<Item> field_it(*fields_for_table[cur_table->shared]);
    Field **field= tmp_table->field+1;		// Skip row pointer
    Copy_field *copy_field_ptr= copy_field, *copy_field_end;
    for ( ; *field ; field++)
1300
    {
1301 1302
      Item_field *item= (Item_field* ) field_it++;
      (copy_field_ptr++)->set(item->field, *field, 0);
1303
    }
1304 1305
    copy_field_end=copy_field_ptr;

1306
    if ((local_error = tmp_table->file->ha_rnd_init(1)))
1307 1308 1309 1310
      goto err;

    ref_pos= (byte*) tmp_table->field[0]->ptr;
    for (;;)
1311
    {
1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
      if (thd->killed && trans_safe)
	goto err;
      if ((local_error=tmp_table->file->rnd_next(tmp_table->record[0])))
      {
	if (local_error == HA_ERR_END_OF_FILE)
	  break;
	if (local_error == HA_ERR_RECORD_DELETED)
	  continue;				// May happen on dup key
	goto err;
      }
      if ((local_error= table->file->rnd_pos(table->record[0], ref_pos)))
	goto err;
1324
      table->status|= STATUS_UPDATED;
1325
      store_record(table,record[1]);
1326 1327 1328 1329 1330 1331 1332 1333

      /* Copy data from temporary table to current table */
      for (copy_field_ptr=copy_field;
	   copy_field_ptr != copy_field_end;
	   copy_field_ptr++)
	(*copy_field_ptr->do_copy)(copy_field_ptr);

      if (compare_record(table, thd->query_id))
1334
      {
1335 1336 1337
	if ((local_error=table->file->update_row(table->record[1],
						 table->record[0])))
	{
1338
	  if (!ignore || local_error != HA_ERR_FOUND_DUPP_KEY)
1339 1340 1341
	    goto err;
	}
	updated++;
1342
      }
1343 1344 1345 1346 1347
    }

    if (updated != org_updated)
    {
      if (table->file->has_transactions())
1348
	transactional_tables= 1;
1349
      else
1350
	trans_safe= 0;				// Can't do safe rollback
1351
    }
1352 1353
    (void) table->file->ha_rnd_end();
    (void) tmp_table->file->ha_rnd_end();
1354
  }
1355 1356 1357 1358
  DBUG_RETURN(0);

err:
  if (!from_send_error)
monty@mysql.com's avatar
monty@mysql.com committed
1359 1360
  {
    thd->fatal_error();
1361
    table->file->print_error(local_error,MYF(0));
monty@mysql.com's avatar
monty@mysql.com committed
1362
  }
1363

1364 1365 1366
  (void) table->file->ha_rnd_end();
  (void) tmp_table->file->ha_rnd_end();

1367 1368 1369
  if (updated != org_updated)
  {
    if (table->file->has_transactions())
1370
      transactional_tables= 1;
1371 1372 1373 1374
    else
      trans_safe= 0;
  }
  DBUG_RETURN(1);
1375 1376 1377
}


monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1378 1379
/* out: 1 if error, 0 if success */

1380 1381
bool multi_update::send_eof()
{
1382
  char buff[STRING_BUFFER_USUAL_SIZE];
1383
  thd->proc_info="updating reference tables";
1384 1385

  /* Does updates for the last n - 1 tables, returns 0 if ok */
1386
  int local_error = (table_count) ? do_updates(0) : 0;
1387
  thd->proc_info= "end";
1388

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1389 1390 1391 1392 1393 1394 1395 1396
  /* We must invalidate the query cache before binlog writing and
  ha_autocommit_... */

  if (updated)
  {
    query_cache_invalidate3(thd, update_tables, 1);
  }

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1397 1398
  /*
    Write the SQL statement to the binlog if we updated
1399
    rows and we succeeded or if we updated some non
1400 1401 1402
    transacational tables.
    Note that if we updated nothing we don't write to the binlog (TODO:
    fix this).
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1403
  */
1404

1405
  if (updated && (local_error <= 0 || !trans_safe))
1406
  {
1407 1408
    if (mysql_bin_log.is_open())
    {
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1409 1410
      if (local_error <= 0)
        thd->clear_error();
1411
      Query_log_event qinfo(thd, thd->query, thd->query_length,
1412
			    transactional_tables, FALSE);
1413
      if (mysql_bin_log.write(&qinfo) && trans_safe)
1414
	local_error= 1;				// Rollback update
1415
    }
1416
    if (!transactional_tables)
1417 1418
      thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
  }
1419

1420 1421
  if (transactional_tables)
  {
1422
    if (ha_autocommit_or_rollback(thd, local_error != 0))
1423 1424
      local_error=1;
  }
1425

1426 1427 1428 1429 1430
  if (local_error > 0) // if the above log write did not fail ...
  {
    /* Safety: If we haven't got an error before (should not happen) */
    my_message(ER_UNKNOWN_ERROR, "An error occured in multi-table update",
	       MYF(0));
1431
    return TRUE;
1432
  }
1433 1434


1435 1436
  sprintf(buff, ER(ER_UPDATE_INFO), (ulong) found, (ulong) updated,
	  (ulong) thd->cuted_fields);
1437 1438
  thd->row_count_func=
    (thd->client_capabilities & CLIENT_FOUND_ROWS) ? found : updated;
1439
  ::send_ok(thd, (ulong) thd->row_count_func,
1440
	    thd->insert_id_used ? thd->insert_id() : 0L,buff);
1441
  return FALSE;
1442
}