sql_update.cc 27 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 33
{
  if (!table->blob_fields)
    return cmp_record(table,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;
unknown's avatar
unknown committed
65 66 67 68
  key_map	old_used_keys;
  TABLE		*table;
  SQL_SELECT	*select;
  READ_RECORD	info;
69 70
  TABLE_LIST    *update_table_list= (TABLE_LIST*) 
    thd->lex.select_lex.table_list.first;
unknown's avatar
unknown committed
71 72
  DBUG_ENTER("mysql_update");
  LINT_INIT(used_index);
unknown's avatar
unknown committed
73
  LINT_INIT(timestamp_query_id);
unknown's avatar
unknown committed
74

unknown's avatar
unknown committed
75
  if ((open_and_lock_tables(thd, table_list)))
76
    DBUG_RETURN(-1);
77
  fix_tables_pointers(thd->lex.all_selects_list);
unknown's avatar
unknown committed
78
  table= table_list->table;
79

unknown's avatar
unknown committed
80 81 82
  table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
  thd->proc_info="init";

83 84 85 86 87
  /* Calculate "table->used_keys" based on the WHERE */
  table->used_keys=table->keys_in_use;
  table->quick_keys=0;
  want_privilege=table->grant.want_privilege;
  table->grant.want_privilege=(SELECT_ACL & ~table->grant.privilege);
88 89
  if (setup_tables(update_table_list) || 
      setup_conds(thd,update_table_list,&conds)
unknown's avatar
unknown committed
90
      || setup_ftfuncs(&thd->lex.select_lex))
91
    DBUG_RETURN(-1);				/* purecov: inspected */
92 93 94
  if (find_real_table_in_list(table_list->next, 
			      table_list->db, table_list->real_name))
  {
unknown's avatar
unknown committed
95
    my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->real_name);
96 97 98
    DBUG_RETURN(-1);
  }

99 100
  old_used_keys=table->used_keys;		// Keys used in WHERE

unknown's avatar
unknown committed
101
  /*
102 103
    Change the query_id for the timestamp column so that we can
    check if this is modified directly
unknown's avatar
unknown committed
104
  */
105 106 107 108
  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
109
    table->time_stamp= table->timestamp_field->offset() +1;
110
  }
unknown's avatar
unknown committed
111

112 113
  /* Check the fields we are going to modify */
  table->grant.want_privilege=want_privilege;
114
  if (setup_fields(thd, 0, update_table_list, fields, 1, 0, 0))
115 116 117 118 119 120 121 122 123
    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;
  }
124

125 126
  /* Check values */
  table->grant.want_privilege=(SELECT_ACL & ~table->grant.privilege);
127
  if (setup_fields(thd, 0, update_table_list, values, 0, 0, 0))
unknown's avatar
unknown committed
128
  {
unknown's avatar
unknown committed
129
    free_underlaid_joins(thd, &thd->lex.select_lex);
unknown's avatar
unknown committed
130 131
    DBUG_RETURN(-1);				/* purecov: inspected */
  }
unknown's avatar
unknown committed
132

133 134
  // Don't count on usage of 'only index' when calculating which key to use
  table->used_keys=0;
unknown's avatar
unknown committed
135 136
  select=make_select(table,0,0,conds,&error);
  if (error ||
unknown's avatar
unknown committed
137
      (select && select->check_quick(safe_update, limit)) || !limit)
unknown's avatar
unknown committed
138 139
  {
    delete select;
unknown's avatar
unknown committed
140
    free_underlaid_joins(thd, &thd->lex.select_lex);
unknown's avatar
unknown committed
141 142 143 144
    if (error)
    {
      DBUG_RETURN(-1);				// Error in where
    }
145
    send_ok(thd);				// No matching records
unknown's avatar
unknown committed
146 147 148
    DBUG_RETURN(0);
  }
  /* If running in safe sql mode, don't allow updates without keys */
