sql_update.cc 28.5 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
2

unknown's avatar
unknown 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

unknown's avatar
unknown 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

unknown's avatar
unknown 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
/* Update of records 
   Multi-table updates were introduced by Monty and Sinisa <sinisa@mysql.com>
*/
unknown's avatar
unknown committed
21 22 23

#include "mysql_priv.h"
#include "sql_acl.h"
24
#include "sql_select.h"
unknown's avatar
unknown committed
25

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

unknown's avatar
unknown committed
28 29
/* Return 0 if row hasn't changed */

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


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

unknown's avatar
unknown committed
76
  LINT_INIT(used_index);
unknown's avatar
unknown committed
77
  LINT_INIT(timestamp_query_id);
unknown's avatar
unknown committed
78

unknown's avatar
unknown committed
79
  if ((open_and_lock_tables(thd, table_list)))
80
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
81
  thd->proc_info="init";
unknown's avatar
unknown committed
82
  fix_tables_pointers(thd->lex->all_selects_list);
unknown's avatar
unknown committed
83
  table= table_list->table;
unknown's avatar
unknown committed
84 85
  table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);

86 87
  /* Calculate "table->used_keys" based on the WHERE */
  table->used_keys=table->keys_in_use;
88
  table->quick_keys.clear_all();
unknown's avatar
unknown committed
89
#ifndef NO_EMBEDDED_ACCESS_CHECKS
90 91
  want_privilege=table->grant.want_privilege;
  table->grant.want_privilege=(SELECT_ACL & ~table->grant.privilege);
unknown's avatar
unknown committed
92
#endif
unknown's avatar
unknown committed
93 94

  bzero((char*) &tables,sizeof(tables));	// For ORDER BY
unknown's avatar
unknown committed
95
  tables.table= table;
unknown's avatar
unknown committed
96
  tables.alias= table_list->alias;
unknown's avatar
unknown committed
97 98 99

  if (setup_tables(update_table_list) ||
      setup_conds(thd,update_table_list,&conds) ||
unknown's avatar
unknown committed
100
      thd->lex->select_lex.setup_ref_array(thd, order_num) ||
unknown's avatar
unknown committed
101
      setup_order(thd, thd->lex->select_lex.ref_pointer_array,
unknown's avatar
unknown committed
102
		  &tables, all_fields, all_fields, order) ||
unknown's avatar
unknown committed
103
      setup_ftfuncs(&thd->lex->select_lex))
104 105
    DBUG_RETURN(-1);				/* purecov: inspected */

unknown's avatar
unknown committed
106
  /* Check that we are not using table that we are updating in a sub select */
107 108 109
  if (find_real_table_in_list(table_list->next, 
			      table_list->db, table_list->real_name))
  {
unknown's avatar
unknown committed
110
    my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->real_name);
111 112 113
    DBUG_RETURN(-1);
  }

unknown's avatar
unknown committed
114
  old_used_keys= table->used_keys;		// Keys used in WHERE
unknown's avatar
unknown committed
115
  /*
116 117
    Change the query_id for the timestamp column so that we can
    check if this is modified directly
unknown's avatar
unknown committed
118
  */
119 120 121 122
  if (table->timestamp_field)
  {
    timestamp_query_id=table->timestamp_field->query_id;
    table->timestamp_field->query_id=thd->query_id-1;
unknown's avatar
unknown committed
123
    table->time_stamp= table->timestamp_field->offset() +1;
124
  }
unknown's avatar
unknown committed
125

126
  /* Check the fields we are going to modify */
unknown's avatar
unknown committed
127
#ifndef NO_EMBEDDED_ACCESS_CHECKS
128
  table->grant.want_privilege=want_privilege;
unknown's avatar
unknown committed
129
#endif
130
  if (setup_fields(thd, 0, update_table_list, fields, 1, 0, 0))
131 132 133 134 135 136 137 138 139
    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)
      table->time_stamp=0;
    else
      table->timestamp_field->query_id=timestamp_query_id;
  }
140

