sql_update.cc 31.9 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 24

#include "mysql_priv.h"
#include "sql_acl.h"
25
#include "sql_select.h"
bk@work.mysql.com's avatar
bk@work.mysql.com committed
26

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

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

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


51 52 53 54 55
int mysql_update(THD *thd,
                 TABLE_LIST *table_list,
                 List<Item> &fields,
		 List<Item> &values,
                 COND *conds,
56
                 uint order_num, ORDER *order,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
57
		 ha_rows limit,
58
		 enum enum_duplicates handle_duplicates)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
59
{
60 61
  bool 		using_limit=limit != HA_POS_ERROR;
  bool		safe_update= thd->options & OPTION_SAFE_UPDATES;
62
  bool		used_key_is_modified, transactional_table, log_delayed;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
63
  int		error=0;
64 65 66 67
  uint		used_index;
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  uint		want_privilege;
#endif
68
  ulong		query_id=thd->query_id, timestamp_query_id;
69
  ha_rows	updated, found;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
70 71 72 73
  key_map	old_used_keys;
  TABLE		*table;
  SQL_SELECT	*select;
  READ_RECORD	info;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
74
  TABLE_LIST    *update_table_list= ((TABLE_LIST*) 
75
				     thd->lex->select_lex.table_list.first);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
76
  DBUG_ENTER("mysql_update");
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
77

bk@work.mysql.com's avatar
bk@work.mysql.com committed
78
  LINT_INIT(used_index);
79
  LINT_INIT(timestamp_query_id);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
80

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
81
  if ((open_and_lock_tables(thd, table_list)))
82
    DBUG_RETURN(-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
83
  thd->proc_info="init";
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
84
  table= table_list->table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
85 86
  table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);

87 88
  /* Calculate "table->used_keys" based on the WHERE */
  table->used_keys=table->keys_in_use;
89
  table->quick_keys.clear_all();
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
90

hf@deer.(none)'s avatar
hf@deer.(none) committed
91
#ifndef NO_EMBEDDED_ACCESS_CHECKS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
92
  want_privilege= table->grant.want_privilege;
hf@deer.(none)'s avatar
hf@deer.(none) committed
93
#endif
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
94 95 96
  if ((error= mysql_prepare_update(thd, table_list, update_table_list,
				   &conds, order_num, order)))
    DBUG_RETURN(error);
97

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
98
  old_used_keys= table->used_keys;		// Keys used in WHERE
bk@work.mysql.com's avatar
bk@work.mysql.com committed
99
  /*
100 101
    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
102
  */
103 104 105 106 107
  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
108

109
  /* Check the fields we are going to modify */
hf@deer.(none)'s avatar
hf@deer.(none) committed
110
#ifndef NO_EMBEDDED_ACCESS_CHECKS
111
  table->grant.want_privilege=want_privilege;
hf@deer.(none)'s avatar
hf@deer.(none) committed
112
#endif
113
  if (setup_fields(thd, 0, update_table_list, fields, 1, 0, 0))
114 115 116 117 118
    DBUG_RETURN(-1);				/* purecov: inspected */
  if (table->timestamp_field)
  {
    // Don't set timestamp column if this is modified
    if (table->timestamp_field->query_id == thd->query_id)
119
      table->timestamp_on_update_now= 0;
120 121 122
    else
      table->timestamp_field->query_id=timestamp_query_id;
  }
123

hf@deer.(none)'s avatar
hf@deer.(none) committed
124
#ifndef NO_EMBEDDED_ACCESS_CHECKS
125 126
  /* Check values */
  table->grant.want_privilege=(SELECT_ACL & ~table->grant.privilege);
hf@deer.(none)'s avatar
hf@deer.(none) committed
127
#endif
128
  if (setup_fields(thd, 0, update_table_list, values, 0, 0, 0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
129
  {
130
    free_underlaid_joins(thd, &thd->lex->select_lex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
131 132
    DBUG_RETURN(-1);				/* purecov: inspected */
  }
133

134
  // Don't count on usage of 'only index' when calculating which key to use
135
  table->used_keys.clear_all();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
136 137
  select=make_select(table,0,0,conds,&error);
  if (error ||
138
      (select && select->check_quick(thd, safe_update, limit)) || !limit)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
139 140
  {
    delete select;
141
    free_underlaid_joins(thd, &thd->lex->select_lex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
142 143 144 145
    if (error)
    {
      DBUG_RETURN(-1);				// Error in where
    }
146
    send_ok(thd);				// No matching records
bk@work.mysql.com's avatar
bk@work.mysql.com committed
147 148 149
    DBUG_RETURN(0);
  }
  /* If running in safe sql mode, don't allow updates without keys */
150
  if (table->quick_keys.is_clear_all())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
151
  {
152
    thd->server_status|=SERVER_QUERY_NO_INDEX_USED;
153
    if (safe_update && !using_limit)
154
    {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
155 156 157
      my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
		 ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
      goto err;
158
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
159
  }
160
  init_ftfuncs(thd, &thd->lex->select_lex, 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
161 162 163 164 165 166 167 168 169 170
  /* Check if we are modifying a key that we are used to search with */
  if (select && select->quick)
    used_key_is_modified= (!select->quick->unique_key_range() &&
			   check_if_key_used(table,
					     (used_index=select->quick->index),
					     fields));
  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;
171
  if (used_key_is_modified || order)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
172 173
  {
    /*
174 175
      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
176
    */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
177
    table->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
178
    if (old_used_keys.is_set(used_index))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
179 180 181 182
    {
      table->key_read=1;
      table->file->extra(HA_EXTRA_KEYREAD);
    }
183 184 185

    if (order)
    {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
186 187 188 189
      /*
	Doing an ORDER BY;  Let filesort find and sort the rows we are going
	to update
      */
190 191
      uint         length;
      SORT_FIELD  *sortorder;
192
      ha_rows examined_rows;
193

igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
194
      table->sort.io_cache = (IO_CACHE *) my_malloc(sizeof(IO_CACHE),
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
195
						    MYF(MY_FAE | MY_ZEROFILL));
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
196
      if (!(sortorder=make_unireg_sortorder(order, &length)) ||
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
197
          (table->sort.found_records = filesort(thd, table, sortorder, length,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
198
						select, limit,
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
199
						&examined_rows))
200 201
          == HA_POS_ERROR)
      {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
202
	free_io_cache(table);
203
	goto err;
204
      }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
205 206 207 208 209 210
      /*
	Filesort has already found and selected the rows we want to update,
	so we don't need the where clause
      */
      delete select;
      select= 0;
211
    }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
212
    else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
213
    {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
214 215 216 217 218 219 220 221 222
      /*
	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)))
223
	goto err;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
224 225 226 227

      init_read_record(&info,thd,table,select,0,1);
      thd->proc_info="Searching rows for update";
      uint tmp_limit= limit;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
228

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
229
      while (!(error=info.read_record(&info)) && !thd->killed)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
230
      {
231
	if (!(select && select->skip_record()))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
232
	{
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
233 234 235 236 237 238 239 240
	  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)
241 242
	  {
	    error= -1;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
243
	    break;
244
	  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
245 246
	}
      }
247 248
      if (thd->killed && !error)
	error= 1;				// Aborted
249
      limit= tmp_limit;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
250 251 252 253 254 255 256 257 258 259
      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
260 261
      else
      {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
262 263
	select= new SQL_SELECT;
	select->head=table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
264
      }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
265 266 267 268
      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)
269
	goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
270 271 272 273 274 275 276 277
    }
    if (table->key_read)
    {
      table->key_read=0;
      table->file->extra(HA_EXTRA_NO_KEYREAD);
    }
  }

monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
278 279
  if (handle_duplicates == DUP_IGNORE)
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
280 281
  init_read_record(&info,thd,table,select,0,1);

282
  updated= found= 0;
283
  thd->count_cuted_fields= CHECK_FIELD_WARN;		/* calc cuted fields */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
284
  thd->cuted_fields=0L;
285
  thd->proc_info="Updating";
286
  query_id=thd->query_id;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
287 288 289

  while (!(error=info.read_record(&info)) && !thd->killed)
  {
290
    if (!(select && select->skip_record()))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
291
    {
292
      store_record(table,record[1]);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
293
      if (fill_record(fields,values, 0) || thd->net.report_error)
294
	break; /* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
295
      found++;
296
      if (compare_record(table, query_id))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
297 298 299 300 301 302 303 304 305 306 307 308 309 310
      {
	if (!(error=table->file->update_row((byte*) table->record[1],
					    (byte*) table->record[0])))
	{
	  updated++;
	}
	else if (handle_duplicates != DUP_IGNORE ||
		 error != HA_ERR_FOUND_DUPP_KEY)
	{
	  table->file->print_error(error,MYF(0));
	  error= 1;
	  break;
	}
      }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
311 312 313 314 315
      if (!--limit && using_limit)
      {
	error= -1;				// Simulate end of file
	break;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
316
    }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
317 318
    else
      table->file->unlock_row();
319
    thd->row_count++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
320
  }
321 322
  if (thd->killed && !error)
    error= 1;					// Aborted
bk@work.mysql.com's avatar
bk@work.mysql.com committed
323
  end_read_record(&info);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
324
  free_io_cache(table);				// If ORDER BY
325
  delete select;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
326
  thd->proc_info="end";
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
327
  VOID(table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY));
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
328 329 330 331 332 333 334 335

  /*
    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);

336 337
  transactional_table= table->file->has_transactions();
  log_delayed= (transactional_table || table->tmp_table);
338
  if ((updated || (error < 0)) && (error <= 0 || !transactional_table))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
339
  {
340 341 342
    mysql_update_log.write(thd,thd->query,thd->query_length);
    if (mysql_bin_log.is_open())
    {
guilhem@mysql.com's avatar
guilhem@mysql.com committed
343 344
      if (error <= 0)
        thd->clear_error();
345
      Query_log_event qinfo(thd, thd->query, thd->query_length,
346 347 348
			    log_delayed);
      if (mysql_bin_log.write(&qinfo) && transactional_table)
	error=1;				// Rollback update
349
    }
350
    if (!log_delayed)
351
      thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
352
  }
353 354 355 356 357
  if (transactional_table)
  {
    if (ha_autocommit_or_rollback(thd, error >= 0))
      error=1;
  }
358

359 360 361 362 363 364
  if (thd->lock)
  {
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
  }

365
  free_underlaid_joins(thd, &thd->lex->select_lex);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
366
  if (error >= 0)
367
    send_error(thd,thd->killed ? ER_SERVER_SHUTDOWN : 0); /* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
368 369 370
  else
  {
    char buff[80];
371 372
    sprintf(buff, ER(ER_UPDATE_INFO), (ulong) found, (ulong) updated,
	    (ulong) thd->cuted_fields);
373
    send_ok(thd,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
374 375 376 377
	    (thd->client_capabilities & CLIENT_FOUND_ROWS) ? found : updated,
	    thd->insert_id_used ? thd->insert_id() : 0L,buff);
    DBUG_PRINT("info",("%d records updated",updated));
  }
378
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;		/* calc cuted fields */
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
379
  free_io_cache(table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
380
  DBUG_RETURN(0);
381 382 383

err:
  delete select;
384
  free_underlaid_joins(thd, &thd->lex->select_lex);
385 386 387 388 389 390
  if (table->key_read)
  {
    table->key_read=0;
    table->file->extra(HA_EXTRA_NO_KEYREAD);
  }
  DBUG_RETURN(-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
391
}
392

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
/*
  Prepare items in UPDATE statement

  SYNOPSIS
    mysql_prepare_update()
    thd			- thread handler
    table_list		- global table list
    update_table_list	- local table list of UPDATE SELECT_LEX
    conds		- conditions
    order_num		- number of ORDER BY list entries
    order		- ORDER BY clause list

  RETURN VALUE
    0  - OK
    1  - error (message is sent to user)
    -1 - error (message is not sent to user)
*/
int mysql_prepare_update(THD *thd, TABLE_LIST *table_list,
			 TABLE_LIST *update_table_list,
			 Item **conds, uint order_num, ORDER *order)
{
  TABLE *table= table_list->table;
  TABLE_LIST tables;
  List<Item> all_fields;
  DBUG_ENTER("mysql_prepare_update");

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

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

  if (setup_tables(update_table_list) ||
      setup_conds(thd, update_table_list, conds) ||
      thd->lex->select_lex.setup_ref_array(thd, order_num) ||
      setup_order(thd, thd->lex->select_lex.ref_pointer_array,
		  update_table_list, all_fields, all_fields, order) ||
      setup_ftfuncs(&thd->lex->select_lex))
    DBUG_RETURN(-1);

  /* Check that we are not using table that we are updating in a sub select */
  if (find_real_table_in_list(table_list->next, 
			      table_list->db, table_list->real_name))
  {
    my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->real_name);
    DBUG_RETURN(-1);
  }

  DBUG_RETURN(0);
}

446

447
/***************************************************************************
448
  Update multiple tables from join 
449 450
***************************************************************************/

451 452 453 454 455 456 457 458 459 460
/*
  Setup multi-update handling and call SELECT to do the join
*/

int mysql_multi_update(THD *thd,
		       TABLE_LIST *table_list,
		       List<Item> *fields,
		       List<Item> *values,
		       COND *conds,
		       ulong options,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
461 462
		       enum enum_duplicates handle_duplicates,
		       SELECT_LEX_UNIT *unit, SELECT_LEX *select_lex)
463
{
464 465 466
  int res;
  multi_update *result;
  TABLE_LIST *tl;
467
  TABLE_LIST *update_list= (TABLE_LIST*) thd->lex->select_lex.table_list.first;
monty@mysql.com's avatar
monty@mysql.com committed
468
  table_map item_tables= 0, derived_tables= 0;
469 470
  DBUG_ENTER("mysql_multi_update");

monty@mysql.com's avatar
monty@mysql.com committed
471
 if ((res=open_and_lock_tables(thd,table_list)))
472 473
    DBUG_RETURN(res);

474
  select_lex->select_limit= HA_POS_ERROR;
475

476 477 478 479
  /*
    Ensure that we have update privilege for all tables and columns in the
    SET part
  */
480
  for (tl= update_list; tl; tl= tl->next)
481 482
  {
    TABLE *table= tl->table;
monty@mysql.com's avatar
monty@mysql.com committed
483 484 485 486 487 488 489 490
    /*
      Update of derived tables is checked later
      We don't check privileges here, becasue then we would get error
      "UPDATE command denided .. for column N" instead of
      "Target table ... is not updatable"
    */
    if (!tl->derived)
      table->grant.want_privilege= (UPDATE_ACL & ~table->grant.privilege);
491 492
  }

493
  /* Assign table map values to check updatability of derived tables */
494 495
  {
    uint tablenr=0;
496
    for (TABLE_LIST *table_list= update_list;
497 498 499 500 501 502
	 table_list;
	 table_list= table_list->next, tablenr++)
    {
      table_list->table->map= (table_map) 1 << tablenr;
    }
  }
503

504
  if (setup_fields(thd, 0, update_list, *fields, 1, 0, 0))
505
    DBUG_RETURN(-1);
506 507

  /* Find tables used in items */
508 509 510 511 512 513 514 515
  {
    List_iterator_fast<Item> it(*fields);
    Item *item;
    while ((item= it++))
    {
      item_tables|= item->used_tables();
    }
  }
516 517 518 519

  /*
    Count tables and setup timestamp handling
  */
520
  for (tl= update_list; tl; tl= tl->next)
521
  {
522
    TABLE *table= tl->table;
523 524 525

    /* We only need SELECT privilege for columns in the values list */
    table->grant.want_privilege= (SELECT_ACL & ~table->grant.privilege);
526 527 528 529
    // Only set timestamp column if this is not modified
    if (table->timestamp_field &&
        table->timestamp_field->query_id == thd->query_id)
      table->timestamp_on_update_now= 0;
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546

    /* if table will be updated then check that it is unique */
    if (table->map & item_tables)
    {
      /*
	 Multi-update can't be constructed over-union => we always have
	 single SELECT on top and have to check underlaying SELECTs of it
      */
      if (select_lex->check_updateable_in_subqueries(tl->db,
                                                     tl->real_name))
      {
        my_error(ER_UPDATE_TABLE_USED, MYF(0),
                 tl->real_name);
        DBUG_RETURN(-1);
      }
    }

547 548 549 550 551 552
    if (tl->derived)
      derived_tables|= table->map;
  }
  if (thd->lex->derived_tables && (item_tables & derived_tables))
  {
    // find derived table which cause error
553
    for (tl= update_list; tl; tl= tl->next)
554 555
    {
      if (tl->derived && (item_tables & tl->table->map))
556
      {
557 558
	my_printf_error(ER_NON_UPDATABLE_TABLE, ER(ER_NON_UPDATABLE_TABLE),
			MYF(0), tl->alias, "UPDATE");
559 560
	DBUG_RETURN(-1);
      }
561
    }
562
  }
563

564
  if (!(result=new multi_update(thd, update_list, fields, values,
565 566 567 568
				handle_duplicates)))
    DBUG_RETURN(-1);

  List<Item> total_list;
569
  res= mysql_select(thd, &select_lex->ref_pointer_array,
570 571
		    select_lex->get_table_list(), select_lex->with_wild,
		    total_list,
572
		    conds, 0, (ORDER *) NULL, (ORDER *)NULL, (Item *) NULL,
573
		    (ORDER *)NULL,
lenz@mysql.com's avatar
lenz@mysql.com committed
574
		    options | SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK,
575
		    result, unit, select_lex);
576 577
  delete result;
  DBUG_RETURN(res);
578 579
}

580 581 582 583

multi_update::multi_update(THD *thd_arg, TABLE_LIST *table_list,
			   List<Item> *field_list, List<Item> *value_list,
			   enum enum_duplicates handle_duplicates_arg)
584 585 586
  :all_tables(table_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),
587
   do_update(1), trans_safe(0), transactional_tables(1)
588 589 590 591 592 593 594
{}


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

595 596
int multi_update::prepare(List<Item> &not_used_values,
			  SELECT_LEX_UNIT *lex_unit)
597
{
598
  TABLE_LIST *table_ref;
599 600 601 602 603 604
  SQL_LIST update;
  table_map tables_to_update= 0;
  Item_field *item;
  List_iterator_fast<Item> field_it(*fields);
  List_iterator_fast<Item> value_it(*values);
  uint i, max_fields;
605
  DBUG_ENTER("multi_update::prepare");
606

607
  thd->count_cuted_fields= CHECK_FIELD_WARN;
608
  thd->cuted_fields=0L;
609 610 611 612
  thd->proc_info="updating main table";

  while ((item= (Item_field *) field_it++))
    tables_to_update|= item->used_tables();
613

614
  if (!tables_to_update)
615
  {
616
    my_error(ER_NO_TABLES_USED, MYF(0));
617
    DBUG_RETURN(1);
618
  }
619

620
  /*
621 622
    We have to check values after setup_tables to get used_keys right in
    reference tables
623
  */
624

625
  if (setup_fields(thd, 0, all_tables, *values, 1, 0, 0))
626 627
    DBUG_RETURN(1);

628
  /*
629 630 631
    Save tables beeing updated in update_tables
    update_table->shared is position for table
    Don't use key read on tables that are updated
632
  */
633 634

  update.empty();
635
  for (table_ref= all_tables;  table_ref; table_ref=table_ref->next)
636
  {
637 638
    TABLE *table=table_ref->table;
    if (tables_to_update & table->map)
639
    {
640 641 642
      TABLE_LIST *tl= (TABLE_LIST*) thd->memdup((char*) table_ref,
						sizeof(*tl));
      if (!tl)
643
	DBUG_RETURN(1);
644 645 646
      update.link_in_list((byte*) tl, (byte**) &tl->next);
      tl->shared= table_count++;
      table->no_keyread=1;
647
      table->used_keys.clear_all();
648
      table->pos_in_table_list= tl;
649 650
    }
  }
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
651 652


653 654 655 656 657 658 659 660 661 662
  table_count=  update.elements;
  update_tables= (TABLE_LIST*) update.first;

  tmp_tables = (TABLE **) thd->calloc(sizeof(TABLE *) * table_count);
  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);
663
  if (thd->is_fatal_error)
664 665 666 667 668 669
    DBUG_RETURN(1);
  for (i=0 ; i < table_count ; i++)
  {
    fields_for_table[i]= new List_item;
    values_for_table[i]= new List_item;
  }
670
  if (thd->is_fatal_error)
671 672 673 674 675 676 677 678 679 680 681 682
    DBUG_RETURN(1);

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

  field_it.rewind();
  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);
  }
683
  if (thd->is_fatal_error)
684 685 686 687 688 689 690
    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];
691 692 693 694 695 696 697 698 699 700 701 702 703

  /*
    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)
  */
704
  for (table_ref= all_tables;  table_ref; table_ref=table_ref->next)
705 706
  {
    TABLE *table=table_ref->table;
707
    if (!(tables_to_update & table->map) && 
monty@mysql.com's avatar
monty@mysql.com committed
708 709
	find_real_table_in_list(update_tables, table_ref->db,
				table_ref->real_name))
710 711
      table->no_cache= 1;			// Disable row cache
  }
712
  DBUG_RETURN(thd->is_fatal_error != 0);
713 714 715
}


716
/*
717
  Initialize table for multi table
718

719 720 721 722
  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).
723 724 725
*/

bool
726 727
multi_update::initialize_tables(JOIN *join)
{
728 729 730 731 732 733 734 735
  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();
  log_delayed= trans_safe || main_table->tmp_table != NO_TMP_TABLE;
736 737 738
  table_to_update= 0;

  /* Create a temporary table for keys to all tables, except main table */
739
  for (table_ref= update_tables; table_ref; table_ref=table_ref->next)
740
  {
741
    TABLE *table=table_ref->table;
742
    uint cnt= table_ref->shared;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
743
    Item_field *ifield;
744 745
    List<Item> temp_fields= *fields_for_table[cnt];
    ORDER     group;
746

747 748 749 750 751 752 753
    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;
      }
754
    }
755 756 757 758 759 760 761 762 763 764 765

    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",
766
			table, &my_charset_bin);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
767
    if (!(ifield= new Item_field(((Field *) &offset))))
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
768
      DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
769 770
    ifield->maybe_null= 0;
    if (temp_fields.push_front(ifield))
771 772 773 774 775 776 777 778 779 780 781 782 783 784
      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
785 786
					   (ORDER*) &group, 0, 0,
					   TMP_TABLE_ALL_COLUMNS,
787 788
					   HA_POS_ERROR,
					   (char *) "")))
789 790
      DBUG_RETURN(1);
    tmp_tables[cnt]->file->extra(HA_EXTRA_WRITE_CACHE);
791
  }
792
  DBUG_RETURN(0);
793 794
}

795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847
/*
  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:
    return 1;					// At most one matching row
  case JT_REF:
    return !check_if_key_used(table, join_tab->ref.key, *fields);
  case JT_ALL:
    /* If range search on index */
    if (join_tab->quick)
      return !check_if_key_used(table, join_tab->quick->index,
				*fields);
    /* If scanning in clustered key */
    if ((table->file->table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
	table->primary_key < MAX_KEY)
      return !check_if_key_used(table, table->primary_key, *fields);
    return 1;
  default:
    break;					// Avoid compler warning
  }
  return 0;
}