149
  if (!table->quick_keys)
unknown's avatar
unknown committed
150
  {
151
    thd->lex.select_lex.options|=QUERY_NO_INDEX_USED;
unknown's avatar
unknown committed
152
    if (safe_update && !using_limit)
153 154
    {
      delete select;
unknown's avatar
unknown committed
155
      free_underlaid_joins(thd, &thd->lex.select_lex);
156
      send_error(thd,ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE);
157 158
      DBUG_RETURN(1);
    }
unknown's avatar
unknown committed
159
  }
160
  init_ftfuncs(thd, &thd->lex.select_lex, 1);
unknown's avatar
unknown 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;
unknown's avatar
unknown committed
171
  if (used_key_is_modified || order)
unknown's avatar
unknown committed
172 173
  {
    /*
unknown's avatar
unknown committed
174 175
      We can't update table directly;  We must first search after all
      matching rows before updating the table!
unknown's avatar
unknown committed
176
    */
177
    table->file->extra(HA_EXTRA_DONT_USE_CURSOR_TO_UPDATE);
unknown's avatar
unknown committed
178 179 180 181
    IO_CACHE tempfile;
    if (open_cached_file(&tempfile, mysql_tmpdir,TEMP_PREFIX,
			  DISK_BUFFER_SIZE, MYF(MY_WME)))
    {
unknown's avatar
unknown committed
182
      delete select; /* purecov: inspected */
unknown's avatar
unknown committed
183
      free_underlaid_joins(thd, &thd->lex.select_lex);
unknown's avatar
unknown committed
184 185 186 187 188 189 190
      DBUG_RETURN(-1);
    }
    if (old_used_keys & ((key_map) 1 << used_index))
    {
      table->key_read=1;
      table->file->extra(HA_EXTRA_KEYREAD);
    }
191 192 193 194 195 196 197 198

    if (order)
    {
      uint         length;
      SORT_FIELD  *sortorder;
      TABLE_LIST   tables;
      List<Item>   fields;
      List<Item>   all_fields;
199
      ha_rows examined_rows;
200 201 202 203 204 205

      bzero((char*) &tables,sizeof(tables));
      tables.table = table;

      table->io_cache = (IO_CACHE *) my_malloc(sizeof(IO_CACHE),
                                               MYF(MY_FAE | MY_ZEROFILL));
206 207 208 209
      if (setup_ref_array(thd, &thd->lex.select_lex.ref_pointer_array,
			order_num)||
	  setup_order(thd, thd->lex.select_lex.ref_pointer_array,
		      &tables, fields, all_fields, order) ||
210
          !(sortorder=make_unireg_sortorder(order, &length)) ||
211 212
          (table->found_records = filesort(thd, table, sortorder, length,
                                           (SQL_SELECT *) 0,
213
					   HA_POS_ERROR, &examined_rows))
214 215 216
          == HA_POS_ERROR)
      {
	delete select;
unknown's avatar
unknown committed
217
	free_underlaid_joins(thd, &thd->lex.select_lex);
218 219 220 221
	DBUG_RETURN(-1);
      }
    }

unknown's avatar
unknown committed
222
    init_read_record(&info,thd,table,select,0,1);
223
    thd->proc_info="Searching rows for update";
unknown's avatar
unknown committed
224 225 226 227 228 229 230 231 232

    while (!(error=info.read_record(&info)) && !thd->killed)
    {
      if (!(select && select->skipp_record()))
      {
	table->file->position(table->record[0]);
	if (my_b_write(&tempfile,table->file->ref,
		       table->file->ref_length))
	{
unknown's avatar
unknown committed
233 234
	  error=1; /* purecov: inspected */
	  break; /* purecov: inspected */
unknown's avatar
unknown committed
235 236 237 238
	}
      }
      else
      {
239
	if (!(test_flags & 512))		/* For debugging */
unknown's avatar
unknown committed
240 241 242 243 244 245
	{
	  DBUG_DUMP("record",(char*) table->record[0],table->reclength);
	}
      }
    }
    end_read_record(&info);
246

unknown's avatar
unknown committed
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
    if (table->key_read)
    {
      table->key_read=0;
      table->file->extra(HA_EXTRA_NO_KEYREAD);
    }
    /* Change select to use tempfile */
    if (select)
    {
      delete select->quick;
      if (select->free_cond)
	delete select->cond;
      select->quick=0;
      select->cond=0;
    }
    else
262
    {
unknown's avatar
unknown committed
263 264 265 266
      select= new SQL_SELECT;
      select->head=table;
    }
    if (reinit_io_cache(&tempfile,READ_CACHE,0L,0,0))
unknown's avatar
unknown committed
267
      error=1; /* purecov: inspected */
unknown's avatar
unknown committed
268 269 270 271
    select->file=tempfile;			// Read row ptrs from this file
    if (error >= 0)
    {
      delete select;
unknown's avatar
unknown committed
272
      free_underlaid_joins(thd, &thd->lex.select_lex);
273
      DBUG_RETURN(-1);
unknown's avatar
unknown committed
274 275 276
    }
  }