unknown's avatar
unknown committed
141
#ifndef NO_EMBEDDED_ACCESS_CHECKS
142 143
  /* Check values */
  table->grant.want_privilege=(SELECT_ACL & ~table->grant.privilege);
unknown's avatar
unknown committed
144
#endif
145
  if (setup_fields(thd, 0, update_table_list, values, 0, 0, 0))
unknown's avatar
unknown committed
146
  {
unknown's avatar
unknown committed
147
    free_underlaid_joins(thd, &thd->lex->select_lex);
unknown's avatar
unknown committed
148 149
    DBUG_RETURN(-1);				/* purecov: inspected */
  }
unknown's avatar
unknown committed
150

151
  // Don't count on usage of 'only index' when calculating which key to use
152
  table->used_keys.clear_all();
unknown's avatar
unknown committed
153 154
  select=make_select(table,0,0,conds,&error);
  if (error ||
155
      (select && select->check_quick(thd, safe_update, limit)) || !limit)
unknown's avatar
unknown committed
156 157
  {
    delete select;
unknown's avatar
unknown committed
158
    free_underlaid_joins(thd, &thd->lex->select_lex);
unknown's avatar
unknown committed
159 160 161 162
    if (error)
    {
      DBUG_RETURN(-1);				// Error in where
    }
163
    send_ok(thd);				// No matching records
unknown's avatar
unknown committed
164 165 166
    DBUG_RETURN(0);
  }
  /* If running in safe sql mode, don't allow updates without keys */
167
  if (table->quick_keys.is_clear_all())
unknown's avatar
unknown committed
168
  {
169
    thd->server_status|=SERVER_QUERY_NO_INDEX_USED;
unknown's avatar
unknown committed
170
    if (safe_update && !using_limit)
171
    {
unknown's avatar
unknown committed
172 173 174
      my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
		 ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
      goto err;
175
    }
unknown's avatar
unknown committed
176
  }
unknown's avatar
unknown committed
177
  init_ftfuncs(thd, &thd->lex->select_lex, 1);
unknown's avatar
unknown committed
178 179
  /* Check if we are modifying a key that we are used to search with */
  if (select && select->quick)
unknown's avatar
unknown committed
180 181 182 183 184 185 186 187 188 189 190 191
  {
    if (select->quick->get_type() != QUICK_SELECT_I::QS_TYPE_INDEX_MERGE)
    {
      used_index= select->quick->index;
      used_key_is_modified= (!select->quick->unique_key_range() &&
			      check_if_key_used(table,used_index,fields));
    }
    else
    {
      used_key_is_modified= true;
    }
  }
unknown's avatar
unknown committed
192 193 194 195
  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;
unknown's avatar
unknown committed
196
  if (used_key_is_modified || order)