848 849 850

multi_update::~multi_update()
{
851 852
  TABLE_LIST *table;
  for (table= update_tables ; table; table= table->next)
853
    table->table->no_keyread= table->table->no_cache= 0;
854

855 856
  if (tmp_tables)
  {
857 858 859 860 861 862 863 864
    for (uint cnt = 0; cnt < table_count; cnt++)
    {
      if (tmp_tables[cnt])
      {
	free_tmp_table(thd, tmp_tables[cnt]);
	tmp_table_param[cnt].cleanup();
      }
    }
865
  }
866 867
  if (copy_field)
    delete [] copy_field;
868
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;		// Restore this setting
869 870
  if (!trans_safe)
    thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
871 872 873
}


874
bool multi_update::send_data(List<Item> &not_used_values)
875
{
876 877 878 879
  TABLE_LIST *cur_table;
  DBUG_ENTER("multi_update::send_data");

  for (cur_table= update_tables; cur_table ; cur_table= cur_table->next)
880
  {
881
    TABLE *table= cur_table->table;
882 883 884 885 886 887 888 889 890 891 892 893
    /*
      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.
    */
894 895 896 897 898
    if (table->status & (STATUS_NULL_ROW | STATUS_UPDATED))
      continue;

    uint offset= cur_table->shared;
    table->file->position(table->record[0]);
899
    if (table == table_to_update)
900 901
    {
      table->status|= STATUS_UPDATED;
902
      store_record(table,record[1]);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
903
      if (fill_record(*fields_for_table[offset], *values_for_table[offset], 0))
904
	DBUG_RETURN(1);
905
      found++;
906
      if (compare_record(table, thd->query_id))
907
      {
908 909
	int error;
	if (!updated++)
910
	{
911 912 913 914 915 916
	  /*
	    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);
917
	}
918 919
	if ((error=table->file->update_row(table->record[1],
					   table->record[0])))
920 921
	{
	  table->file->print_error(error,MYF(0));
922 923
	  updated--;
	  DBUG_RETURN(1);
924 925
	}
      }
926 927 928 929 930
    }
    else
    {
      int error;
      TABLE *tmp_table= tmp_tables[offset];
931
      fill_record(tmp_table->field+1, *values_for_table[offset], 1);
932
      found++;
933 934 935 936 937 938 939
      /* 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))
940
      {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
941
	if (create_myisam_from_heap(thd, tmp_table, tmp_table_param + offset,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
942
				    error, 1))
943
	{
944 945
	  do_update=0;
	  DBUG_RETURN(1);			// Not a table_is_full error
946 947 948 949
	}
      }
    }
  }
950
  DBUG_RETURN(0);
951 952
}

953

954 955 956
void multi_update::send_error(uint errcode,const char *err)
{
  /* First send error what ever it is ... */
957
  ::send_error(thd,errcode,err);
958 959 960 961

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

963
  /* Something already updated so we have to invalidate cache */
964 965
  query_cache_invalidate3(thd, update_tables, 1);

966
  /*
967 968
    If all tables that has been updated are trans safe then just do rollback.
    If not attempt to do remaining updates.
969
  */
970 971

  if (trans_safe)
972
    ha_rollback_stmt(thd);
973 974 975 976 977
  else if (do_update && table_count > 1)
  {
    /* Add warning here */
    VOID(do_updates(0));
  }
978 979 980
}


981
int multi_update::do_updates(bool from_send_error)
982
{
983 984 985
  TABLE_LIST *cur_table;
  int local_error;
  ha_rows org_updated;
986
  TABLE *table, *tmp_table;
987 988
  DBUG_ENTER("do_updates");

989 990

  do_update= 0;					// Don't retry this function
991
  if (!found)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
992
    DBUG_RETURN(0);
993
  for (cur_table= update_tables; cur_table ; cur_table= cur_table->next)
994
  {
995
    byte *ref_pos;
996

997
    table = cur_table->table;
998
    if (table == table_to_update)
999 1000
      continue;					// Already updated
    org_updated= updated;
1001
    tmp_table= tmp_tables[cur_table->shared];
1002
    tmp_table->file->extra(HA_EXTRA_CACHE);	// Change to read cache
1003
    (void) table->file->ha_rnd_init(0);
1004 1005 1006 1007 1008 1009 1010 1011 1012
    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++)
1013
    {
1014 1015
      Item_field *item= (Item_field* ) field_it++;
      (copy_field_ptr++)->set(item->field, *field, 0);
1016
    }
1017 1018
    copy_field_end=copy_field_ptr;

1019
    if ((local_error = tmp_table->file->ha_rnd_init(1)))
1020 1021 1022 1023
      goto err;

    ref_pos= (byte*) tmp_table->field[0]->ptr;
    for (;;)
1024
    {
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
      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;
1037
      table->status|= STATUS_UPDATED;
1038
      store_record(table,record[1]);
1039 1040 1041 1042 1043 1044 1045 1046

      /* 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))
1047
      {
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
	if ((local_error=table->file->update_row(table->record[1],
						 table->record[0])))
	{
	  if (local_error != HA_ERR_FOUND_DUPP_KEY ||
	      handle_duplicates != DUP_IGNORE)
	    goto err;
	}
	updated++;
	if (table->tmp_table != NO_TMP_TABLE)
	  log_delayed= 1;
1058
      }
1059 1060 1061 1062 1063 1064 1065 1066
    }

    if (updated != org_updated)
    {
      if (table->tmp_table != NO_TMP_TABLE)
	log_delayed= 1;				// Tmp tables forces delay log
      if (table->file->has_transactions())
	log_delayed= transactional_tables= 1;
1067
      else
1068
	trans_safe= 0;				// Can't do safe rollback
1069
    }
1070 1071
    (void) table->file->ha_rnd_end();
    (void) tmp_table->file->ha_rnd_end();
1072
  }
1073 1074 1075 1076 1077 1078
  DBUG_RETURN(0);

err:
  if (!from_send_error)
    table->file->print_error(local_error,MYF(0));

1079 1080 1081
  (void) table->file->ha_rnd_end();
  (void) tmp_table->file->ha_rnd_end();

1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
  if (updated != org_updated)
  {
    if (table->tmp_table != NO_TMP_TABLE)
      log_delayed= 1;
    if (table->file->has_transactions())
      log_delayed= transactional_tables= 1;
    else
      trans_safe= 0;
  }
  DBUG_RETURN(1);
1092 1093 1094
}


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

1097 1098
bool multi_update::send_eof()
{
1099 1100
  char buff[80];
  thd->proc_info="updating reference tables";
1101 1102

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

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1106 1107 1108 1109 1110 1111 1112 1113
  /* 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
1114 1115
  /*
    Write the SQL statement to the binlog if we updated
1116
    rows and we succeeded or if we updated some non
1117 1118 1119
    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
1120
  */
1121

1122
  if (updated && (local_error <= 0 || !trans_safe))
1123 1124
  {
    mysql_update_log.write(thd,thd->query,thd->query_length);
1125 1126
    if (mysql_bin_log.is_open())
    {
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1127 1128
      if (local_error <= 0)
        thd->clear_error();
1129 1130 1131
      Query_log_event qinfo(thd, thd->query, thd->query_length,
			    log_delayed);
      if (mysql_bin_log.write(&qinfo) && trans_safe)
1132
	local_error= 1;				// Rollback update
1133 1134 1135 1136
    }
    if (!log_delayed)
      thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
  }
1137

1138 1139
  if (transactional_tables)
  {
1140
    if (ha_autocommit_or_rollback(thd, local_error != 0))
1141 1142
      local_error=1;
  }
1143

1144 1145 1146 1147 1148
  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));
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1149
    ::send_error(thd);
1150
    return 1;
1151
  }
1152 1153


1154 1155
  sprintf(buff, ER(ER_UPDATE_INFO), (ulong) found, (ulong) updated,
	  (ulong) thd->cuted_fields);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1156
  ::send_ok(thd,
1157 1158
	    (thd->client_capabilities & CLIENT_FOUND_ROWS) ? found : updated,
	    thd->insert_id_used ? thd->insert_id() : 0L,buff);
1159 1160
  return 0;
}