unknown's avatar
unknown committed
277 278
  if (handle_duplicates == DUP_IGNORE)
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
unknown's avatar
unknown committed
279 280 281 282 283
  init_read_record(&info,thd,table,select,0,1);

  ha_rows updated=0L,found=0L;
  thd->count_cuted_fields=1;			/* calc cuted fields */
  thd->cuted_fields=0L;
284
  thd->proc_info="Updating";
285
  query_id=thd->query_id;
unknown's avatar
unknown committed
286 287 288 289 290 291

  while (!(error=info.read_record(&info)) && !thd->killed)
  {
    if (!(select && select->skipp_record()))
    {
      store_record(table,1);
unknown's avatar
unknown committed
292
      if (fill_record(fields,values) || thd->net.report_error)
unknown's avatar
unknown committed
293
	break; /* purecov: inspected */
unknown's avatar
unknown committed
294
      found++;
295
      if (compare_record(table, query_id))
unknown's avatar
unknown committed
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
      {
	if (!(error=table->file->update_row((byte*) table->record[1],
					    (byte*) table->record[0])))
	{
	  updated++;
	  if (!--limit && using_limit)
	  {
	    error= -1;
	    break;
	  }
	}
	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
316 317
    else
      table->file->unlock_row();
unknown's avatar
unknown committed
318 319 320
  }
  end_read_record(&info);
  thd->proc_info="end";
unknown's avatar
unknown committed
321
  VOID(table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY));
322 323 324
  transactional_table= table->file->has_transactions();
  log_delayed= (transactional_table || table->tmp_table);
  if (updated && (error <= 0 || !transactional_table))
unknown's avatar
unknown committed
325
  {
326 327 328
    mysql_update_log.write(thd,thd->query,thd->query_length);
    if (mysql_bin_log.is_open())
    {
329
      Query_log_event qinfo(thd, thd->query, thd->query_length,
330 331 332
			    log_delayed);
      if (mysql_bin_log.write(&qinfo) && transactional_table)
	error=1;				// Rollback update
333
    }
334
    if (!log_delayed)
335
      thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
unknown's avatar
unknown committed
336
  }
unknown's avatar
unknown committed
337 338 339 340 341
  if (transactional_table)
  {
    if (ha_autocommit_or_rollback(thd, error >= 0))
      error=1;
  }
unknown's avatar
unknown committed
342

unknown's avatar
unknown committed
343
  /*
unknown's avatar
unknown committed
344 345
    Store table for future invalidation  or invalidate it in
    the query cache if something changed
unknown's avatar
unknown committed
346
  */
unknown's avatar
unknown committed
347
  if (updated)
unknown's avatar
merge  
unknown committed
348
  {
349
    query_cache_invalidate3(thd, table_list, 1);
unknown's avatar
merge  
unknown committed
350
  }
unknown's avatar
unknown committed
351 352 353 354 355
  if (thd->lock)
  {
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
  }
356

unknown's avatar
unknown committed
357
  delete select;
unknown's avatar
unknown committed
358
  free_underlaid_joins(thd, &thd->lex.select_lex);
unknown's avatar
unknown committed
359
  if (error >= 0)
360
    send_error(thd,thd->killed ? ER_SERVER_SHUTDOWN : 0); /* purecov: inspected */
unknown's avatar
unknown committed
361 362 363 364 365
  else
  {
    char buff[80];
    sprintf(buff,ER(ER_UPDATE_INFO), (long) found, (long) updated,
	    (long) thd->cuted_fields);
366
    send_ok(thd,
unknown's avatar
unknown committed
367 368 369 370 371
	    (thd->client_capabilities & CLIENT_FOUND_ROWS) ? found : updated,
	    thd->insert_id_used ? thd->insert_id() : 0L,buff);
    DBUG_PRINT("info",("%d records updated",updated));
  }
  thd->count_cuted_fields=0;			/* calc cuted fields */
unknown's avatar
unknown committed
372
  free_io_cache(table);
373

unknown's avatar
unknown committed
374 375
  DBUG_RETURN(0);
}
376

