sql_update.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:37k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /*
  14.   Single table and multi table updates of tables.
  15.   Multi-table updates were introduced by Sinisa & Monty
  16. */
  17. #include "mysql_priv.h"
  18. #include "sql_select.h"
  19. static bool safe_update_on_fly(JOIN_TAB *join_tab, List<Item> *fields);
  20. /* Return 0 if row hasn't changed */
  21. static bool compare_record(TABLE *table, ulong query_id)
  22. {
  23.   if (!table->blob_fields)
  24.     return cmp_record(table,record[1]);
  25.   /* Compare null bits */
  26.   if (memcmp(table->null_flags,
  27.      table->null_flags+table->rec_buff_length,
  28.      table->null_bytes))
  29.     return 1; // Diff in NULL value
  30.   /* Compare updated fields */
  31.   for (Field **ptr=table->field ; *ptr ; ptr++)
  32.   {
  33.     if ((*ptr)->query_id == query_id &&
  34. (*ptr)->cmp_binary_offset(table->rec_buff_length))
  35.       return 1;
  36.   }
  37.   return 0;
  38. }
  39. int mysql_update(THD *thd,
  40.                  TABLE_LIST *table_list,
  41.                  List<Item> &fields,
  42.  List<Item> &values,
  43.                  COND *conds,
  44.                  uint order_num, ORDER *order,
  45.  ha_rows limit,
  46.  enum enum_duplicates handle_duplicates,
  47.                  bool ignore)
  48. {
  49.   bool using_limit=limit != HA_POS_ERROR;
  50.   bool safe_update= thd->options & OPTION_SAFE_UPDATES;
  51.   bool used_key_is_modified, transactional_table, log_delayed;
  52.   int error=0;
  53.   uint used_index= MAX_KEY;
  54.   bool          need_sort= TRUE;
  55. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  56.   uint want_privilege;
  57. #endif
  58.   ulong query_id=thd->query_id, timestamp_query_id;
  59.   ha_rows updated, found;
  60.   key_map old_used_keys;
  61.   TABLE *table;
  62.   SQL_SELECT *select= 0;
  63.   READ_RECORD info;
  64.   TABLE_LIST    *update_table_list= ((TABLE_LIST*)
  65.      thd->lex->select_lex.table_list.first);
  66.   DBUG_ENTER("mysql_update");
  67.   LINT_INIT(timestamp_query_id);
  68.   if ((open_and_lock_tables(thd, table_list)))
  69.     DBUG_RETURN(-1);
  70.   thd->proc_info="init";
  71.   table= table_list->table;
  72.   table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
  73.   /* Calculate "table->used_keys" based on the WHERE */
  74.   table->used_keys=table->keys_in_use;
  75.   table->quick_keys.clear_all();
  76. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  77.   want_privilege= table->grant.want_privilege;
  78. #endif
  79.   if ((error= mysql_prepare_update(thd, table_list, update_table_list,
  80.    &conds, order_num, order)))
  81.     DBUG_RETURN(error);
  82.   old_used_keys= table->used_keys; // Keys used in WHERE
  83.   /*
  84.     Change the query_id for the timestamp column so that we can
  85.     check if this is modified directly
  86.   */
  87.   if (table->timestamp_field)
  88.   {
  89.     timestamp_query_id=table->timestamp_field->query_id;
  90.     table->timestamp_field->query_id=thd->query_id-1;
  91.   }
  92.   /* Check the fields we are going to modify */
  93. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  94.   table->grant.want_privilege=want_privilege;
  95. #endif
  96.   if (setup_fields(thd, 0, update_table_list, fields, 1, 0, 0))
  97.     DBUG_RETURN(-1); /* purecov: inspected */
  98.   if (table->timestamp_field)
  99.   {
  100.     // Don't set timestamp column if this is modified
  101.     if (table->timestamp_field->query_id == thd->query_id)
  102.       table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
  103.     else
  104.       table->timestamp_field->query_id=timestamp_query_id;
  105.   }
  106. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  107.   /* Check values */
  108.   table->grant.want_privilege=(SELECT_ACL & ~table->grant.privilege);
  109. #endif
  110.   if (setup_fields(thd, 0, update_table_list, values, 1, 0, 0))
  111.   {
  112.     free_underlaid_joins(thd, &thd->lex->select_lex);
  113.     DBUG_RETURN(-1); /* purecov: inspected */
  114.   }
  115.   if (conds)
  116.   {
  117.     Item::cond_result cond_value;
  118.     conds= remove_eq_conds(thd, conds, &cond_value);
  119.     if (cond_value == Item::COND_FALSE)
  120.       limit= 0;                                   // Impossible WHERE
  121.   }
  122.   // Don't count on usage of 'only index' when calculating which key to use
  123.   table->used_keys.clear_all();
  124.   if (limit)
  125.     select=make_select(table,0,0,conds,&error);
  126.   if (error || !limit ||
  127.       (select && select->check_quick(thd, safe_update, limit)))
  128.   {
  129.     delete select;
  130.     free_underlaid_joins(thd, &thd->lex->select_lex);
  131.     if (error)
  132.     {
  133.       DBUG_RETURN(-1); // Error in where
  134.     }
  135.     send_ok(thd); // No matching records
  136.     DBUG_RETURN(0);
  137.   }
  138.   if (!select && limit != HA_POS_ERROR)
  139.   {
  140.     if ((used_index= get_index_for_order(table, order, limit)) != MAX_KEY)
  141.       need_sort= FALSE;
  142.   }
  143.   /* If running in safe sql mode, don't allow updates without keys */
  144.   if (table->quick_keys.is_clear_all())
  145.   {
  146.     thd->server_status|=SERVER_QUERY_NO_INDEX_USED;
  147.     if (safe_update && !using_limit)
  148.     {
  149.       my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
  150.  ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
  151.       goto err;
  152.     }
  153.   }
  154.   init_ftfuncs(thd, &thd->lex->select_lex, 1);
  155.   
  156.   /* Check if we are modifying a key that we are used to search with */
  157.   if (select && select->quick)
  158.   {
  159.     used_index=select->quick->index;
  160.     used_key_is_modified= (!select->quick->unique_key_range() &&
  161.    check_if_key_used(table, used_index, fields));
  162.   }
  163.   else
  164.   {
  165.     used_key_is_modified= 0;
  166.     if (used_index == MAX_KEY)                  // no index for sort order
  167.       used_index= table->file->key_used_on_scan;
  168.     if (used_index != MAX_KEY)
  169.       used_key_is_modified= check_if_key_used(table, used_index, fields);
  170.   }
  171.   if (used_key_is_modified || order)
  172.   {
  173.     /*
  174.       We can't update table directly;  We must first search after all
  175.       matching rows before updating the table!
  176.     */
  177.     table->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
  178.     if (used_index < MAX_KEY && old_used_keys.is_set(used_index))
  179.     {
  180.       table->key_read=1;
  181.       table->file->extra(HA_EXTRA_KEYREAD);
  182.     }
  183.     /* note: can actually avoid sorting below.. */
  184.     if (order && (need_sort || used_key_is_modified))
  185.     {
  186.       /*
  187. Doing an ORDER BY;  Let filesort find and sort the rows we are going
  188. to update
  189.       */
  190.       uint         length;
  191.       SORT_FIELD  *sortorder;
  192.       ha_rows examined_rows;
  193.       used_index= MAX_KEY;                   // For call to init_read_record()
  194.       table->sort.io_cache = (IO_CACHE *) my_malloc(sizeof(IO_CACHE),
  195.     MYF(MY_FAE | MY_ZEROFILL));
  196.       if (!(sortorder=make_unireg_sortorder(order, &length)) ||
  197.           (table->sort.found_records = filesort(thd, table, sortorder, length,
  198. select, limit,
  199. &examined_rows))
  200.           == HA_POS_ERROR)
  201.       {
  202. free_io_cache(table);
  203. goto err;
  204.       }
  205.       /*
  206. Filesort has already found and selected the rows we want to update,
  207. so we don't need the where clause
  208.       */
  209.       delete select;
  210.       select= 0;
  211.     }
  212.     else
  213.     {
  214.       /*
  215. We are doing a search on a key that is updated. In this case
  216. we go trough the matching rows, save a pointer to them and
  217. update these in a separate loop based on the pointer.
  218.       */
  219.       IO_CACHE tempfile;
  220.       if (open_cached_file(&tempfile, mysql_tmpdir,TEMP_PREFIX,
  221.    DISK_BUFFER_SIZE, MYF(MY_WME)))
  222. goto err;
  223.       if (used_index == MAX_KEY)
  224.         init_read_record(&info,thd,table,select,0,1);
  225.       else
  226.         init_read_record_idx(&info, thd, table, 1, used_index);
  227.       thd->proc_info="Searching rows for update";
  228.       uint tmp_limit= limit;
  229.       while (!(error=info.read_record(&info)) && !thd->killed)
  230.       {
  231. if (!(select && select->skip_record()))
  232. {
  233.   table->file->position(table->record[0]);
  234.   if (my_b_write(&tempfile,table->file->ref,
  235.  table->file->ref_length))
  236.   {
  237.     error=1; /* purecov: inspected */
  238.     break; /* purecov: inspected */
  239.   }
  240.   if (!--limit && using_limit)
  241.   {
  242.     error= -1;
  243.     break;
  244.   }
  245. }
  246.       }
  247.       if (thd->killed && !error)
  248. error= 1; // Aborted
  249.       limit= tmp_limit;
  250.       end_read_record(&info);
  251.      
  252.       /* Change select to use tempfile */
  253.       if (select)
  254.       {
  255. delete select->quick;
  256. if (select->free_cond)
  257.   delete select->cond;
  258. select->quick=0;
  259. select->cond=0;
  260.       }
  261.       else
  262.       {
  263. select= new SQL_SELECT;
  264. select->head=table;
  265.       }
  266.       if (reinit_io_cache(&tempfile,READ_CACHE,0L,0,0))
  267. error=1; /* purecov: inspected */
  268.       select->file=tempfile; // Read row ptrs from this file
  269.       if (error >= 0)
  270. goto err;
  271.     }
  272.     if (table->key_read)
  273.     {
  274.       table->key_read=0;
  275.       table->file->extra(HA_EXTRA_NO_KEYREAD);
  276.     }
  277.   }
  278.   if (ignore)
  279.     table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
  280.   init_read_record(&info,thd,table,select,0,1);
  281.   updated= found= 0;
  282.   thd->count_cuted_fields= CHECK_FIELD_WARN; /* calc cuted fields */
  283.   thd->cuted_fields=0L;
  284.   thd->proc_info="Updating";
  285.   query_id=thd->query_id;
  286.   while (!(error=info.read_record(&info)) && !thd->killed)
  287.   {
  288.     if (!(select && select->skip_record()))
  289.     {
  290.       store_record(table,record[1]);
  291.       if (fill_record(fields,values, 0) || thd->net.report_error)
  292. break; /* purecov: inspected */
  293.       found++;
  294.       if (compare_record(table, query_id))
  295.       {
  296. if (!(error=table->file->update_row((byte*) table->record[1],
  297.     (byte*) table->record[0])))
  298. {
  299.   updated++;
  300. }
  301. else if (!ignore || error != HA_ERR_FOUND_DUPP_KEY)
  302. {
  303.           thd->fatal_error();                   // Force error message
  304.   table->file->print_error(error,MYF(0));
  305.   error= 1;
  306.   break;
  307. }
  308.       }
  309.       if (!--limit && using_limit)
  310.       {
  311. error= -1; // Simulate end of file
  312. break;
  313.       }
  314.     }
  315.     else
  316.       table->file->unlock_row();
  317.     thd->row_count++;
  318.   }
  319.   if (thd->killed && !error)
  320.     error= 1; // Aborted
  321.   end_read_record(&info);
  322.   free_io_cache(table); // If ORDER BY
  323.   delete select;
  324.   thd->proc_info="end";
  325.   VOID(table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY));
  326.   /*
  327.     Invalidate the table in the query cache if something changed.
  328.     This must be before binlog writing and ha_autocommit_...
  329.   */
  330.   if (updated)
  331.     query_cache_invalidate3(thd, table_list, 1);
  332.   transactional_table= table->file->has_transactions();
  333.   log_delayed= (transactional_table || table->tmp_table);
  334.   if ((updated || (error < 0)) && (error <= 0 || !transactional_table))
  335.   {
  336.     mysql_update_log.write(thd,thd->query,thd->query_length);
  337.     if (mysql_bin_log.is_open())
  338.     {
  339.       if (error <= 0)
  340.         thd->clear_error();
  341.       Query_log_event qinfo(thd, thd->query, thd->query_length,
  342.     log_delayed, FALSE);
  343.       if (mysql_bin_log.write(&qinfo) && transactional_table)
  344. error=1; // Rollback update
  345.     }
  346.     if (!log_delayed)
  347.       thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
  348.   }
  349.   if (transactional_table)
  350.   {
  351.     if (ha_autocommit_or_rollback(thd, error >= 0))
  352.       error=1;
  353.   }
  354.   if (thd->lock)
  355.   {
  356.     mysql_unlock_tables(thd, thd->lock);
  357.     thd->lock=0;
  358.   }
  359.   free_underlaid_joins(thd, &thd->lex->select_lex);
  360.   if (error >= 0)
  361.     send_error(thd,thd->killed ? ER_SERVER_SHUTDOWN : 0); /* purecov: inspected */
  362.   else
  363.   {
  364.     char buff[80];
  365.     sprintf(buff, ER(ER_UPDATE_INFO), (ulong) found, (ulong) updated,
  366.     (ulong) thd->cuted_fields);
  367.     send_ok(thd,
  368.     (thd->client_capabilities & CLIENT_FOUND_ROWS) ? found : updated,
  369.     thd->insert_id_used ? thd->insert_id() : 0L,buff);
  370.     DBUG_PRINT("info",("%d records updated",updated));
  371.   }
  372.   thd->count_cuted_fields= CHECK_FIELD_IGNORE; /* calc cuted fields */
  373.   free_io_cache(table);
  374.   DBUG_RETURN(0);
  375. err:
  376.   delete select;
  377.   free_underlaid_joins(thd, &thd->lex->select_lex);
  378.   if (table->key_read)
  379.   {
  380.     table->key_read=0;
  381.     table->file->extra(HA_EXTRA_NO_KEYREAD);
  382.   }
  383.   DBUG_RETURN(-1);
  384. }
  385. /*
  386.   Prepare items in UPDATE statement
  387.   SYNOPSIS
  388.     mysql_prepare_update()
  389.     thd - thread handler
  390.     table_list - global table list
  391.     update_table_list - local table list of UPDATE SELECT_LEX
  392.     conds - conditions
  393.     order_num - number of ORDER BY list entries
  394.     order - ORDER BY clause list
  395.   RETURN VALUE
  396.     0  - OK
  397.     1  - error (message is sent to user)
  398.     -1 - error (message is not sent to user)
  399. */
  400. int mysql_prepare_update(THD *thd, TABLE_LIST *table_list,
  401.  TABLE_LIST *update_table_list,
  402.  Item **conds, uint order_num, ORDER *order)
  403. {
  404.   TABLE *table= table_list->table;
  405.   TABLE_LIST tables;
  406.   List<Item> all_fields;
  407.   DBUG_ENTER("mysql_prepare_update");
  408. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  409.   table->grant.want_privilege= (SELECT_ACL & ~table->grant.privilege);
  410. #endif
  411.   bzero((char*) &tables,sizeof(tables)); // For ORDER BY
  412.   tables.table= table;
  413.   tables.alias= table_list->alias;
  414.   thd->allow_sum_func= 0;
  415.   if (setup_tables(update_table_list) ||
  416.       setup_conds(thd, update_table_list, conds) ||
  417.       thd->lex->select_lex.setup_ref_array(thd, order_num) ||
  418.       setup_order(thd, thd->lex->select_lex.ref_pointer_array,
  419.   update_table_list, all_fields, all_fields, order) ||
  420.       setup_ftfuncs(&thd->lex->select_lex))
  421.     DBUG_RETURN(-1);
  422.   /* Check that we are not using table that we are updating in a sub select */
  423.   if (find_real_table_in_list(table_list->next, 
  424.       table_list->db, table_list->real_name))
  425.   {
  426.     my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->real_name);
  427.     DBUG_RETURN(-1);
  428.   }
  429.   DBUG_RETURN(0);
  430. }
  431. /***************************************************************************
  432.   Update multiple tables from join 
  433. ***************************************************************************/
  434. /*
  435.   Get table map for list of Item_field
  436. */
  437. static table_map get_table_map(List<Item> *items)
  438. {
  439.   List_iterator_fast<Item> item_it(*items);
  440.   Item_field *item;
  441.   table_map map= 0;
  442.   while ((item= (Item_field *) item_it++)) 
  443.     map|= item->used_tables();
  444.   DBUG_PRINT("info",("table_map: 0x%08x", map));
  445.   return map;
  446. }
  447. /*
  448.   Prepare tables for multi-update 
  449.   Analyse which tables need specific privileges and perform locking
  450.   as required
  451. */
  452. int mysql_multi_update_lock(THD *thd,
  453.     TABLE_LIST *table_list,
  454.     List<Item> *fields,
  455.     SELECT_LEX *select_lex)
  456. {
  457.   int res;
  458.   TABLE_LIST *tl;
  459.   TABLE_LIST *update_list= (TABLE_LIST*) thd->lex->select_lex.table_list.first;
  460.   const bool using_lock_tables= thd->locked_tables != 0;
  461.   bool initialized_dervied= 0;
  462.   DBUG_ENTER("mysql_multi_update_lock");
  463.   /*
  464.     The following loop is here to to ensure that we only lock tables
  465.     that we are going to update with a write lock
  466.   */
  467.   for (;;)
  468.   {
  469.     table_map update_tables, derived_tables=0;
  470.     uint tnr, table_count;
  471.     if ((res=open_tables(thd, table_list, &table_count)))
  472.       DBUG_RETURN(res);
  473.     /* Only need to call lock_tables if we are not using LOCK TABLES */
  474.     if (!using_lock_tables &&
  475.         ((res= lock_tables(thd, table_list, table_count))))
  476.       DBUG_RETURN(res);
  477.     if (!initialized_dervied)
  478.     {
  479.       initialized_dervied= 1;
  480.       relink_tables_for_derived(thd);
  481.       if ((res= mysql_handle_derived(thd->lex)))
  482.         DBUG_RETURN(res);
  483.     }
  484.     /*
  485.       Ensure that we have update privilege for all tables and columns in the
  486.       SET part
  487.       While we are here, initialize the table->map field to check which
  488.       tables are updated and updatability of derived tables
  489.     */
  490.     for (tl= update_list, tnr=0 ; tl ; tl=tl->next)
  491.     {
  492.       TABLE *table= tl->table;
  493.       /*
  494.         Update of derived tables is checked later
  495.         We don't check privileges here, becasue then we would get error
  496.         "UPDATE command denided .. for column N" instead of
  497.         "Target table ... is not updatable"
  498.       */
  499.       if (!tl->derived)
  500.         table->grant.want_privilege= (UPDATE_ACL & ~table->grant.privilege);
  501.       table->map= (table_map) 1 << (tnr++);
  502.     }
  503.     if (setup_fields(thd, 0, update_list, *fields, 1, 0, 0))
  504.       DBUG_RETURN(-1);
  505.     update_tables= get_table_map(fields);
  506.     /* Unlock the tables in preparation for relocking */
  507.     if (!using_lock_tables)
  508.     {
  509.       mysql_unlock_tables(thd, thd->lock);
  510.       thd->lock= 0;
  511.     }
  512.     /*
  513.       Count tables and setup timestamp handling
  514.       Set also the table locking strategy according to the update map
  515.     */
  516.     for (tl= update_list; tl; tl= tl->next)
  517.     {
  518.       TABLE_LIST *save= tl->next;
  519.       TABLE *table= tl->table;
  520.       uint wants;
  521.       /* if table will be updated then check that it is unique */
  522.       if (table->map & update_tables)
  523.       {
  524.         /*
  525.           Multi-update can't be constructed over-union => we always have
  526.           single SELECT on top and have to check underlaying SELECTs of it
  527.         */
  528.         if (select_lex->check_updateable_in_subqueries(tl->db,
  529.                                                        tl->real_name))
  530.         {
  531.           my_error(ER_UPDATE_TABLE_USED, MYF(0),
  532.                    tl->real_name);
  533.           DBUG_RETURN(-1);
  534.         }
  535. DBUG_PRINT("info",("setting table `%s` for update", tl->alias));
  536. tl->lock_type= thd->lex->multi_lock_option;
  537.         tl->updating= 1;               // loacal or only list
  538.         if (tl->table_list)
  539.           tl->table_list->updating= 1; // global list (if we have 2 lists)
  540. wants= UPDATE_ACL;
  541.       }
  542.       else
  543.       {
  544.         DBUG_PRINT("info",("setting table `%s` for read-only", tl->alias));
  545. // If we are using the binary log, we need TL_READ_NO_INSERT to get
  546. // correct order of statements. Otherwise, we use a TL_READ lock to
  547. // improve performance.
  548. tl->lock_type= using_update_log ? TL_READ_NO_INSERT : TL_READ;
  549.         tl->updating= 0;               // loacal or only list
  550.         if (tl->table_list)
  551.           tl->table_list->updating= 0; // global list (if we have 2 lists)
  552. wants= SELECT_ACL;
  553.       }
  554.       if (tl->derived)
  555.         derived_tables|= table->map;
  556.       else 
  557.       {
  558.         tl->next= 0;
  559.         if (!using_lock_tables)
  560.   tl->table->reginfo.lock_type= tl->lock_type;
  561.         if (check_access(thd, wants, tl->db, &tl->grant.privilege, 0, 0) ||
  562.             (grant_option && check_grant(thd, wants, tl, 0, 0, 0)))
  563.         {
  564.           tl->next= save;
  565.           DBUG_RETURN(1);
  566.         }
  567.         tl->next= save;
  568.       }
  569.     }
  570.     if (thd->lex->derived_tables && (update_tables & derived_tables))
  571.     {
  572.       // find derived table which cause error
  573.       for (tl= update_list; tl; tl= tl->next)
  574.       {
  575.         if (tl->derived && (update_tables & tl->table->map))
  576.         {
  577.           my_printf_error(ER_NON_UPDATABLE_TABLE, ER(ER_NON_UPDATABLE_TABLE),
  578.                           MYF(0), tl->alias, "UPDATE");
  579.           DBUG_RETURN(-1);
  580.         }
  581.       }
  582.     }
  583.     /* Relock the tables with the correct modes */
  584.     res= lock_tables(thd, table_list, table_count);
  585.     if (using_lock_tables)
  586.       break;                                 // Don't have to do setup_field()
  587.     /*
  588.       We must setup fields again as the file may have been reopened
  589.       during lock_tables 
  590.     */
  591.     {
  592.       List_iterator_fast<Item> field_it(*fields);
  593.       Item_field *item;
  594.       while ((item= (Item_field *) field_it++)) 
  595.       {
  596.         item->field->query_id= 0;
  597.         item->cleanup();
  598.       }
  599.     }
  600.     if (setup_fields(thd, 0, update_list, *fields, 1, 0, 0))
  601.       DBUG_RETURN(-1);
  602.     /*
  603.       If lock succeded and the table map didn't change since the above lock
  604.       we can continue.
  605.     */
  606.     if (!res && update_tables == get_table_map(fields))
  607.       break;
  608.     /*
  609.       There was some very unexpected changes in the table definition between
  610.       open tables and lock tables. Close tables and try again.
  611.     */
  612.     close_thread_tables(thd);
  613.   }
  614.   
  615.   DBUG_RETURN(res);
  616. }
  617. /*
  618.   Setup multi-update handling and call SELECT to do the join
  619. */
  620. int mysql_multi_update(THD *thd,
  621.        TABLE_LIST *table_list,
  622.        List<Item> *fields,
  623.        List<Item> *values,
  624.        COND *conds,
  625.        ulong options,
  626.        enum enum_duplicates handle_duplicates, bool ignore,
  627.        SELECT_LEX_UNIT *unit, SELECT_LEX *select_lex)
  628. {
  629.   int res;
  630.   TABLE_LIST *tl;
  631.   TABLE_LIST *update_list= (TABLE_LIST*) thd->lex->select_lex.table_list.first;
  632.   List<Item> total_list;
  633.   multi_update *result;
  634.   DBUG_ENTER("mysql_multi_update");
  635.   /* Setup timestamp handling */
  636.   for (tl= update_list; tl; tl= tl->next)
  637.   {
  638.     TABLE *table= tl->table;
  639.     /* Only set timestamp column if this is not modified */
  640.     if (table->timestamp_field &&
  641.         table->timestamp_field->query_id == thd->query_id)
  642.       table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
  643.     /* We only need SELECT privilege for columns in the values list */
  644.     table->grant.want_privilege= (SELECT_ACL & ~table->grant.privilege);
  645.   }
  646.   if (!(result=new multi_update(thd, update_list, fields, values,
  647. handle_duplicates, ignore)))
  648.     DBUG_RETURN(-1);
  649.   res= mysql_select(thd, &select_lex->ref_pointer_array,
  650.     select_lex->get_table_list(), select_lex->with_wild,
  651.     total_list,
  652.     conds, 0, (ORDER *) NULL, (ORDER *)NULL, (Item *) NULL,
  653.     (ORDER *)NULL,
  654.     options | SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK,
  655.     result, unit, select_lex);
  656.   delete result;
  657.   DBUG_RETURN(res);
  658. }
  659. multi_update::multi_update(THD *thd_arg, TABLE_LIST *table_list,
  660.    List<Item> *field_list, List<Item> *value_list,
  661.    enum enum_duplicates handle_duplicates_arg, bool ignore_arg)
  662.   :all_tables(table_list), update_tables(0), thd(thd_arg), tmp_tables(0),
  663.    updated(0), found(0), fields(field_list), values(value_list),
  664.    table_count(0), copy_field(0), handle_duplicates(handle_duplicates_arg),
  665.    do_update(1), trans_safe(0), transactional_tables(1), ignore(ignore_arg)
  666. {}
  667. /*
  668.   Connect fields with tables and create list of tables that are updated
  669. */
  670. int multi_update::prepare(List<Item> &not_used_values,
  671.   SELECT_LEX_UNIT *lex_unit)
  672. {
  673.   TABLE_LIST *table_ref;
  674.   SQL_LIST update;
  675.   table_map tables_to_update;
  676.   Item_field *item;
  677.   List_iterator_fast<Item> field_it(*fields);
  678.   List_iterator_fast<Item> value_it(*values);
  679.   uint i, max_fields;
  680.   DBUG_ENTER("multi_update::prepare");
  681.   thd->count_cuted_fields= CHECK_FIELD_WARN;
  682.   thd->cuted_fields=0L;
  683.   thd->proc_info="updating main table";
  684.   tables_to_update= get_table_map(fields);
  685.   if (!tables_to_update)
  686.   {
  687.     my_error(ER_NO_TABLES_USED, MYF(0));
  688.     DBUG_RETURN(1);
  689.   }
  690.   /*
  691.     We have to check values after setup_tables to get used_keys right in
  692.     reference tables
  693.   */
  694.   if (setup_fields(thd, 0, all_tables, *values, 1, 0, 0))
  695.     DBUG_RETURN(1);
  696.   /*
  697.     Save tables beeing updated in update_tables
  698.     update_table->shared is position for table
  699.     Don't use key read on tables that are updated
  700.   */
  701.   update.empty();
  702.   for (table_ref= all_tables;  table_ref; table_ref=table_ref->next)
  703.   {
  704.     TABLE *table=table_ref->table;
  705.     if (tables_to_update & table->map)
  706.     {
  707.       TABLE_LIST *tl= (TABLE_LIST*) thd->memdup((char*) table_ref,
  708. sizeof(*tl));
  709.       if (!tl)
  710. DBUG_RETURN(1);
  711.       update.link_in_list((byte*) tl, (byte**) &tl->next);
  712.       tl->shared= table_count++;
  713.       table->no_keyread=1;
  714.       table->used_keys.clear_all();
  715.       table->pos_in_table_list= tl;
  716.     }
  717.   }
  718.   table_count=  update.elements;
  719.   update_tables= (TABLE_LIST*) update.first;
  720.   tmp_tables = (TABLE **) thd->calloc(sizeof(TABLE *) * table_count);
  721.   tmp_table_param = (TMP_TABLE_PARAM*) thd->calloc(sizeof(TMP_TABLE_PARAM) *
  722.    table_count);
  723.   fields_for_table= (List_item **) thd->alloc(sizeof(List_item *) *
  724.       table_count);
  725.   values_for_table= (List_item **) thd->alloc(sizeof(List_item *) *
  726.       table_count);
  727.   if (thd->is_fatal_error)
  728.     DBUG_RETURN(1);
  729.   for (i=0 ; i < table_count ; i++)
  730.   {
  731.     fields_for_table[i]= new List_item;
  732.     values_for_table[i]= new List_item;
  733.   }
  734.   if (thd->is_fatal_error)
  735.     DBUG_RETURN(1);
  736.   /* Split fields into fields_for_table[] and values_by_table[] */
  737.   while ((item= (Item_field *) field_it++))
  738.   {
  739.     Item *value= value_it++;
  740.     uint offset= item->field->table->pos_in_table_list->shared;
  741.     fields_for_table[offset]->push_back(item);
  742.     values_for_table[offset]->push_back(value);
  743.   }
  744.   if (thd->is_fatal_error)
  745.     DBUG_RETURN(1);
  746.   /* Allocate copy fields */
  747.   max_fields=0;
  748.   for (i=0 ; i < table_count ; i++)
  749.     set_if_bigger(max_fields, fields_for_table[i]->elements);
  750.   copy_field= new Copy_field[max_fields];
  751.   /*
  752.     Mark all copies of tables that are updates to ensure that
  753.     init_read_record() will not try to enable a cache on them
  754.     The problem is that for queries like
  755.     UPDATE t1, t1 AS t2 SET t1.b=t2.c WHERE t1.a=t2.a;
  756.     the row buffer may contain things that doesn't match what is on disk
  757.     which will cause an error when reading a row.
  758.     (This issue is mostly relevent for MyISAM tables)
  759.   */
  760.   for (table_ref= all_tables;  table_ref; table_ref=table_ref->next)
  761.   {
  762.     TABLE *table=table_ref->table;
  763.     if (!(tables_to_update & table->map) && 
  764. find_real_table_in_list(update_tables, table_ref->db,
  765. table_ref->real_name))
  766.       table->no_cache= 1; // Disable row cache
  767.   }
  768.   DBUG_RETURN(thd->is_fatal_error != 0);
  769. }
  770. /*
  771.   Initialize table for multi table
  772.   IMPLEMENTATION
  773.     - Update first table in join on the fly, if possible
  774.     - Create temporary tables to store changed values for all other tables
  775.       that are updated (and main_table if the above doesn't hold).
  776. */
  777. bool
  778. multi_update::initialize_tables(JOIN *join)
  779. {
  780.   TABLE_LIST *table_ref;
  781.   DBUG_ENTER("initialize_tables");
  782.   if ((thd->options & OPTION_SAFE_UPDATES) && error_if_full_join(join))
  783.     DBUG_RETURN(1);
  784.   main_table=join->join_tab->table;
  785.   trans_safe= transactional_tables= main_table->file->has_transactions();
  786.   log_delayed= trans_safe || main_table->tmp_table != NO_TMP_TABLE;
  787.   table_to_update= 0;
  788.   /* Create a temporary table for keys to all tables, except main table */
  789.   for (table_ref= update_tables; table_ref; table_ref=table_ref->next)
  790.   {
  791.     TABLE *table=table_ref->table;
  792.     uint cnt= table_ref->shared;
  793.     Item_field *ifield;
  794.     List<Item> temp_fields= *fields_for_table[cnt];
  795.     ORDER     group;
  796.     if (table == main_table) // First table in join
  797.     {
  798.       if (safe_update_on_fly(join->join_tab, &temp_fields))
  799.       {
  800. table_to_update= main_table; // Update table on the fly
  801. continue;
  802.       }
  803.     }
  804.     TMP_TABLE_PARAM *tmp_param= tmp_table_param+cnt;
  805.     /*
  806.       Create a temporary table to store all fields that are changed for this
  807.       table. The first field in the temporary table is a pointer to the
  808.       original row so that we can find and update it
  809.     */
  810.     /* ok to be on stack as this is not referenced outside of this func */
  811.     Field_string offset(table->file->ref_length, 0, "offset",
  812. table, &my_charset_bin);
  813.     if (!(ifield= new Item_field(((Field *) &offset))))
  814.       DBUG_RETURN(1);
  815.     ifield->maybe_null= 0;
  816.     if (temp_fields.push_front(ifield))
  817.       DBUG_RETURN(1);
  818.     /* Make an unique key over the first field to avoid duplicated updates */
  819.     bzero((char*) &group, sizeof(group));
  820.     group.asc= 1;
  821.     group.item= (Item**) temp_fields.head_ref();
  822.     tmp_param->quick_group=1;
  823.     tmp_param->field_count=temp_fields.elements;
  824.     tmp_param->group_parts=1;
  825.     tmp_param->group_length= table->file->ref_length;
  826.     if (!(tmp_tables[cnt]=create_tmp_table(thd,
  827.    tmp_param,
  828.    temp_fields,
  829.    (ORDER*) &group, 0, 0,
  830.    TMP_TABLE_ALL_COLUMNS,
  831.    HA_POS_ERROR,
  832.    (char *) "")))
  833.       DBUG_RETURN(1);
  834.     tmp_tables[cnt]->file->extra(HA_EXTRA_WRITE_CACHE);
  835.   }
  836.   DBUG_RETURN(0);
  837. }
  838. /*
  839.   Check if table is safe to update on fly
  840.   SYNOPSIS
  841.     safe_update_on_fly
  842.     join_tab How table is used in join
  843.     fields Fields that are updated
  844.   NOTES
  845.     We can update the first table in join on the fly if we know that
  846.     a row in this tabel will never be read twice. This is true under
  847.     the folloing conditions:
  848.     - We are doing a table scan and the data is in a separate file (MyISAM) or
  849.       if we don't update a clustered key.
  850.     - We are doing a range scan and we don't update the scan key or
  851.       the primary key for a clustered table handler.
  852.   WARNING
  853.     This code is a bit dependent of how make_join_readinfo() works.
  854.   RETURN
  855.     0 Not safe to update
  856.     1 Safe to update
  857. */
  858. static bool safe_update_on_fly(JOIN_TAB *join_tab, List<Item> *fields)
  859. {
  860.   TABLE *table= join_tab->table;
  861.   switch (join_tab->type) {
  862.   case JT_SYSTEM:
  863.   case JT_CONST:
  864.   case JT_EQ_REF:
  865.     return 1; // At most one matching row
  866.   case JT_REF:
  867.     return !check_if_key_used(table, join_tab->ref.key, *fields);
  868.   case JT_ALL:
  869.     /* If range search on index */
  870.     if (join_tab->quick)
  871.       return !check_if_key_used(table, join_tab->quick->index,
  872. *fields);
  873.     /* If scanning in clustered key */
  874.     if ((table->file->table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
  875. table->primary_key < MAX_KEY)
  876.       return !check_if_key_used(table, table->primary_key, *fields);
  877.     return 1;
  878.   default:
  879.     break; // Avoid compler warning
  880.   }
  881.   return 0;
  882. }
  883. multi_update::~multi_update()
  884. {
  885.   TABLE_LIST *table;
  886.   for (table= update_tables ; table; table= table->next)
  887.     table->table->no_keyread= table->table->no_cache= 0;
  888.   if (tmp_tables)
  889.   {
  890.     for (uint cnt = 0; cnt < table_count; cnt++)
  891.     {
  892.       if (tmp_tables[cnt])
  893.       {
  894. free_tmp_table(thd, tmp_tables[cnt]);
  895. tmp_table_param[cnt].cleanup();
  896.       }
  897.     }
  898.   }
  899.   if (copy_field)
  900.     delete [] copy_field;
  901.   thd->count_cuted_fields= CHECK_FIELD_IGNORE; // Restore this setting
  902.   if (!trans_safe)
  903.     thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
  904. }
  905. bool multi_update::send_data(List<Item> &not_used_values)
  906. {
  907.   TABLE_LIST *cur_table;
  908.   DBUG_ENTER("multi_update::send_data");
  909.   for (cur_table= update_tables; cur_table ; cur_table= cur_table->next)
  910.   {
  911.     TABLE *table= cur_table->table;
  912.     /*
  913.       Check if we are using outer join and we didn't find the row
  914.       or if we have already updated this row in the previous call to this
  915.       function.
  916.       The same row may be presented here several times in a join of type
  917.       UPDATE t1 FROM t1,t2 SET t1.a=t2.a
  918.       In this case we will do the update for the first found row combination.
  919.       The join algorithm guarantees that we will not find the a row in
  920.       t1 several times.
  921.     */
  922.     if (table->status & (STATUS_NULL_ROW | STATUS_UPDATED))
  923.       continue;
  924.     uint offset= cur_table->shared;
  925.     table->file->position(table->record[0]);
  926.     if (table == table_to_update)
  927.     {
  928.       table->status|= STATUS_UPDATED;
  929.       store_record(table,record[1]);
  930.       if (fill_record(*fields_for_table[offset], *values_for_table[offset], 0))
  931. DBUG_RETURN(1);
  932.       found++;
  933.       if (compare_record(table, thd->query_id))
  934.       {
  935. int error;
  936. if (!updated++)
  937. {
  938.   /*
  939.     Inform the main table that we are going to update the table even
  940.     while we may be scanning it.  This will flush the read cache
  941.     if it's used.
  942.   */
  943.   main_table->file->extra(HA_EXTRA_PREPARE_FOR_UPDATE);
  944. }
  945. if ((error=table->file->update_row(table->record[1],
  946.    table->record[0])))
  947. {
  948.   updated--;
  949.   if (!ignore || error != HA_ERR_FOUND_DUPP_KEY)
  950.   {
  951.             thd->fatal_error();                 // Force error message
  952.     table->file->print_error(error,MYF(0));
  953.     DBUG_RETURN(1);
  954.   }
  955. }
  956.       }
  957.     }
  958.     else
  959.     {
  960.       int error;
  961.       TABLE *tmp_table= tmp_tables[offset];
  962.       fill_record(tmp_table->field+1, *values_for_table[offset], 1);
  963.       found++;
  964.       /* Store pointer to row */
  965.       memcpy((char*) tmp_table->field[0]->ptr,
  966.      (char*) table->file->ref, table->file->ref_length);
  967.       /* Write row, ignoring duplicated updates to a row */
  968.       if ((error= tmp_table->file->write_row(tmp_table->record[0])) &&
  969.   (error != HA_ERR_FOUND_DUPP_KEY &&
  970.    error != HA_ERR_FOUND_DUPP_UNIQUE))
  971.       {
  972. if (create_myisam_from_heap(thd, tmp_table, tmp_table_param + offset,
  973.     error, 1))
  974. {
  975.   do_update=0;
  976.   DBUG_RETURN(1); // Not a table_is_full error
  977. }
  978.       }
  979.     }
  980.   }
  981.   DBUG_RETURN(0);
  982. }
  983. void multi_update::send_error(uint errcode,const char *err)
  984. {
  985.   /* First send error what ever it is ... */
  986.   ::send_error(thd,errcode,err);
  987.   /* If nothing updated return */
  988.   if (!updated)
  989.     return;
  990.   /* Something already updated so we have to invalidate cache */
  991.   query_cache_invalidate3(thd, update_tables, 1);
  992.   /*
  993.     If all tables that has been updated are trans safe then just do rollback.
  994.     If not attempt to do remaining updates.
  995.   */
  996.   if (trans_safe)
  997.     ha_rollback_stmt(thd);
  998.   else if (do_update && table_count > 1)
  999.   {
  1000.     /* Add warning here */
  1001.     VOID(do_updates(0));
  1002.   }
  1003. }
  1004. int multi_update::do_updates(bool from_send_error)
  1005. {
  1006.   TABLE_LIST *cur_table;
  1007.   int local_error;
  1008.   ha_rows org_updated;
  1009.   TABLE *table, *tmp_table;
  1010.   DBUG_ENTER("do_updates");
  1011.   do_update= 0; // Don't retry this function
  1012.   if (!found)
  1013.     DBUG_RETURN(0);
  1014.   for (cur_table= update_tables; cur_table ; cur_table= cur_table->next)
  1015.   {
  1016.     byte *ref_pos;
  1017.     table = cur_table->table;
  1018.     if (table == table_to_update)
  1019.       continue; // Already updated
  1020.     org_updated= updated;
  1021.     tmp_table= tmp_tables[cur_table->shared];
  1022.     tmp_table->file->extra(HA_EXTRA_CACHE); // Change to read cache
  1023.     (void) table->file->ha_rnd_init(0);
  1024.     table->file->extra(HA_EXTRA_NO_CACHE);
  1025.     /*
  1026.       Setup copy functions to copy fields from temporary table
  1027.     */
  1028.     List_iterator_fast<Item> field_it(*fields_for_table[cur_table->shared]);
  1029.     Field **field= tmp_table->field+1; // Skip row pointer
  1030.     Copy_field *copy_field_ptr= copy_field, *copy_field_end;
  1031.     for ( ; *field ; field++)
  1032.     {
  1033.       Item_field *item= (Item_field* ) field_it++;
  1034.       (copy_field_ptr++)->set(item->field, *field, 0);
  1035.     }
  1036.     copy_field_end=copy_field_ptr;
  1037.     if ((local_error = tmp_table->file->ha_rnd_init(1)))
  1038.       goto err;
  1039.     ref_pos= (byte*) tmp_table->field[0]->ptr;
  1040.     for (;;)
  1041.     {
  1042.       if (thd->killed && trans_safe)
  1043. goto err;
  1044.       if ((local_error=tmp_table->file->rnd_next(tmp_table->record[0])))
  1045.       {
  1046. if (local_error == HA_ERR_END_OF_FILE)
  1047.   break;
  1048. if (local_error == HA_ERR_RECORD_DELETED)
  1049.   continue; // May happen on dup key
  1050. goto err;
  1051.       }
  1052.       if ((local_error= table->file->rnd_pos(table->record[0], ref_pos)))
  1053. goto err;
  1054.       table->status|= STATUS_UPDATED;
  1055.       store_record(table,record[1]);
  1056.       /* Copy data from temporary table to current table */
  1057.       for (copy_field_ptr=copy_field;
  1058.    copy_field_ptr != copy_field_end;
  1059.    copy_field_ptr++)
  1060. (*copy_field_ptr->do_copy)(copy_field_ptr);
  1061.       if (compare_record(table, thd->query_id))
  1062.       {
  1063. if ((local_error=table->file->update_row(table->record[1],
  1064.  table->record[0])))
  1065. {
  1066.   if (!ignore || local_error != HA_ERR_FOUND_DUPP_KEY)
  1067.     goto err;
  1068. }
  1069. updated++;
  1070. if (table->tmp_table != NO_TMP_TABLE)
  1071.   log_delayed= 1;
  1072.       }
  1073.     }
  1074.     if (updated != org_updated)
  1075.     {
  1076.       if (table->tmp_table != NO_TMP_TABLE)
  1077. log_delayed= 1; // Tmp tables forces delay log
  1078.       if (table->file->has_transactions())
  1079. log_delayed= transactional_tables= 1;
  1080.       else
  1081. trans_safe= 0; // Can't do safe rollback
  1082.     }
  1083.     (void) table->file->ha_rnd_end();
  1084.     (void) tmp_table->file->ha_rnd_end();
  1085.   }
  1086.   DBUG_RETURN(0);
  1087. err:
  1088.   if (!from_send_error)
  1089.   {
  1090.     thd->fatal_error();
  1091.     table->file->print_error(local_error,MYF(0));
  1092.   }
  1093.   (void) table->file->ha_rnd_end();
  1094.   (void) tmp_table->file->ha_rnd_end();
  1095.   if (updated != org_updated)
  1096.   {
  1097.     if (table->tmp_table != NO_TMP_TABLE)
  1098.       log_delayed= 1;
  1099.     if (table->file->has_transactions())
  1100.       log_delayed= transactional_tables= 1;
  1101.     else
  1102.       trans_safe= 0;
  1103.   }
  1104.   DBUG_RETURN(1);
  1105. }
  1106. /* out: 1 if error, 0 if success */
  1107. bool multi_update::send_eof()
  1108. {
  1109.   char buff[80];
  1110.   thd->proc_info="updating reference tables";
  1111.   /* Does updates for the last n - 1 tables, returns 0 if ok */
  1112.   int local_error = (table_count) ? do_updates(0) : 0;
  1113.   thd->proc_info= "end";
  1114.   /* We must invalidate the query cache before binlog writing and
  1115.   ha_autocommit_... */
  1116.   if (updated)
  1117.   {
  1118.     query_cache_invalidate3(thd, update_tables, 1);
  1119.   }
  1120.   /*
  1121.     Write the SQL statement to the binlog if we updated
  1122.     rows and we succeeded or if we updated some non
  1123.     transacational tables.
  1124.     Note that if we updated nothing we don't write to the binlog (TODO:
  1125.     fix this).
  1126.   */
  1127.   if (updated && (local_error <= 0 || !trans_safe))
  1128.   {
  1129.     mysql_update_log.write(thd,thd->query,thd->query_length);
  1130.     if (mysql_bin_log.is_open())
  1131.     {
  1132.       if (local_error <= 0)
  1133.         thd->clear_error();
  1134.       Query_log_event qinfo(thd, thd->query, thd->query_length,
  1135.     log_delayed, FALSE);
  1136.       if (mysql_bin_log.write(&qinfo) && trans_safe)
  1137. local_error= 1; // Rollback update
  1138.     }
  1139.     if (!log_delayed)
  1140.       thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
  1141.   }
  1142.   if (transactional_tables)
  1143.   {
  1144.     if (ha_autocommit_or_rollback(thd, local_error != 0))
  1145.       local_error=1;
  1146.   }
  1147.   if (local_error > 0) // if the above log write did not fail ...
  1148.   {
  1149.     /* Safety: If we haven't got an error before (should not happen) */
  1150.     my_message(ER_UNKNOWN_ERROR, "An error occured in multi-table update",
  1151.        MYF(0));
  1152.     ::send_error(thd);
  1153.     return 1;
  1154.   }
  1155.   sprintf(buff, ER(ER_UPDATE_INFO), (ulong) found, (ulong) updated,
  1156.   (ulong) thd->cuted_fields);
  1157.   ::send_ok(thd,
  1158.     (thd->client_capabilities & CLIENT_FOUND_ROWS) ? found : updated,
  1159.     thd->insert_id_used ? thd->insert_id() : 0L,buff);
  1160.   return 0;
  1161. }