unknown's avatar
unknown committed
197 198
  {
    /*
unknown's avatar
unknown committed
199 200
      We can't update table directly;  We must first search after all
      matching rows before updating the table!
unknown's avatar
unknown committed
201
    */
unknown's avatar
unknown committed
202
    table->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
203
    if (old_used_keys.is_set(used_index))
unknown's avatar
unknown committed
204 205 206 207
    {
      table->key_read=1;
      table->file->extra(HA_EXTRA_KEYREAD);
    }
208 209 210

    if (order)
    {
unknown's avatar
unknown committed
211 212 213 214
      /*
	Doing an ORDER BY;  Let filesort find and sort the rows we are going
	to update
      */
215 216
      uint         length;
      SORT_FIELD  *sortorder;
217
      ha_rows examined_rows;
218

unknown's avatar
unknown committed
219
      table->sort.io_cache = (IO_CACHE *) my_malloc(sizeof(IO_CACHE),
unknown's avatar
unknown committed
220
						    MYF(MY_FAE | MY_ZEROFILL));
unknown's avatar
unknown committed
221
      if (!(sortorder=make_unireg_sortorder(order, &length)) ||
unknown's avatar
unknown committed
222
          (table->sort.found_records = filesort(thd, table, sortorder, length,
unknown's avatar
unknown committed
223
						select, limit,
unknown's avatar
unknown committed
224
						&examined_rows))
225 226
          == HA_POS_ERROR)
      {
unknown's avatar
unknown committed
227
	free_io_cache(table);
228
	goto err;
229
      }
unknown's avatar
unknown committed
230 231 232 233 234 235
      /*
	Filesort has already found and selected the rows we want to update,
	so we don't need the where clause
      */
      delete select;
      select= 0;
236
    }
unknown's avatar
unknown committed
237
    else
unknown's avatar
unknown committed
238
    {
unknown's avatar
unknown committed
239 240 241 242 243 244 245 246 247
      /*
	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)))
248
	goto err;
unknown's avatar
unknown committed
249 250 251 252

      init_read_record(&info,thd,table,select,0,1);
      thd->proc_info="Searching rows for update";
      uint tmp_limit= limit;
unknown's avatar
unknown committed
253

unknown's avatar
unknown committed
254
      while (!(error=info.read_record(&info)) && !thd->killed)
unknown's avatar
unknown committed
255
      {
unknown's avatar
unknown committed
256
	if (!(select && select->skipp_record()))
unknown's avatar
unknown committed
257
	{
unknown's avatar
unknown committed
258 259 260 261 262 263 264 265
	  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)
266 267
	  {
	    error= -1;
unknown's avatar
unknown committed
268
	    break;
269
	  }
unknown's avatar
unknown committed
270 271
	}
      }
272
      limit= tmp_limit;
unknown's avatar
unknown committed
273 274 275 276 277 278 279 280 281 282
      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;
      }
unknown's avatar
unknown committed
283 284
      else
      {
unknown's avatar
unknown committed
285 286
	select= new SQL_SELECT;
	select->head=table;
unknown's avatar
unknown committed
287
      }
unknown's avatar
unknown committed
288 289 290 291
      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)
292
	goto err;
unknown's avatar
unknown committed
293 294 295 296 297 298 299 300
    }
    if (table->key_read)
    {
      table->key_read=0;
      table->file->extra(HA_EXTRA_NO_KEYREAD);
    }
  }

unknown's avatar
unknown committed
301 302
  if (handle_duplicates == DUP_IGNORE)
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
unknown's avatar
unknown committed
303 304
  init_read_record(&info,thd,table,select,0,1);

305
  updated= found= 0;
306
  thd->count_cuted_fields= CHECK_FIELD_WARN;		/* calc cuted fields */
unknown's avatar
unknown committed
307
  thd->cuted_fields=0L;
308
  thd->proc_info="Updating";
309
  query_id=thd->query_id;
unknown's avatar
unknown committed
310 311 312 313 314

  while (!(error=info.read_record(&info)) && !thd->killed)
  {
    if (!(select && select->skipp_record()))
    {
unknown's avatar
unknown committed
315
      store_record(table,record[1]);
unknown's avatar
unknown committed
316
      if (fill_record(fields,values, 0) || thd->net.report_error)
unknown's avatar
unknown committed
317
	break; /* purecov: inspected */
unknown's avatar
unknown committed
318
      found++;
319
      if (compare_record(table, query_id))
unknown's avatar
unknown committed
320 321 322 323 324 325 326 327 328 329 330 331 332 333
      {
	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;
	}
      }
unknown's avatar
unknown committed
334 335 336 337 338
      if (!--limit && using_limit)
      {
	error= -1;				// Simulate end of file
	break;
      }
unknown's avatar
unknown committed
339
    }
unknown's avatar
unknown committed
340 341
    else
      table->file->unlock_row();
342
    thd->row_count++;
unknown's avatar
unknown committed
343 344
  }
  end_read_record(&info);
unknown's avatar
unknown committed
345
  free_io_cache(table);				// If ORDER BY
unknown's avatar
unknown committed
346
  thd->proc_info="end";
unknown's avatar
unknown committed
347
  VOID(table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY));
unknown's avatar
unknown committed
348 349 350 351 352 353 354 355

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