unknown's avatar
unknown committed
377

378
/***************************************************************************
379
  Update multiple tables from join 
380 381
***************************************************************************/

unknown's avatar
unknown committed
382 383 384 385 386 387 388 389 390 391
/*
  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
392 393
		       enum enum_duplicates handle_duplicates,
		       SELECT_LEX_UNIT *unit, SELECT_LEX *select_lex)
394
{
unknown's avatar
unknown committed
395 396 397 398 399 400 401 402 403 404
  int res;
  multi_update *result;
  TABLE_LIST *tl;
  DBUG_ENTER("mysql_multi_update");

  table_list->grant.want_privilege=(SELECT_ACL & ~table_list->grant.privilege);
  if ((res=open_and_lock_tables(thd,table_list)))
    DBUG_RETURN(res);

  thd->select_limit=HA_POS_ERROR;
405
  if (setup_fields(thd, 0, table_list, *fields, 1, 0, 0))
unknown's avatar
unknown committed
406 407 408 409 410 411
    DBUG_RETURN(-1);

  /*
    Count tables and setup timestamp handling
  */
  for (tl= (TABLE_LIST*) table_list ; tl ; tl=tl->next)
412
  {
unknown's avatar
unknown committed
413
    TABLE *table= tl->table;
414 415
    if (table->timestamp_field)
    {
unknown's avatar
unknown committed
416 417 418 419
      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;
420 421
    }
  }
unknown's avatar
unknown committed
422 423 424 425 426 427

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

  List<Item> total_list;
428 429 430
  res= mysql_select(thd, &select_lex->ref_pointer_array,
		    table_list, select_lex->with_wild, total_list,
		    conds, 0, (ORDER *) NULL, (ORDER *)NULL, (Item *) NULL,
unknown's avatar
unknown committed
431
		    (ORDER *)NULL,
unknown's avatar
unknown committed
432
		    options | SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK,
433
		    result, unit, select_lex, 0);
unknown's avatar
unknown committed
434 435
  delete result;
  DBUG_RETURN(res);
436 437
}

unknown's avatar
unknown committed
438 439 440 441

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)
442 443 444 445
  :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
446 447 448 449 450 451 452
{}


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