356 357 358
  transactional_table= table->file->has_transactions();
  log_delayed= (transactional_table || table->tmp_table);
  if (updated && (error <= 0 || !transactional_table))
unknown's avatar
unknown committed
359
  {
360 361
    if (mysql_bin_log.is_open())
    {
362
      Query_log_event qinfo(thd, thd->query, thd->query_length,
363 364 365
			    log_delayed);
      if (mysql_bin_log.write(&qinfo) && transactional_table)
	error=1;				// Rollback update
366
    }
367
    if (!log_delayed)
368
      thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
unknown's avatar
unknown committed
369
  }
unknown's avatar
unknown committed
370 371 372 373 374
  if (transactional_table)
  {
    if (ha_autocommit_or_rollback(thd, error >= 0))
      error=1;
  }
unknown's avatar
unknown committed
375

376 377 378 379 380 381
  if (thd->lock)
  {
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
  }

unknown's avatar
unknown committed
382
  delete select;
unknown's avatar
unknown committed
383
  free_underlaid_joins(thd, &thd->lex->select_lex);
unknown's avatar
unknown committed
384
  if (error >= 0)
unknown's avatar
SCRUM  
unknown committed
385
    send_error(thd,thd->killed_errno()); /* purecov: inspected */
unknown's avatar
unknown committed
386 387 388
  else
  {
    char buff[80];
389 390
    sprintf(buff, ER(ER_UPDATE_INFO), (ulong) found, (ulong) updated,
	    (ulong) thd->cuted_fields);
391
    send_ok(thd,
unknown's avatar
unknown committed
392 393 394 395
	    (thd->client_capabilities & CLIENT_FOUND_ROWS) ? found : updated,
	    thd->insert_id_used ? thd->insert_id() : 0L,buff);
    DBUG_PRINT("info",("%d records updated",updated));
  }
396
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;		/* calc cuted fields */
unknown's avatar
unknown committed
397
  free_io_cache(table);
unknown's avatar
unknown committed
398
  DBUG_RETURN(0);
399 400 401

err:
  delete select;
402
  free_underlaid_joins(thd, &thd->lex->select_lex);
403 404 405 406 407 408
  if (table->key_read)
  {
    table->key_read=0;
    table->file->extra(HA_EXTRA_NO_KEYREAD);
  }
  DBUG_RETURN(-1);
unknown's avatar
unknown committed
409
}
410

unknown's avatar
unknown committed
411

412
/***************************************************************************
413
  Update multiple tables from join 
414 415
***************************************************************************/

unknown's avatar
unknown committed
416 417 418 419 420 421 422 423 424 425
/*
  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,
unknown's avatar
unknown committed
426 427
		       enum enum_duplicates handle_duplicates,
		       SELECT_LEX_UNIT *unit, SELECT_LEX *select_lex)
428
{
unknown's avatar
unknown committed
429 430 431 432 433
  int res;
  multi_update *result;
  TABLE_LIST *tl;
  DBUG_ENTER("mysql_multi_update");

unknown's avatar
unknown committed
434
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
435
  table_list->grant.want_privilege=(SELECT_ACL & ~table_list->grant.privilege);
unknown's avatar
unknown committed
436
#endif
unknown's avatar
unknown committed
437 438
  if ((res=open_and_lock_tables(thd,table_list)))
    DBUG_RETURN(res);
unknown's avatar
unknown committed
439
  fix_tables_pointers(thd->lex->all_selects_list);
unknown's avatar
unknown committed
440

unknown's avatar
unknown committed
441
  select_lex->select_limit= HA_POS_ERROR;
442
  if (setup_fields(thd, 0, table_list, *fields, 1, 0, 0))
unknown's avatar
unknown committed
443 444 445 446 447
    DBUG_RETURN(-1);

  /*
    Count tables and setup timestamp handling
  */
unknown's avatar
unknown committed
448
  for (tl= select_lex->get_table_list() ; tl ; tl=tl->next)