unknown's avatar
unknown committed
453
int multi_update::prepare(List<Item> &not_used_values, SELECT_LEX_UNIT *unit)
454
{
unknown's avatar
unknown committed
455 456 457 458 459 460 461
  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;
462
  DBUG_ENTER("multi_update::prepare");
unknown's avatar
unknown committed
463

464 465
  thd->count_cuted_fields=1;
  thd->cuted_fields=0L;
unknown's avatar
unknown committed
466 467 468 469
  thd->proc_info="updating main table";

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

unknown's avatar
unknown committed
471
  if (!tables_to_update)
472
  {
unknown's avatar
unknown committed
473 474 475
    my_error(ER_NOT_SUPPORTED_YET, MYF(0),
	     "You didn't specify any tables to UPDATE");
    DBUG_RETURN(1);
476
  }
unknown's avatar
unknown committed
477

478
  /*
unknown's avatar
unknown committed
479 480
    We have to check values after setup_tables to get used_keys right in
    reference tables
481
  */
482

483
  if (setup_fields(thd, 0, all_tables, *values, 1, 0, 0))
484 485
    DBUG_RETURN(1);

486
  /*
unknown's avatar
unknown committed
487 488 489
    Save tables beeing updated in update_tables
    update_table->shared is position for table
    Don't use key read on tables that are updated
490
  */
unknown's avatar
unknown committed
491 492 493

  update.empty();
  for (table_ref= all_tables;  table_ref; table_ref=table_ref->next)
494
  {
unknown's avatar
unknown committed
495 496
    TABLE *table=table_ref->table;
    if (tables_to_update & table->map)
497
    {
unknown's avatar
unknown committed
498 499 500
      TABLE_LIST *tl= (TABLE_LIST*) thd->memdup((char*) table_ref,
						sizeof(*tl));
      if (!tl)
501
	DBUG_RETURN(1);
unknown's avatar
unknown committed
502 503 504 505 506
      update.link_in_list((byte*) tl, (byte**) &tl->next);
      tl->shared= table_count++;
      table->no_keyread=1;
      table->used_keys=0;
      table->pos_in_table_list= tl;
507 508
    }
  }
unknown's avatar
unknown committed
509 510 511 512 513 514 515 516 517 518
  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);
519
  if (thd->is_fatal_error)
unknown's avatar
unknown committed
520 521 522 523 524 525
    DBUG_RETURN(1);
  for (i=0 ; i < table_count ; i++)
  {
    fields_for_table[i]= new List_item;
    values_for_table[i]= new List_item;
  }
526
  if (thd->is_fatal_error)
unknown's avatar
unknown committed
527 528 529 530 531 532 533 534 535 536 537 538
    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);
  }
539
  if (thd->is_fatal_error)
unknown's avatar
unknown committed
540 541 542 543 544 545 546
    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];
547
  DBUG_RETURN(thd->is_fatal_error != 0);
548 549 550
}


unknown's avatar
unknown committed
551
/*
552
  Initialize table for multi table
unknown's avatar
unknown committed
553

554 555 556 557
  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
558 559 560
*/

bool
561 562
multi_update::initialize_tables(JOIN *join)
{
unknown's avatar
unknown committed
563 564 565 566 567 568 569 570
  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;
571 572 573
  table_to_update= 0;

  /* Create a temporary table for keys to all tables, except main table */
unknown's avatar
unknown committed
574
  for (table_ref= update_tables; table_ref; table_ref=table_ref->next)
575
  {
unknown's avatar
unknown committed
576
    TABLE *table=table_ref->table;
577 578 579
    uint cnt= table_ref->shared;
    List<Item> temp_fields= *fields_for_table[cnt];
    ORDER     group;
unknown's avatar
unknown committed
580

581 582 583 584 585 586 587
    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;
      }
588
    }
589 590 591 592 593 594 595 596 597 598 599

    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
600
			table, &my_charset_bin);
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
    if (temp_fields.push_front(new Item_field(((Field *) &offset))))
      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
616 617 618
					   (ORDER*) &group, 0, 0,
					   TMP_TABLE_ALL_COLUMNS,
					   HA_POS_ERROR)))