449
  {
unknown's avatar
unknown committed
450
    TABLE *table= tl->table;
451 452
    if (table->timestamp_field)
    {
unknown's avatar
unknown committed
453 454 455 456
      table->time_stamp=0;
      // Only set timestamp column if this is not modified
      if (table->timestamp_field->query_id != thd->query_id)
	table->time_stamp= table->timestamp_field->offset() +1;
457 458
    }
  }
unknown's avatar
unknown committed
459 460 461 462 463 464

  if (!(result=new multi_update(thd, table_list, fields, values,
				handle_duplicates)))
    DBUG_RETURN(-1);

  List<Item> total_list;
465
  res= mysql_select(thd, &select_lex->ref_pointer_array,
unknown's avatar
unknown committed
466 467
		    select_lex->get_table_list(), select_lex->with_wild,
		    total_list,
468
		    conds, 0, (ORDER *) NULL, (ORDER *)NULL, (Item *) NULL,
unknown's avatar
unknown committed
469
		    (ORDER *)NULL,
unknown's avatar
unknown committed
470
		    options | SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK,
471
		    result, unit, select_lex);
unknown's avatar
unknown committed
472 473
  delete result;
  DBUG_RETURN(res);
474 475
}

unknown's avatar
unknown committed
476 477 478 479

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)
480 481 482 483
  :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),
   do_update(1), trans_safe(0)
unknown's avatar
unknown committed
484 485 486 487 488 489 490
{}


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

491 492
int multi_update::prepare(List<Item> &not_used_values,
			  SELECT_LEX_UNIT *lex_unit)
493
{
unknown's avatar
unknown committed
494 495 496 497 498 499 500
  TABLE_LIST *table_ref;
  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;
501
  DBUG_ENTER("multi_update::prepare");
unknown's avatar
unknown committed
502

503
  thd->count_cuted_fields= CHECK_FIELD_WARN;
504
  thd->cuted_fields=0L;
unknown's avatar
unknown committed
505 506 507 508
  thd->proc_info="updating main table";

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

unknown's avatar
unknown committed
510
  if (!tables_to_update)
511
  {
unknown's avatar
unknown committed
512
    my_error(ER_NO_TABLES_USED, MYF(0));
unknown's avatar
unknown committed
513
    DBUG_RETURN(1);
514
  }
unknown's avatar
unknown committed
515

516
  /*
unknown's avatar
unknown committed
517 518
    We have to check values after setup_tables to get used_keys right in
    reference tables
519
  */
520

521
  if (setup_fields(thd, 0, all_tables, *values, 1, 0, 0))
522 523
    DBUG_RETURN(1);

524
  /*
unknown's avatar
unknown committed
525 526 527
    Save tables beeing updated in update_tables
    update_table->shared is position for table
    Don't use key read on tables that are updated
528
  */
unknown's avatar
unknown committed
529 530 531

  update.empty();
  for (table_ref= all_tables;  table_ref; table_ref=table_ref->next)
532
  {
unknown's avatar
unknown committed
533 534
    TABLE *table=table_ref->table;
    if (tables_to_update & table->map)
535
    {
unknown's avatar
unknown committed
536 537 538
      TABLE_LIST *tl= (TABLE_LIST*) thd->memdup((char*) table_ref,
						sizeof(*tl));
      if (!tl)
539
	DBUG_RETURN(1);
unknown's avatar
unknown committed
540 541 542
      update.link_in_list((byte*) tl, (byte**) &tl->next);
      tl->shared= table_count++;
      table->no_keyread=1;
543
      table->used_keys.clear_all();
unknown's avatar
unknown committed
544
      table->pos_in_table_list= tl;
545 546
    }
  }
unknown's avatar
unknown committed
547 548


unknown's avatar
unknown committed
549 550 551 552 553 554 555 556 557 558
  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);
559
  if (thd->is_fatal_error)
unknown's avatar
unknown committed
560 561 562 563 564 565
    DBUG_RETURN(1);
  for (i=0 ; i < table_count ; i++)
  {
    fields_for_table[i]= new List_item;
    values_for_table[i]= new List_item;
  }