619 620
      DBUG_RETURN(1);
    tmp_tables[cnt]->file->extra(HA_EXTRA_WRITE_CACHE);
621
  }
unknown's avatar
unknown committed
622
  DBUG_RETURN(0);
623 624
}

625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
/*
  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;
}

678 679 680

multi_update::~multi_update()
{
unknown's avatar
unknown committed
681 682 683 684
  TABLE_LIST *table;
  for (table= update_tables ; table; table= table->next)
    table->table->no_keyread=0;

685 686
  if (tmp_tables)
  {
687 688 689 690 691 692 693 694
    for (uint cnt = 0; cnt < table_count; cnt++)
    {
      if (tmp_tables[cnt])
      {
	free_tmp_table(thd, tmp_tables[cnt]);
	tmp_table_param[cnt].cleanup();
      }
    }
695
  }
unknown's avatar
unknown committed
696 697 698 699 700
  if (copy_field)
    delete [] copy_field;
  thd->count_cuted_fields=0;			// Restore this setting
  if (!trans_safe)
    thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
701 702 703
}


unknown's avatar
unknown committed
704
bool multi_update::send_data(List<Item> &not_used_values)
705
{
unknown's avatar
unknown committed
706 707 708 709
  TABLE_LIST *cur_table;
  DBUG_ENTER("multi_update::send_data");

  for (cur_table= update_tables; cur_table ; cur_table= cur_table->next)
710
  {
unknown's avatar
unknown committed
711
    TABLE *table= cur_table->table;
712 713 714 715 716 717 718 719 720 721 722 723
    /*
      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
724 725 726 727 728
    if (table->status & (STATUS_NULL_ROW | STATUS_UPDATED))
      continue;

    uint offset= cur_table->shared;
    table->file->position(table->record[0]);
729
    if (table == table_to_update)
730 731
    {
      table->status|= STATUS_UPDATED;
unknown's avatar
unknown committed
732 733 734
      store_record(table,1);
      if (fill_record(*fields_for_table[offset], *values_for_table[offset]))
	DBUG_RETURN(1);
735
      found++;
unknown's avatar
unknown committed
736
      if (compare_record(table, thd->query_id))
737
      {
unknown's avatar
unknown committed
738 739
	int error;
	if (!updated++)
740
	{
unknown's avatar
unknown committed
741 742 743 744 745 746
	  /*
	    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);
747
	}
unknown's avatar
unknown committed
748 749
	if ((error=table->file->update_row(table->record[1],
					   table->record[0])))
750 751
	{
	  table->file->print_error(error,MYF(0));
unknown's avatar
unknown committed
752 753
	  updated--;
	  DBUG_RETURN(1);
754 755
	}
      }
unknown's avatar
unknown committed
756 757 758 759 760 761
    }
    else
    {
      int error;
      TABLE *tmp_table= tmp_tables[offset];
      fill_record(tmp_table->field+1, *values_for_table[offset]);
762
      found++;
unknown's avatar
unknown committed
763 764 765 766 767 768 769
      /* 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))
770
      {
unknown's avatar
unknown committed
771 772
	if (create_myisam_from_heap(thd, table, tmp_table_param + offset,
				    error, 1))
773
	{
unknown's avatar
unknown committed
774 775
	  do_update=0;
	  DBUG_RETURN(1);			// Not a table_is_full error
776 777 778 779
	}
      }
    }
  }
unknown's avatar
unknown committed
780
  DBUG_RETURN(0);
781 782
}

unknown's avatar
unknown committed
783

784 785 786
void multi_update::send_error(uint errcode,const char *err)
{
  /* First send error what ever it is ... */
787
  ::send_error(thd,errcode,err);
788 789 790 791

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

793
  /* Something already updated so we have to invalidate cache */
794 795
  query_cache_invalidate3(thd, update_tables, 1);