566
  if (thd->is_fatal_error)
unknown's avatar
unknown committed
567 568 569 570 571 572 573 574 575 576 577 578
    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);
  }
579
  if (thd->is_fatal_error)
unknown's avatar
unknown committed
580 581 582 583 584 585 586
    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];
587
  DBUG_RETURN(thd->is_fatal_error != 0);
588 589 590
}


unknown's avatar
unknown committed
591
/*
592
  Initialize table for multi table
unknown's avatar
unknown committed
593

594 595 596 597
  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).
unknown's avatar
unknown committed
598 599 600
*/

bool
601 602
multi_update::initialize_tables(JOIN *join)
{
unknown's avatar
unknown committed
603 604 605 606 607 608 609 610
  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;
611 612 613
  table_to_update= 0;

  /* Create a temporary table for keys to all tables, except main table */
unknown's avatar
unknown committed
614
  for (table_ref= update_tables; table_ref; table_ref=table_ref->next)
615
  {
unknown's avatar
unknown committed
616
    TABLE *table=table_ref->table;
617
    uint cnt= table_ref->shared;
unknown's avatar
unknown committed
618
    Item_field *If;
619 620
    List<Item> temp_fields= *fields_for_table[cnt];
    ORDER     group;
unknown's avatar
unknown committed
621

622 623 624 625 626 627 628
    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;
      }
629
    }
630 631 632 633 634 635 636 637 638 639 640

    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",
unknown's avatar
unknown committed
641
			table, &my_charset_bin);
unknown's avatar
unknown committed
642 643 644 645
    if (!(If=new Item_field(((Field *) &offset))))
      DBUG_RETURN(1);
    If->maybe_null=0;
    if (temp_fields.push_front(If))
646 647 648 649 650 651 652 653 654 655 656 657 658 659
      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,
unknown's avatar
unknown committed
660 661
					   (ORDER*) &group, 0, 0,
					   TMP_TABLE_ALL_COLUMNS,
662 663
					   HA_POS_ERROR,
					   (char *) "")))
664 665
      DBUG_RETURN(1);
    tmp_tables[cnt]->file->extra(HA_EXTRA_WRITE_CACHE);
666
  }
unknown's avatar
unknown committed
667
  DBUG_RETURN(0);
668 669
}

670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
/*
  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)
unknown's avatar
unknown committed
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
    {
      if (join_tab->quick->get_type() != QUICK_SELECT_I::QS_TYPE_INDEX_MERGE)
      {
        return !check_if_key_used(table,join_tab->quick->index,*fields);
      }
      else
      {
        QUICK_INDEX_MERGE_SELECT *qsel_imerge=
          (QUICK_INDEX_MERGE_SELECT*)(join_tab->quick);
        List_iterator_fast<QUICK_RANGE_SELECT> it(qsel_imerge->quick_selects);
        QUICK_RANGE_SELECT *quick;
        while ((quick= it++))
        {
          if (check_if_key_used(table, quick->index, *fields))
            return 0;
        }
        return 1;
      }
    }

730 731 732 733 734 735 736 737 738 739 740
    /* 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;
}

741 742 743

multi_update::~multi_update()
{
unknown's avatar
unknown committed
744 745 746 747
  TABLE_LIST *table;
  for (table= update_tables ; table; table= table->next)
    table->table->no_keyread=0;

748 749
  if (tmp_tables)
  {
750 751 752 753 754 755 756 757
    for (uint cnt = 0; cnt < table_count; cnt++)
    {
      if (tmp_tables[cnt])
      {
	free_tmp_table(thd, tmp_tables[cnt]);
	tmp_table_param[cnt].cleanup();
      }
    }
758
  }
unknown's avatar
unknown committed
759 760
  if (copy_field)
    delete [] copy_field;
761
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;		// Restore this setting
unknown's avatar
unknown committed
762 763
  if (!trans_safe)
    thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
764 765 766
}


unknown's avatar
unknown committed
767
bool multi_update::send_data(List<Item> &not_used_values)
768
{
unknown's avatar
unknown committed
769 770 771 772
  TABLE_LIST *cur_table;
  DBUG_ENTER("multi_update::send_data");

  for (cur_table= update_tables; cur_table ; cur_table= cur_table->next)
773
  {
unknown's avatar
unknown committed
774
    TABLE *table= cur_table->table;
775 776 777 778 779 780 781 782 783 784 785 786
    /*
      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.
    */
unknown's avatar
unknown committed
787 788 789 790 791
    if (table->status & (STATUS_NULL_ROW | STATUS_UPDATED))
      continue;

    uint offset= cur_table->shared;
    table->file->position(table->record[0]);
792
    if (table == table_to_update)
793 794
    {
      table->status|= STATUS_UPDATED;
unknown's avatar
unknown committed
795
      store_record(table,record[1]);
unknown's avatar
unknown committed
796
      if (fill_record(*fields_for_table[offset], *values_for_table[offset], 0))
unknown's avatar
unknown committed
797
	DBUG_RETURN(1);
798
      found++;
unknown's avatar
unknown committed
799
      if (compare_record(table, thd->query_id))
800
      {
unknown's avatar
unknown committed
801 802
	int error;
	if (!updated++)
803
	{
unknown's avatar
unknown committed
804 805 806 807 808 809
	  /*
	    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);
810
	}
unknown's avatar
unknown committed
811 812
	if ((error=table->file->update_row(table->record[1],
					   table->record[0])))
813 814
	{
	  table->file->print_error(error,MYF(0));
unknown's avatar
unknown committed
815 816
	  updated--;
	  DBUG_RETURN(1);
817 818
	}
      }
unknown's avatar
unknown committed
819 820 821 822 823
    }
    else
    {
      int error;
      TABLE *tmp_table= tmp_tables[offset];
824
      fill_record(tmp_table->field+1, *values_for_table[offset], 1);
825
      found++;
unknown's avatar
unknown committed
826 827 828 829 830 831 832
      /* 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))
833
      {
unknown's avatar
unknown committed
834
	if (create_myisam_from_heap(thd, tmp_table, tmp_table_param + offset,
unknown's avatar
unknown committed
835
				    error, 1))
836
	{
unknown's avatar
unknown committed
837 838
	  do_update=0;
	  DBUG_RETURN(1);			// Not a table_is_full error
839 840 841 842
	}
      }
    }
  }
unknown's avatar
unknown committed
843
  DBUG_RETURN(0);
844 845
}

unknown's avatar
unknown committed
846

847 848 849
void multi_update::send_error(uint errcode,const char *err)
{
  /* First send error what ever it is ... */
850
  ::send_error(thd,errcode,err);
851 852 853 854

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

856
  /* Something already updated so we have to invalidate cache */
857 858
  query_cache_invalidate3(thd, update_tables, 1);

859
  /*
unknown's avatar
unknown committed
860 861
    If all tables that has been updated are trans safe then just do rollback.
    If not attempt to do remaining updates.
862
  */
unknown's avatar
unknown committed
863 864

  if (trans_safe)
865
    ha_rollback_stmt(thd);
unknown's avatar
unknown committed
866 867 868 869 870
  else if (do_update && table_count > 1)
  {
    /* Add warning here */
    VOID(do_updates(0));
  }
871 872 873
}


unknown's avatar
unknown committed
874
int multi_update::do_updates(bool from_send_error)
875
{
unknown's avatar
unknown committed
876 877 878 879 880 881 882 883
  TABLE_LIST *cur_table;
  int local_error;
  ha_rows org_updated;
  TABLE *table;
  DBUG_ENTER("do_updates");

  do_update= 0;					// Don't retry this function
  for (cur_table= update_tables; cur_table ; cur_table= cur_table->next)
884
  {
unknown's avatar
unknown committed
885
    table = cur_table->table;
886
    if (table == table_to_update)
unknown's avatar
unknown committed
887
      continue;					// Already updated
888

unknown's avatar
unknown committed
889 890 891 892 893 894 895 896 897 898 899 900 901
    org_updated= updated;
    byte *ref_pos;
    TABLE *tmp_table= tmp_tables[cur_table->shared];
    tmp_table->file->extra(HA_EXTRA_CACHE);	// Change to read cache
    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++)
902
    {
unknown's avatar
unknown committed
903 904
      Item_field *item= (Item_field* ) field_it++;
      (copy_field_ptr++)->set(item->field, *field, 0);
905
    }
unknown's avatar
unknown committed
906 907 908 909 910 911 912
    copy_field_end=copy_field_ptr;

    if ((local_error = tmp_table->file->rnd_init(1)))
      goto err;

    ref_pos= (byte*) tmp_table->field[0]->ptr;
    for (;;)
913
    {
unknown's avatar
unknown committed
914 915 916 917 918 919 920 921 922 923 924 925
      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;
926
      table->status|= STATUS_UPDATED;
unknown's avatar
unknown committed
927
      store_record(table,record[1]);
unknown's avatar
unknown committed
928 929 930 931 932 933 934 935

      /* 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))
936
      {
unknown's avatar
unknown committed
937 938 939 940 941 942 943 944 945 946
	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;
947
      }
unknown's avatar
unknown committed
948 949 950 951 952 953 954 955
    }

    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;
956
      else
unknown's avatar
unknown committed
957
	trans_safe= 0;				// Can't do safe rollback
958 959
    }
  }
unknown's avatar
unknown committed
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975
  DBUG_RETURN(0);

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

  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);
976 977 978
}


unknown's avatar
unknown committed
979 980
/* out: 1 if error, 0 if success */

981 982
bool multi_update::send_eof()
{
unknown's avatar
unknown committed
983 984
  char buff[80];
  thd->proc_info="updating reference tables";
985 986

  /* Does updates for the last n - 1 tables, returns 0 if ok */
unknown's avatar
unknown committed
987
  int local_error = (table_count) ? do_updates(0) : 0;
988
  thd->proc_info= "end";
989

unknown's avatar
unknown committed
990 991 992 993 994 995 996 997
  /* We must invalidate the query cache before binlog writing and
  ha_autocommit_... */

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

unknown's avatar
unknown committed
998 999
  /*
    Write the SQL statement to the binlog if we updated
unknown's avatar
unknown committed
1000 1001
    rows and we succeeded or if we updated some non
    transacational tables
unknown's avatar
unknown committed
1002
  */
1003

unknown's avatar
unknown committed
1004
  if (updated && (local_error <= 0 || !trans_safe))
1005
  {
unknown's avatar
unknown committed
1006 1007 1008 1009 1010
    if (mysql_bin_log.is_open())
    {
      Query_log_event qinfo(thd, thd->query, thd->query_length,
			    log_delayed);
      if (mysql_bin_log.write(&qinfo) && trans_safe)
1011
	local_error= 1;				// Rollback update
unknown's avatar
unknown committed
1012 1013 1014 1015
    }
    if (!log_delayed)
      thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
  }
1016

unknown's avatar
unknown committed
1017 1018
  if (transactional_tables)
  {
1019
    if (ha_autocommit_or_rollback(thd, local_error != 0))
unknown's avatar
unknown committed
1020 1021
      local_error=1;
  }
1022

unknown's avatar
unknown committed
1023 1024 1025 1026 1027
  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));
unknown's avatar
unknown committed
1028
    ::send_error(thd);
unknown's avatar
unknown committed
1029
    return 1;
1030
  }
unknown's avatar
unknown committed
1031 1032


1033 1034
  sprintf(buff, ER(ER_UPDATE_INFO), (ulong) found, (ulong) updated,
	  (ulong) thd->cuted_fields);
unknown's avatar
unknown committed
1035
  ::send_ok(thd,
unknown's avatar
unknown committed
1036 1037
	    (thd->client_capabilities & CLIENT_FOUND_ROWS) ? found : updated,
	    thd->insert_id_used ? thd->insert_id() : 0L,buff);
1038 1039
  return 0;
}