796
  /*
unknown's avatar
unknown committed
797 798
    If all tables that has been updated are trans safe then just do rollback.
    If not attempt to do remaining updates.
799
  */
unknown's avatar
unknown committed
800 801

  if (trans_safe)
802
    ha_rollback_stmt(thd);
unknown's avatar
unknown committed
803 804 805 806 807
  else if (do_update && table_count > 1)
  {
    /* Add warning here */
    VOID(do_updates(0));
  }
808 809 810
}


unknown's avatar
unknown committed
811
int multi_update::do_updates(bool from_send_error)
812
{
unknown's avatar
unknown committed
813 814 815 816 817 818 819 820
  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)
821
  {
unknown's avatar
unknown committed
822
    table = cur_table->table;
823
    if (table == table_to_update)
unknown's avatar
unknown committed
824
      continue;					// Already updated
825

unknown's avatar
unknown committed
826 827 828 829 830 831 832 833 834 835 836 837 838
    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++)
839
    {
unknown's avatar
unknown committed
840 841
      Item_field *item= (Item_field* ) field_it++;
      (copy_field_ptr++)->set(item->field, *field, 0);
842
    }
unknown's avatar
unknown committed
843 844 845 846 847 848 849
    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 (;;)
850
    {
unknown's avatar
unknown committed
851 852 853 854 855 856 857 858 859 860 861 862
      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;
863
      table->status|= STATUS_UPDATED;
unknown's avatar
unknown committed
864 865 866 867 868 869 870 871 872
      store_record(table,1);

      /* 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))
873
      {
unknown's avatar
unknown committed
874 875 876 877 878 879 880 881 882 883
	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;
884
      }
unknown's avatar
unknown committed
885 886 887 888 889 890 891 892
    }

    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;
893
      else
unknown's avatar
unknown committed
894
	trans_safe= 0;				// Can't do safe rollback
895 896
    }
  }
unknown's avatar
unknown committed
897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
  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);
913 914 915
}


unknown's avatar
unknown committed
916 917
/* out: 1 if error, 0 if success */

918 919
bool multi_update::send_eof()
{
unknown's avatar
unknown committed
920 921
  char buff[80];
  thd->proc_info="updating reference tables";
922 923

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

unknown's avatar
unknown committed
927 928
  /*
    Write the SQL statement to the binlog if we updated
unknown's avatar
unknown committed
929 930
    rows and we succeeded or if we updated some non
    transacational tables
unknown's avatar
unknown committed
931
  */
932

unknown's avatar
unknown committed
933
  if (updated && (local_error <= 0 || !trans_safe))
934 935
  {
    mysql_update_log.write(thd,thd->query,thd->query_length);
unknown's avatar
unknown committed
936 937 938 939 940
    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)
941
	local_error= 1;				// Rollback update
unknown's avatar
unknown committed
942 943 944 945
    }
    if (!log_delayed)
      thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
  }
946

unknown's avatar
unknown committed
947 948
  if (transactional_tables)
  {
949
    if (ha_autocommit_or_rollback(thd, local_error != 0))
unknown's avatar
unknown committed
950 951
      local_error=1;
  }
952

unknown's avatar
unknown committed
953 954 955 956 957
  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
958
    ::send_error(thd);
unknown's avatar
unknown committed
959
    return 1;
960
  }
unknown's avatar
unknown committed
961 962 963 964 965


  sprintf(buff,ER(ER_UPDATE_INFO), (long) found, (long) updated,
	  (long) thd->cuted_fields);
  if (updated)
966
  {
unknown's avatar
unknown committed
967
    query_cache_invalidate3(thd, update_tables, 1);
968
  }
unknown's avatar
unknown committed
969
  ::send_ok(thd,
unknown's avatar
unknown committed
970 971
	    (thd->client_capabilities & CLIENT_FOUND_ROWS) ? found : updated,
	    thd->insert_id_used ? thd->insert_id() : 0L,buff);
972 973
  return 0;
}